/mandos/trunk : revision 94

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

#

4

# Mandos server - give out binary blobs to connecting clients.

5

#

6

# This program is partly derived from an example program for an Avahi

7

# service publisher, downloaded from

8

# <http://avahi.org/wiki/PythonPublishExample>. This includes the

9

# methods "add" and "remove" in the "AvahiService" class, the

10

# "server_state_changed" and "entry_group_state_changed" functions,

11

# and some lines in "main".

12

#

13

# Everything else is

14

15

#

16

# This program is free software: you can redistribute it and/or modify

17

# it under the terms of the GNU General Public License as published by

18

# the Free Software Foundation, either version 3 of the License, or

19

# (at your option) any later version.

20

#

21

# This program is distributed in the hope that it will be useful,

22

# but WITHOUT ANY WARRANTY; without even the implied warranty of

23

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

24

# GNU General Public License for more details.

25

#

26

# You should have received a copy of the GNU General Public License

27

# along with this program. If not, see <http://www.gnu.org/licenses/>.

28

#

29

# Contact the authors at <mandos@fukt.bsnet.se>.

30

#

3

31

4

32

from __future__ import division

5

33

24

52

import subprocess

25

53

import atexit

26

54

import stat

55

import logging

56

import logging.handlers

27

57

28

58

import dbus

29

59

import gobject

31

61

from dbus.mainloop.glib import DBusGMainLoop

32

62

import ctypes

33

63

34

import logging

35

import logging.handlers

64

version = "1.0"

36

65

37

66

logger = logging.Logger('mandos')

38

67

syslogger = logging.handlers.SysLogHandler\

39

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

68

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

69

address = "/dev/log")

40

70

syslogger.setFormatter(logging.Formatter\

41

('%(levelname)s: %(message)s'))

71

('Mandos: %(levelname)s: %(message)s'))

42

72

logger.addHandler(syslogger)

43

del syslogger

44

45

# This variable is used to optionally bind to a specified interface.

46

# It is a global variable to fit in with the other variables from the

47

# Avahi server example code.

48

serviceInterface = avahi.IF_UNSPEC

49

# From the Avahi server example code:

50

serviceName = "Mandos"

51

serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html

52

servicePort = None # Not known at startup

53

serviceTXT = [] # TXT record for the service

54

domain = "" # Domain to publish on, default to .local

55

host = "" # Host to publish records for, default to localhost

56

group = None #our entry group

57

rename_count = 12 # Counter so we only rename after collisions a

58

# sensible number of times

73

74

console = logging.StreamHandler()

75

console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'

76

' %(message)s'))

77

logger.addHandler(console)

78

79

class AvahiError(Exception):

80

def __init__(self, value):

81

self.value = value

82

def __str__(self):

83

return repr(self.value)

84

85

class AvahiServiceError(AvahiError):

86

pass

87

88

class AvahiGroupError(AvahiError):

89

pass

90

91

92

class AvahiService(object):

93

"""An Avahi (Zeroconf) service.

94

Attributes:

95

interface: integer; avahi.IF_UNSPEC or an interface index.

96

Used to optionally bind to the specified interface.

97

name: string; Example: 'Mandos'

98

type: string; Example: '_mandos._tcp'.

99

See <http://www.dns-sd.org/ServiceTypes.html>

100

port: integer; what port to announce

101

TXT: list of strings; TXT record for the service

102

domain: string; Domain to publish on, default to .local if empty.

103

host: string; Host to publish records for, default is localhost

104

max_renames: integer; maximum number of renames

105

rename_count: integer; counter so we only rename after collisions

106

a sensible number of times

107

"""

108

def __init__(self, interface = avahi.IF_UNSPEC, name = None,

109

type = None, port = None, TXT = None, domain = "",

110

host = "", max_renames = 32768):

111

self.interface = interface

112

self.name = name

113

self.type = type

114

self.port = port

115

if TXT is None:

116

self.TXT = []

117

else:

118

self.TXT = TXT

119

self.domain = domain

120

self.host = host

121

self.rename_count = 0

122

self.max_renames = max_renames

123

def rename(self):

124

"""Derived from the Avahi example code"""

125

if self.rename_count >= self.max_renames:

126

logger.critical(u"No suitable service name found after %i"

127

u" retries, exiting.", rename_count)

128

raise AvahiServiceError("Too many renames")

129

self.name = server.GetAlternativeServiceName(self.name)

130

logger.info(u"Changing name to %r ...", str(self.name))

131

syslogger.setFormatter(logging.Formatter\

132

('Mandos (%s): %%(levelname)s:'

133

' %%(message)s' % self.name))

134

self.remove()

135

self.add()

136

self.rename_count += 1

137

def remove(self):

138

"""Derived from the Avahi example code"""

139

if group is not None:

140

group.Reset()

141

def add(self):

142

"""Derived from the Avahi example code"""

143

global group

144

if group is None:

145

group = dbus.Interface\

146

(bus.get_object(avahi.DBUS_NAME,

147

server.EntryGroupNew()),

148

avahi.DBUS_INTERFACE_ENTRY_GROUP)

149

group.connect_to_signal('StateChanged',

150

entry_group_state_changed)

151

logger.debug(u"Adding service '%s' of type '%s' ...",

152

service.name, service.type)

153

group.AddService(

154

self.interface, # interface

155

avahi.PROTO_INET6, # protocol

156

dbus.UInt32(0), # flags

157

self.name, self.type,

158

self.domain, self.host,

159

dbus.UInt16(self.port),

160

avahi.string_array_to_txt_array(self.TXT))

161

group.Commit()

162

163

# From the Avahi example code:

164

group = None # our entry group

59

165

# End of Avahi example code

60

166

61

167

66

172

fingerprint: string (40 or 32 hexadecimal digits); used to

67

173

uniquely identify the client

68

174

secret: bytestring; sent verbatim (over TLS) to client

69

fqdn: string (FQDN); available for use by the checker command

70

created: datetime.datetime()

71

last_seen: datetime.datetime() or None if not yet seen

72

timeout: datetime.timedelta(); How long from last_seen until

73

this client is invalid

175

host: string; available for use by the checker command

176

created: datetime.datetime(); object creation, not client host

177

last_checked_ok: datetime.datetime() or None if not yet checked OK

178

timeout: datetime.timedelta(); How long from last_checked_ok

179

until this client is invalid

74

180

interval: datetime.timedelta(); How often to start a new checker

75

181

stop_hook: If set, called by stop() as stop_hook(self)

76

182

checker: subprocess.Popen(); a running checker process used

77

183

to see if the client lives.

78

Is None if no process is running.

184

'None' if no process is running.

79

185

checker_initiator_tag: a gobject event source tag, or None

80

186

stop_initiator_tag: - '' -

81

187

checker_callback_tag: - '' -

82

188

checker_command: string; External command which is run to check if

83

client lives. %()s expansions are done at

189

client lives. %() expansions are done at

84

190

runtime with vars(self) as dict, so that for

85

191

instance %(name)s can be used in the command.

86

192

Private attibutes:

87

193

_timeout: Real variable for 'timeout'

88

194

_interval: Real variable for 'interval'

89

_timeout_milliseconds: Used by gobject.timeout_add()

195

_timeout_milliseconds: Used when calling gobject.timeout_add()

90

196

_interval_milliseconds: - '' -

91

197

"""

92

198

def _set_timeout(self, timeout):

112

218

interval = property(lambda self: self._interval,

113

219

_set_interval)

114

220

del _set_interval

115

def __init__(self, name=None, options=None, stop_hook=None,

116

fingerprint=None, secret=None, secfile=None,

117

fqdn=None, timeout=None, interval=-1, checker=None):

221

def __init__(self, name = None, stop_hook=None, config={}):

222

"""Note: the 'checker' key in 'config' sets the

223

'checker_command' attribute and *not* the 'checker'

224

attribute."""

118

225

self.name = name

119

# Uppercase and remove spaces from fingerprint

120

# for later comparison purposes with return value of

121

# the fingerprint() function

122

self.fingerprint = fingerprint.upper().replace(u" ", u"")

123

if secret:

124

self.secret = secret.decode(u"base64")

125

elif secfile:

126

sf = open(secfile)

226

logger.debug(u"Creating client %r", self.name)

227

# Uppercase and remove spaces from fingerprint for later

228

# comparison purposes with return value from the fingerprint()

229

# function

230

self.fingerprint = config["fingerprint"].upper()\

231

.replace(u" ", u"")

232

logger.debug(u" Fingerprint: %s", self.fingerprint)

233

if "secret" in config:

234

self.secret = config["secret"].decode(u"base64")

235

elif "secfile" in config:

236

sf = open(config["secfile"])

127

237

self.secret = sf.read()

128

238

sf.close()

129

239

else:

130

raise RuntimeError(u"No secret or secfile for client %s"

131

% self.name)

132

self.fqdn = fqdn # string

240

raise TypeError(u"No secret or secfile for client %s"

241

% self.name)

242

self.host = config.get("host", "")

133

243

self.created = datetime.datetime.now()

134

self.last_seen = None

135

if timeout is None:

136

self.timeout = options.timeout

137

else:

138

self.timeout = string_to_delta(timeout)

139

if interval == -1:

140

self.interval = options.interval

141

else:

142

self.interval = string_to_delta(interval)

244

self.last_checked_ok = None

245

self.timeout = string_to_delta(config["timeout"])

246

self.interval = string_to_delta(config["interval"])

143

247

self.stop_hook = stop_hook

144

248

self.checker = None

145

249

self.checker_initiator_tag = None

146

250

self.stop_initiator_tag = None

147

251

self.checker_callback_tag = None

148

self.check_command = checker

252

self.check_command = config["checker"]

149

253

def start(self):

150

"""Start this clients checker and timeout hooks"""

254

"""Start this client's checker and timeout hooks"""

151

255

# Schedule a new checker to be started an 'interval' from now,

152

256

# and every interval from then on.

153

257

self.checker_initiator_tag = gobject.timeout_add\

161

265

self.stop)

162

266

def stop(self):

163

267

"""Stop this client.

164

The possibility that this client might be restarted is left

165

open, but not currently used."""

166

logger.debug(u"Stopping client %s", self.name)

167

self.secret = None

168

if self.stop_initiator_tag:

268

The possibility that a client might be restarted is left open,

269

but not currently used."""

270

# If this client doesn't have a secret, it is already stopped.

271

if hasattr(self, "secret") and self.secret:

272

logger.info(u"Stopping client %s", self.name)

273

self.secret = None

274

else:

275

return False

276

if getattr(self, "stop_initiator_tag", False):

169

277

gobject.source_remove(self.stop_initiator_tag)

170

278

self.stop_initiator_tag = None

171

if self.checker_initiator_tag:

279

if getattr(self, "checker_initiator_tag", False):

172

280

gobject.source_remove(self.checker_initiator_tag)

173

281

self.checker_initiator_tag = None

174

282

self.stop_checker()

177

285

# Do not run this again if called by a gobject.timeout_add

178

286

return False

179

287

def __del__(self):

180

# Some code duplication here and in stop()

181

if hasattr(self, "stop_initiator_tag") \

182

and self.stop_initiator_tag:

183

gobject.source_remove(self.stop_initiator_tag)

184

self.stop_initiator_tag = None

185

if hasattr(self, "checker_initiator_tag") \

186

and self.checker_initiator_tag:

187

gobject.source_remove(self.checker_initiator_tag)

188

self.checker_initiator_tag = None

189

self.stop_checker()

288

self.stop_hook = None

289

self.stop()

190

290

def checker_callback(self, pid, condition):

191

291

"""The checker has completed, so take appropriate actions."""

192

292

now = datetime.datetime.now()

293

self.checker_callback_tag = None

294

self.checker = None

193

295

if os.WIFEXITED(condition) \

194

296

and (os.WEXITSTATUS(condition) == 0):

195

logger.debug(u"Checker for %(name)s succeeded",

196

vars(self))

197

self.last_seen = now

297

logger.info(u"Checker for %(name)s succeeded",

298

vars(self))

299

self.last_checked_ok = now

198

300

gobject.source_remove(self.stop_initiator_tag)

199

301

self.stop_initiator_tag = gobject.timeout_add\

200

302

(self._timeout_milliseconds,

203

305

logger.warning(u"Checker for %(name)s crashed?",

204

306

vars(self))

205

307

else:

206

logger.debug(u"Checker for %(name)s failed",

207

vars(self))

208

self.checker = None

209

self.checker_callback_tag = None

308

logger.info(u"Checker for %(name)s failed",

309

vars(self))

210

310

def start_checker(self):

211

311

"""Start a new checker subprocess if one is not running.

212

312

If a checker already exists, leave it running and do

213

313

nothing."""

314

# The reason for not killing a running checker is that if we

315

# did that, then if a checker (for some reason) started

316

# running slowly and taking more than 'interval' time, the

317

# client would inevitably timeout, since no checker would get

318

# a chance to run to completion. If we instead leave running

319

# checkers alone, the checker would have to take more time

320

# than 'timeout' for the client to be declared invalid, which

321

# is as it should be.

214

322

if self.checker is None:

215

323

try:

216

command = self.check_command % self.fqdn

324

# In case check_command has exactly one % operator

325

command = self.check_command % self.host

217

326

except TypeError:

327

# Escape attributes for the shell

218

328

escaped_attrs = dict((key, re.escape(str(val)))

219

329

for key, val in

220

330

vars(self).iteritems())

221

331

try:

222

332

command = self.check_command % escaped_attrs

223

333

except TypeError, error:

224

logger.critical(u'Could not format string "%s":'

225

u' %s', self.check_command, error)

334

logger.error(u'Could not format string "%s":'

335

u' %s', self.check_command, error)

226

336

return True # Try again later

227

337

try:

228

logger.debug(u"Starting checker %r for %s",

229

command, self.name)

230

self.checker = subprocess.\

231

Popen(command,

232

close_fds=True, shell=True,

233

cwd="/")

338

logger.info(u"Starting checker %r for %s",

339

command, self.name)

340

# We don't need to redirect stdout and stderr, since

341

# in normal mode, that is already done by daemon(),

342

# and in debug mode we don't want to. (Stdin is

343

# always replaced by /dev/null.)

344

self.checker = subprocess.Popen(command,

345

close_fds=True,

346

shell=True, cwd="/")

234

347

self.checker_callback_tag = gobject.child_watch_add\

235

348

(self.checker.pid,

236

349

self.checker_callback)

237

except subprocess.OSError, error:

350

except OSError, error:

238

351

logger.error(u"Failed to start subprocess: %s",

239

352

error)

240

353

# Re-run this periodically if run by gobject.timeout_add

241

354

return True

242

355

def stop_checker(self):

243

356

"""Force the checker process, if any, to stop."""

244

if not hasattr(self, "checker") or self.checker is None:

357

if self.checker_callback_tag:

358

gobject.source_remove(self.checker_callback_tag)

359

self.checker_callback_tag = None

360

if getattr(self, "checker", None) is None:

245

361

return

246

gobject.source_remove(self.checker_callback_tag)

247

self.checker_callback_tag = None

248

os.kill(self.checker.pid, signal.SIGTERM)

249

if self.checker.poll() is None:

250

os.kill(self.checker.pid, signal.SIGKILL)

362

logger.debug(u"Stopping checker for %(name)s", vars(self))

363

try:

364

os.kill(self.checker.pid, signal.SIGTERM)

365

#os.sleep(0.5)

366

#if self.checker.poll() is None:

367

# os.kill(self.checker.pid, signal.SIGKILL)

368

except OSError, error:

369

if error.errno != errno.ESRCH: # No such process

370

raise

251

371

self.checker = None

252

def still_valid(self, now=None):

372

def still_valid(self):

253

373

"""Has the timeout not yet passed for this client?"""

254

if now is None:

255

now = datetime.datetime.now()

256

if self.last_seen is None:

374

now = datetime.datetime.now()

375

if self.last_checked_ok is None:

257

376

return now < (self.created + self.timeout)

258

377

else:

259

return now < (self.last_seen + self.timeout)

378

return now < (self.last_checked_ok + self.timeout)

260

379

261

380

262

381

def peer_certificate(session):

263

"Return an OpenPGP data packet string for the peer's certificate"

382

"Return the peer's OpenPGP certificate as a bytestring"

264

383

# If not an OpenPGP certificate...

265

384

if gnutls.library.functions.gnutls_certificate_type_get\

266

385

(session._c_object) \

277

396

278

397

279

398

def fingerprint(openpgp):

280

"Convert an OpenPGP data string to a hexdigit fingerprint string"

281

# New empty GnuTLS certificate

282

crt = gnutls.library.types.gnutls_openpgp_crt_t()

283

gnutls.library.functions.gnutls_openpgp_crt_init\

284

(ctypes.byref(crt))

399

"Convert an OpenPGP bytestring to a hexdigit fingerprint string"

285

400

# New GnuTLS "datum" with the OpenPGP public key

286

401

datum = gnutls.library.types.gnutls_datum_t\

287

402

(ctypes.cast(ctypes.c_char_p(openpgp),

288

403

ctypes.POINTER(ctypes.c_ubyte)),

289

404

ctypes.c_uint(len(openpgp)))

405

# New empty GnuTLS certificate

406

crt = gnutls.library.types.gnutls_openpgp_crt_t()

407

gnutls.library.functions.gnutls_openpgp_crt_init\

408

(ctypes.byref(crt))

290

409

# Import the OpenPGP public key into the certificate

291

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

292

(crt,

293

ctypes.byref(datum),

294

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

410

gnutls.library.functions.gnutls_openpgp_crt_import\

411

(crt, ctypes.byref(datum),

412

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

295

413

# New buffer for the fingerprint

296

414

buffer = ctypes.create_string_buffer(20)

297

415

buffer_length = ctypes.c_size_t()

313

431

Note: This will run in its own forked process."""

314

432

315

433

def handle(self):

316

logger.debug(u"TCP connection from: %s",

434

logger.info(u"TCP connection from: %s",

317

435

unicode(self.client_address))

318

session = gnutls.connection.ClientSession(self.request,

319

gnutls.connection.\

320

X509Credentials())

436

session = gnutls.connection.ClientSession\

437

(self.request, gnutls.connection.X509Credentials())

438

439

line = self.request.makefile().readline()

440

logger.debug(u"Protocol version: %r", line)

441

try:

442

if int(line.strip().split()[0]) > 1:

443

raise RuntimeError

444

except (ValueError, IndexError, RuntimeError), error:

445

logger.error(u"Unknown protocol version: %s", error)

446

return

447

448

# Note: gnutls.connection.X509Credentials is really a generic

449

# GnuTLS certificate credentials object so long as no X.509

450

# keys are added to it. Therefore, we can use it here despite

451

# using OpenPGP certificates.

321

452

322

453

#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",

323

454

# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",

324

455

# "+DHE-DSS"))

325

priority = "SECURE256"

326

456

priority = "NORMAL" # Fallback default, since this

457

# MUST be set.

458

if self.server.settings["priority"]:

459

priority = self.server.settings["priority"]

327

460

gnutls.library.functions.gnutls_priority_set_direct\

328

461

(session._c_object, priority, None);

329

462

330

463

try:

331

464

session.handshake()

332

465

except gnutls.errors.GNUTLSError, error:

333

logger.debug(u"Handshake failed: %s", error)

466

logger.warning(u"Handshake failed: %s", error)

334

467

# Do not run session.bye() here: the session is not

335

468

# established. Just abandon the request.

336

469

return

337

470

try:

338

471

fpr = fingerprint(peer_certificate(session))

339

472

except (TypeError, gnutls.errors.GNUTLSError), error:

340

logger.debug(u"Bad certificate: %s", error)

473

logger.warning(u"Bad certificate: %s", error)

341

474

session.bye()

342

475

return

343

476

logger.debug(u"Fingerprint: %s", fpr)

344

477

client = None

345

for c in clients:

478

for c in self.server.clients:

346

479

if c.fingerprint == fpr:

347

480

client = c

348

481

break

482

if not client:

483

logger.warning(u"Client not found for fingerprint: %s",

484

fpr)

485

session.bye()

486

return

349

487

# Have to check if client.still_valid(), since it is possible

350

488

# that the client timed out while establishing the GnuTLS

351

489

# session.

352

if (not client) or (not client.still_valid()):

353

if client:

354

logger.debug(u"Client %(name)s is invalid",

355

vars(client))

356

else:

357

logger.debug(u"Client not found for fingerprint: %s",

358

fpr)

490

if not client.still_valid():

491

logger.warning(u"Client %(name)s is invalid",

492

vars(client))

359

493

session.bye()

360

494

return

361

495

sent_size = 0

371

505

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

372

506

"""IPv6 TCP server. Accepts 'None' as address and/or port.

373

507

Attributes:

374

options: Command line options

508

settings: Server settings

375

509

clients: Set() of Client objects

376

510

"""

377

511

address_family = socket.AF_INET6

378

512

def __init__(self, *args, **kwargs):

379

if "options" in kwargs:

380

self.options = kwargs["options"]

381

del kwargs["options"]

513

if "settings" in kwargs:

514

self.settings = kwargs["settings"]

515

del kwargs["settings"]

382

516

if "clients" in kwargs:

383

517

self.clients = kwargs["clients"]

384

518

del kwargs["clients"]

387

521

"""This overrides the normal server_bind() function

388

522

to bind to an interface if one was specified, and also NOT to

389

523

bind to an address or port if they were not specified."""

390

if self.options.interface:

391

if not hasattr(socket, "SO_BINDTODEVICE"):

392

# From /usr/include/asm-i486/socket.h

393

socket.SO_BINDTODEVICE = 25

524

if self.settings["interface"]:

525

# 25 is from /usr/include/asm-i486/socket.h

526

SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)

394

527

try:

395

528

self.socket.setsockopt(socket.SOL_SOCKET,

396

socket.SO_BINDTODEVICE,

397

self.options.interface)

529

SO_BINDTODEVICE,

530

self.settings["interface"])

398

531

except socket.error, error:

399

532

if error[0] == errno.EPERM:

400

logger.warning(u"No permission to"

401

u" bind to interface %s",

402

self.options.interface)

533

logger.error(u"No permission to"

534

u" bind to interface %s",

535

self.settings["interface"])

403

536

else:

404

537

raise error

405

538

# Only bind(2) the socket if we really need to.

408

541

in6addr_any = "::"

409

542

self.server_address = (in6addr_any,

410

543

self.server_address[1])

411

elif self.server_address[1] is None:

544

elif not self.server_address[1]:

412

545

self.server_address = (self.server_address[0],

413

546

0)

547

# if self.settings["interface"]:

548

# self.server_address = (self.server_address[0],

549

# 0, # port

550

# 0, # flowinfo

551

# if_nametoindex

552

# (self.settings

553

# ["interface"]))

414

554

return super(type(self), self).server_bind()

415

555

416

556

427

567

datetime.timedelta(1)

428

568

>>> string_to_delta(u'1w')

429

569

datetime.timedelta(7)

570

>>> string_to_delta('5m 30s')

571

datetime.timedelta(0, 330)

430

572

"""

431

try:

432

suffix=unicode(interval[-1])

433

value=int(interval[:-1])

434

if suffix == u"d":

435

delta = datetime.timedelta(value)

436

elif suffix == u"s":

437

delta = datetime.timedelta(0, value)

438

elif suffix == u"m":

439

delta = datetime.timedelta(0, 0, 0, 0, value)

440

elif suffix == u"h":

441

delta = datetime.timedelta(0, 0, 0, 0, 0, value)

442

elif suffix == u"w":

443

delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

444

else:

573

timevalue = datetime.timedelta(0)

574

for s in interval.split():

575

try:

576

suffix=unicode(s[-1])

577

value=int(s[:-1])

578

if suffix == u"d":

579

delta = datetime.timedelta(value)

580

elif suffix == u"s":

581

delta = datetime.timedelta(0, value)

582

elif suffix == u"m":

583

delta = datetime.timedelta(0, 0, 0, 0, value)

584

elif suffix == u"h":

585

delta = datetime.timedelta(0, 0, 0, 0, 0, value)

586

elif suffix == u"w":

587

delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

588

else:

589

raise ValueError

590

except (ValueError, IndexError):

445

591

raise ValueError

446

except (ValueError, IndexError):

447

raise ValueError

448

return delta

449

450

451

def add_service():

452

"""From the Avahi server example code"""

453

global group, serviceName, serviceType, servicePort, serviceTXT, \

454

domain, host

455

if group is None:

456

group = dbus.Interface(

457

bus.get_object( avahi.DBUS_NAME,

458

server.EntryGroupNew()),

459

avahi.DBUS_INTERFACE_ENTRY_GROUP)

460

group.connect_to_signal('StateChanged',

461

entry_group_state_changed)

462

logger.debug(u"Adding service '%s' of type '%s' ...",

463

serviceName, serviceType)

464

465

group.AddService(

466

serviceInterface, # interface

467

avahi.PROTO_INET6, # protocol

468

dbus.UInt32(0), # flags

469

serviceName, serviceType,

470

domain, host,

471

dbus.UInt16(servicePort),

472

avahi.string_array_to_txt_array(serviceTXT))

473

group.Commit()

474

475

476

def remove_service():

477

"""From the Avahi server example code"""

478

global group

479

480

if not group is None:

481

group.Reset()

592

timevalue += delta

593

return timevalue

482

594

483

595

484

596

def server_state_changed(state):

485

"""From the Avahi server example code"""

597

"""Derived from the Avahi example code"""

486

598

if state == avahi.SERVER_COLLISION:

487

logger.warning(u"Server name collision")

488

remove_service()

599

logger.error(u"Server name collision")

600

service.remove()

489

601

elif state == avahi.SERVER_RUNNING:

490

add_service()

602

service.add()

491

603

492

604

493

605

def entry_group_state_changed(state, error):

494

"""From the Avahi server example code"""

495

global serviceName, server, rename_count

496

606

"""Derived from the Avahi example code"""

497

607

logger.debug(u"state change: %i", state)

498

608

499

609

if state == avahi.ENTRY_GROUP_ESTABLISHED:

500

610

logger.debug(u"Service established.")

501

611

elif state == avahi.ENTRY_GROUP_COLLISION:

502

503

rename_count = rename_count - 1

504

if rename_count > 0:

505

name = server.GetAlternativeServiceName(name)

506

logger.warning(u"Service name collision, "

507

u"changing name to '%s' ...", name)

508

remove_service()

509

add_service()

510

511

else:

512

logger.error(u"No suitable service name found after %i"

513

u" retries, exiting.", n_rename)

514

killme(1)

612

logger.warning(u"Service name collision.")

613

service.rename()

515

614

elif state == avahi.ENTRY_GROUP_FAILURE:

516

logger.error(u"Error in group state changed %s",

517

unicode(error))

518

killme(1)

519

615

logger.critical(u"Error in group state changed %s",

616

unicode(error))

617

raise AvahiGroupError("State changed: %s", str(error))

520

618

521

619

def if_nametoindex(interface):

522

"""Call the C function if_nametoindex()"""

620

"""Call the C function if_nametoindex(), or equivalent"""

621

global if_nametoindex

523

622

try:

524

libc = ctypes.cdll.LoadLibrary("libc.so.6")

525

return libc.if_nametoindex(interface)

623

if "ctypes.util" not in sys.modules:

624

import ctypes.util

625

if_nametoindex = ctypes.cdll.LoadLibrary\

626

(ctypes.util.find_library("c")).if_nametoindex

526

627

except (OSError, AttributeError):

527

628

if "struct" not in sys.modules:

528

629

import struct

529

630

if "fcntl" not in sys.modules:

530

631

import fcntl

531

SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h

532

s = socket.socket()

533

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

534

struct.pack("16s16x", interface))

535

s.close()

536

interface_index = struct.unpack("I", ifreq[16:20])[0]

537

return interface_index

538

539

540

def daemon(nochdir, noclose):

632

def if_nametoindex(interface):

633

"Get an interface index the hard way, i.e. using fcntl()"

634

SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h

635

s = socket.socket()

636

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

637

struct.pack("16s16x", interface))

638

s.close()

639

interface_index = struct.unpack("I", ifreq[16:20])[0]

640

return interface_index

641

return if_nametoindex(interface)

642

643

644

def daemon(nochdir = False, noclose = False):

541

645

"""See daemon(3). Standard BSD Unix function.

542

646

This should really exist as os.daemon, but it doesn't (yet)."""

543

647

if os.fork():

545

649

os.setsid()

546

650

if not nochdir:

547

651

os.chdir("/")

652

if os.fork():

653

sys.exit()

548

654

if not noclose:

549

655

# Close all standard open file descriptors

550

null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)

656

null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)

551

657

if not stat.S_ISCHR(os.fstat(null).st_mode):

552

658

raise OSError(errno.ENODEV,

553

659

"/dev/null not a character device")

558

664

os.close(null)

559

665

560

666

561

def killme(status = 0):

562

logger.debug("Stopping server with exit status %d", status)

563

exitstatus = status

564

if main_loop_started:

565

main_loop.quit()

566

else:

567

sys.exit(status)

568

569

570

if __name__ == '__main__':

571

exitstatus = 0

667

def main():

668

global main_loop_started

572

669

main_loop_started = False

573

parser = OptionParser()

670

671

parser = OptionParser(version = "%%prog %s" % version)

574

672

parser.add_option("-i", "--interface", type="string",

575

default=None, metavar="IF",

576

help="Bind to interface IF")

577

parser.add_option("-p", "--port", type="int", default=None,

673

metavar="IF", help="Bind to interface IF")

674

parser.add_option("-a", "--address", type="string",

675

help="Address to listen for requests on")

676

parser.add_option("-p", "--port", type="int",

578

677

help="Port number to receive requests on")

579

parser.add_option("--timeout", type="string", # Parsed later

580

default="1h",

581

help="Amount of downtime allowed for clients")

582

parser.add_option("--interval", type="string", # Parsed later

583

default="5m",

584

help="How often to check that a client is up")

585

678

parser.add_option("--check", action="store_true", default=False,

586

679

help="Run self-test")

587

parser.add_option("--debug", action="store_true", default=False,

588

help="Debug mode")

680

parser.add_option("--debug", action="store_true",

681

help="Debug mode; run in foreground and log to"

682

" terminal")

683

parser.add_option("--priority", type="string", help="GnuTLS"

684

" priority string (see GnuTLS documentation)")

685

parser.add_option("--servicename", type="string", metavar="NAME",

686

help="Zeroconf service name")

687

parser.add_option("--configdir", type="string",

688

default="/etc/mandos", metavar="DIR",

689

help="Directory to search for configuration"

690

" files")

589

691

(options, args) = parser.parse_args()

590

692

591

693

if options.check:

593

695

doctest.testmod()

594

696

sys.exit()

595

697

596

# Parse the time arguments

597

try:

598

options.timeout = string_to_delta(options.timeout)

599

except ValueError:

600

parser.error("option --timeout: Unparseable time")

601

try:

602

options.interval = string_to_delta(options.interval)

603

except ValueError:

604

parser.error("option --interval: Unparseable time")

605

606

# Parse config file

607

defaults = { "checker": "fping -q -- %%(fqdn)s" }

608

client_config = ConfigParser.SafeConfigParser(defaults)

609

#client_config.readfp(open("secrets.conf"), "secrets.conf")

610

client_config.read("mandos-clients.conf")

611

612

# From the Avahi server example code

698

# Default values for config file for server-global settings

699

server_defaults = { "interface": "",

700

"address": "",

701

"port": "",

702

"debug": "False",

703

"priority":

704

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",

705

"servicename": "Mandos",

706

}

707

708

# Parse config file for server-global settings

709

server_config = ConfigParser.SafeConfigParser(server_defaults)

710

del server_defaults

711

server_config.read(os.path.join(options.configdir, "mandos.conf"))

712

# Convert the SafeConfigParser object to a dict

713

server_settings = server_config.defaults()

714

# Use getboolean on the boolean config option

715

server_settings["debug"] = server_config.getboolean\

716

("DEFAULT", "debug")

717

del server_config

718

719

# Override the settings from the config file with command line

720

# options, if set.

721

for option in ("interface", "address", "port", "debug",

722

"priority", "servicename", "configdir"):

723

value = getattr(options, option)

724

if value is not None:

725

server_settings[option] = value

726

del options

727

# Now we have our good server settings in "server_settings"

728

729

debug = server_settings["debug"]

730

731

if not debug:

732

syslogger.setLevel(logging.WARNING)

733

console.setLevel(logging.WARNING)

734

735

if server_settings["servicename"] != "Mandos":

736

syslogger.setFormatter(logging.Formatter\

737

('Mandos (%s): %%(levelname)s:'

738

' %%(message)s'

739

% server_settings["servicename"]))

740

741

# Parse config file with clients

742

client_defaults = { "timeout": "1h",

743

"interval": "5m",

744

"checker": "fping -q -- %(host)s",

745

"host": "",

746

}

747

client_config = ConfigParser.SafeConfigParser(client_defaults)

748

client_config.read(os.path.join(server_settings["configdir"],

749

"clients.conf"))

750

751

global service

752

service = AvahiService(name = server_settings["servicename"],

753

type = "_mandos._tcp", );

754

if server_settings["interface"]:

755

service.interface = if_nametoindex(server_settings["interface"])

756

757

global main_loop

758

global bus

759

global server

760

# From the Avahi example code

613

761

DBusGMainLoop(set_as_default=True )

614

762

main_loop = gobject.MainLoop()

615

763

bus = dbus.SystemBus()

618

766

avahi.DBUS_INTERFACE_SERVER )

619

767

# End of Avahi example code

620

768

621

debug = options.debug

622

623

if debug:

624

console = logging.StreamHandler()

625

# console.setLevel(logging.DEBUG)

626

console.setFormatter(logging.Formatter\

627

('%(levelname)s: %(message)s'))

628

logger.addHandler(console)

629

del console

630

631

769

clients = Set()

632

770

def remove_from_clients(client):

633

771

clients.remove(client)

634

772

if not clients:

635

logger.debug(u"No clients left, exiting")

636

killme()

773

logger.critical(u"No clients left, exiting")

774

sys.exit()

637

775

638

clients.update(Set(Client(name=section, options=options,

776

clients.update(Set(Client(name = section,

639

777

stop_hook = remove_from_clients,

640

**(dict(client_config\

641

.items(section))))

778

config

779

= dict(client_config.items(section)))

642

780

for section in client_config.sections()))

643

644

if not debug:

645

daemon(False, False)

781

if not clients:

782

logger.critical(u"No clients defined")

783

sys.exit(1)

784

785

if debug:

786

# Redirect stdin so all checkers get /dev/null

787

null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)

788

os.dup2(null, sys.stdin.fileno())

789

if null > 2:

790

os.close(null)

791

else:

792

# No console logging

793

logger.removeHandler(console)

794

# Close all input and output, do double fork, etc.

795

daemon()

796

797

pidfilename = "/var/run/mandos/mandos.pid"

798

pid = os.getpid()

799

try:

800

pidfile = open(pidfilename, "w")

801

pidfile.write(str(pid) + "\n")

802

pidfile.close()

803

del pidfile

804

except IOError, err:

805

logger.error(u"Could not write %s file with PID %d",

806

pidfilename, os.getpid())

646

807

647

808

def cleanup():

648

809

"Cleanup function; run on exit"

649

810

global group

650

# From the Avahi server example code

811

# From the Avahi example code

651

812

if not group is None:

652

813

group.Free()

653

814

group = None

654

815

# End of Avahi example code

655

816

656

for client in clients:

817

while clients:

818

client = clients.pop()

657

819

client.stop_hook = None

658

820

client.stop()

659

821

661

823

662

824

if not debug:

663

825

signal.signal(signal.SIGINT, signal.SIG_IGN)

664

signal.signal(signal.SIGHUP, lambda signum, frame: killme())

665

signal.signal(signal.SIGTERM, lambda signum, frame: killme())

826

signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())

827

signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())

666

828

667

829

for client in clients:

668

830

client.start()

669

831

670

tcp_server = IPv6_TCPServer((None, options.port),

832

tcp_server = IPv6_TCPServer((server_settings["address"],

833

server_settings["port"]),

671

834

tcp_handler,

672

options=options,

835

settings=server_settings,

673

836

clients=clients)

674

# Find out what random port we got

675

servicePort = tcp_server.socket.getsockname()[1]

676

logger.debug(u"Now listening on port %d", servicePort)

677

678

if options.interface is not None:

679

serviceInterface = if_nametoindex(options.interface)

680

681

# From the Avahi server example code

682

server.connect_to_signal("StateChanged", server_state_changed)

683

try:

684

server_state_changed(server.GetState())

685

except dbus.exceptions.DBusException, error:

686

logger.critical(u"DBusException: %s", error)

687

killme(1)

688

# End of Avahi example code

689

690

gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,

691

lambda *args, **kwargs:

692

tcp_server.handle_request(*args[2:],

693

**kwargs) or True)

694

try:

837

# Find out what port we got

838

service.port = tcp_server.socket.getsockname()[1]

839

logger.info(u"Now listening on address %r, port %d, flowinfo %d,"

840

u" scope_id %d" % tcp_server.socket.getsockname())

841

842

#service.interface = tcp_server.socket.getsockname()[3]

843

844

try:

845

# From the Avahi example code

846

server.connect_to_signal("StateChanged", server_state_changed)

847

try:

848

server_state_changed(server.GetState())

849

except dbus.exceptions.DBusException, error:

850

logger.critical(u"DBusException: %s", error)

851

sys.exit(1)

852

# End of Avahi example code

853

854

gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,

855

lambda *args, **kwargs:

856

tcp_server.handle_request\

857

(*args[2:], **kwargs) or True)

858

859

logger.debug(u"Starting main loop")

695

860

main_loop_started = True

696

861

main_loop.run()

862

except AvahiError, error:

863

logger.critical(u"AvahiError: %s" + unicode(error))

864

sys.exit(1)

697

865

except KeyboardInterrupt:

698

866

if debug:

699

867

print

700

701

sys.exit(exitstatus)

868

869

if __name__ == '__main__':

870

main()