/mandos/release : revision 24.1.20

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".

9

# following functions: "AvahiService.add", "AvahiService.remove",

10

# "server_state_changed", "entry_group_state_changed", and some lines

11

# in "main".

12

#

13

# Everything else is

14

15

14

16

15

#

17

16

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

18

17

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

25

24

# GNU General Public License for more details.

26

25

#

27

26

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

28

# along with this program. If not, see

29

# <http://www.gnu.org/licenses/>.

27

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

30

28

#

31

29

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

32

30

#

33

31

34

from __future__ import division, with_statement, absolute_import

32

from __future__ import division

35

33

36

34

import SocketServer

37

35

import socket

36

import select

38

37

from optparse import OptionParser

39

38

import datetime

40

39

import errno

55

54

import stat

56

55

import logging

57

56

import logging.handlers

58

import pwd

59

from contextlib import closing

60

57

61

58

import dbus

62

import dbus.service

63

59

import gobject

64

60

import avahi

65

61

from dbus.mainloop.glib import DBusGMainLoop

66

62

import ctypes

67

import ctypes.util

68

69

version = "1.0.2"

63

64

# Brief description of the operation of this program:

65

#

66

# This server announces itself as a Zeroconf service. Connecting

67

# clients use the TLS protocol, with the unusual quirk that this

68

# server program acts as a TLS "client" while a connecting client acts

69

# as a TLS "server". The client (acting as a TLS "server") must

70

# supply an OpenPGP certificate, and the fingerprint of this

71

# certificate is used by this server to look up (in a list read from a

72

# file at start time) which binary blob to give the client. No other

73

# authentication or authorization is done by this server.

74

70

75

71

76

logger = logging.Logger('mandos')

72

syslogger = (logging.handlers.SysLogHandler

73

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

74

address = "/dev/log"))

75

syslogger.setFormatter(logging.Formatter

76

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

77

syslogger = logging.handlers.SysLogHandler\

78

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

79

syslogger.setFormatter(logging.Formatter\

80

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

77

81

logger.addHandler(syslogger)

82

del syslogger

78

83

79

console = logging.StreamHandler()

80

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

81

' %(message)s'))

82

logger.addHandler(console)

83

84

85

class AvahiError(Exception):

85

86

def __init__(self, value):

86

87

self.value = value

87

super(AvahiError, self).__init__()

88

def __str__(self):

89

return repr(self.value)

90

112

a sensible number of times

113

"""

114

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

115

servicetype = None, port = None, TXT = None,

116

domain = "", host = "", max_renames = 32768):

115

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

116

host = "", max_renames = 12):

117

self.interface = interface

118

self.name = name

119

self.type = servicetype

119

self.type = type

120

self.port = port

121

self.TXT = TXT if TXT is not None else []

121

if TXT is None:

122

self.TXT = []

123

else:

124

self.TXT = TXT

122

125

self.domain = domain

123

126

self.host = host

124

127

self.rename_count = 0

125

self.max_renames = max_renames

126

128

def rename(self):

127

129

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

128

130

if self.rename_count >= self.max_renames:

129

logger.critical(u"No suitable Zeroconf service name found"

130

u" after %i retries, exiting.",

131

self.rename_count)

131

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

132

u" retries, exiting.", rename_count)

132

133

raise AvahiServiceError("Too many renames")

133

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

134

logger.info(u"Changing Zeroconf service name to %r ...",

135

str(self.name))

136

syslogger.setFormatter(logging.Formatter

137

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

138

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

134

name = server.GetAlternativeServiceName(name)

135

logger.error(u"Changing name to %r ...", name)

139

136

self.remove()

140

137

self.add()

141

138

self.rename_count += 1

147

144

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

148

145

global group

149

146

if group is None:

150

group = dbus.Interface(bus.get_object

151

(avahi.DBUS_NAME,

147

group = dbus.Interface\

148

(bus.get_object(avahi.DBUS_NAME,

152

149

server.EntryGroupNew()),

153

avahi.DBUS_INTERFACE_ENTRY_GROUP)

150

avahi.DBUS_INTERFACE_ENTRY_GROUP)

154

151

group.connect_to_signal('StateChanged',

155

152

entry_group_state_changed)

156

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

153

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

157

154

service.name, service.type)

158

155

group.AddService(

159

156

self.interface, # interface

170

167

# End of Avahi example code

171

168

172

169

173

def _datetime_to_dbus_struct(dt, variant_level=0):

174

"""Convert a UTC datetime.datetime() to a D-Bus struct.

175

The format is special to this application, since we could not find

176

any other standard way."""

177

return dbus.Struct((dbus.Int16(dt.year),

178

dbus.Byte(dt.month),

179

dbus.Byte(dt.day),

180

dbus.Byte(dt.hour),

181

dbus.Byte(dt.minute),

182

dbus.Byte(dt.second),

183

dbus.UInt32(dt.microsecond)),

184

signature="nyyyyyu",

185

variant_level=variant_level)

186

187

188

class Client(dbus.service.Object):

170

class Client(object):

189

171

"""A representation of a client host served by this server.

190

172

Attributes:

191

name: string; from the config file, used in log messages

173

name: string; from the config file, used in log messages

192

174

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

193

175

uniquely identify the client

194

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

195

host: string; available for use by the checker command

196

created: datetime.datetime(); (UTC) object creation

197

last_started: datetime.datetime(); (UTC)

198

started: bool()

199

last_checked_ok: datetime.datetime(); (UTC) or None

200

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

201

until this client is invalid

202

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

203

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

204

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

205

to see if the client lives.

206

'None' if no process is running.

176

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

177

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

178

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

179

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

180

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

181

until this client is invalid

182

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

183

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

184

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

185

to see if the client lives.

186

'None' if no process is running.

207

187

checker_initiator_tag: a gobject event source tag, or None

208

188

stop_initiator_tag: - '' -

209

189

checker_callback_tag: - '' -

211

191

client lives. %() expansions are done at

212

192

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

213

193

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

214

dbus_object_path: dbus.ObjectPath

215

194

Private attibutes:

216

195

_timeout: Real variable for 'timeout'

217

196

_interval: Real variable for 'interval'

219

198

_interval_milliseconds: - '' -

220

199

"""

221

200

def _set_timeout(self, timeout):

222

"Setter function for the 'timeout' attribute"

201

"Setter function for 'timeout' attribute"

223

202

self._timeout = timeout

224

203

self._timeout_milliseconds = ((self.timeout.days

225

204

* 24 * 60 * 60 * 1000)

226

205

+ (self.timeout.seconds * 1000)

227

206

+ (self.timeout.microseconds

228

207

// 1000))

229

# Emit D-Bus signal

230

self.PropertyChanged(dbus.String(u"timeout"),

231

(dbus.UInt64(self._timeout_milliseconds,

232

variant_level=1)))

233

timeout = property(lambda self: self._timeout, _set_timeout)

208

timeout = property(lambda self: self._timeout,

209

_set_timeout)

234

210

del _set_timeout

235

236

211

def _set_interval(self, interval):

237

"Setter function for the 'interval' attribute"

212

"Setter function for 'interval' attribute"

238

213

self._interval = interval

239

214

self._interval_milliseconds = ((self.interval.days

240

215

* 24 * 60 * 60 * 1000)

242

217

* 1000)

243

218

+ (self.interval.microseconds

244

219

// 1000))

245

# Emit D-Bus signal

246

self.PropertyChanged(dbus.String(u"interval"),

247

(dbus.UInt64(self._interval_milliseconds,

248

variant_level=1)))

249

interval = property(lambda self: self._interval, _set_interval)

220

interval = property(lambda self: self._interval,

221

_set_interval)

250

222

del _set_interval

251

252

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

223

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

253

224

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

254

225

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

255

226

attribute."""

256

self.dbus_object_path = (dbus.ObjectPath

257

("/Mandos/clients/"

258

+ name.replace(".", "_")))

259

dbus.service.Object.__init__(self, bus,

260

self.dbus_object_path)

261

if config is None:

262

config = {}

263

227

self.name = name

264

228

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

265

229

# Uppercase and remove spaces from fingerprint for later

266

230

# comparison purposes with return value from the fingerprint()

267

231

# function

268

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

269

.replace(u" ", u""))

232

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

233

.replace(u" ", u"")

270

234

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

271

235

if "secret" in config:

272

236

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

273

237

elif "secfile" in config:

274

with closing(open(os.path.expanduser

275

(os.path.expandvars

276

(config["secfile"])))) as secfile:

277

self.secret = secfile.read()

238

sf = open(config["secfile"])

239

self.secret = sf.read()

240

sf.close()

278

241

else:

279

242

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

280

243

% self.name)

281

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

282

self.created = datetime.datetime.utcnow()

283

self.started = False

284

self.last_started = None

244

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

245

self.created = datetime.datetime.now()

285

246

self.last_checked_ok = None

286

247

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

287

248

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

290

251

self.checker_initiator_tag = None

291

252

self.stop_initiator_tag = None

292

253

self.checker_callback_tag = None

293

self.checker_command = config["checker"]

294

254

self.check_command = config["checker"]

295

255

def start(self):

296

256

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

297

self.last_started = datetime.datetime.utcnow()

298

257

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

299

258

# and every interval from then on.

300

self.checker_initiator_tag = (gobject.timeout_add

301

(self._interval_milliseconds,

302

self.start_checker))

259

self.checker_initiator_tag = gobject.timeout_add\

260

(self._interval_milliseconds,

261

self.start_checker)

303

262

# Also start a new checker *right now*.

304

263

self.start_checker()

305

264

# Schedule a stop() when 'timeout' has passed

306

self.stop_initiator_tag = (gobject.timeout_add

307

(self._timeout_milliseconds,

308

self.stop))

309

self.started = True

310

# Emit D-Bus signal

311

self.PropertyChanged(dbus.String(u"started"),

312

dbus.Boolean(True, variant_level=1))

313

self.PropertyChanged(dbus.String(u"last_started"),

314

(_datetime_to_dbus_struct

315

(self.last_started, variant_level=1)))

316

265

self.stop_initiator_tag = gobject.timeout_add\

266

(self._timeout_milliseconds,

267

self.stop)

317

268

def stop(self):

318

"""Stop this client."""

319

if not getattr(self, "started", False):

269

"""Stop this client.

270

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

271

but not currently used."""

272

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

273

if self.secret:

274

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

275

self.secret = None

276

else:

320

277

return False

321

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

322

278

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

323

279

gobject.source_remove(self.stop_initiator_tag)

324

280

self.stop_initiator_tag = None

328

284

self.stop_checker()

329

285

if self.stop_hook:

330

286

self.stop_hook(self)

331

self.started = False

332

# Emit D-Bus signal

333

self.PropertyChanged(dbus.String(u"started"),

334

dbus.Boolean(False, variant_level=1))

335

287

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

336

288

return False

337

338

289

def __del__(self):

339

290

self.stop_hook = None

340

291

self.stop()

341

342

def checker_callback(self, pid, condition, command):

292

def checker_callback(self, pid, condition):

343

293

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

294

now = datetime.datetime.now()

344

295

self.checker_callback_tag = None

345

296

self.checker = None

346

# Emit D-Bus signal

347

self.PropertyChanged(dbus.String(u"checker_running"),

348

dbus.Boolean(False, variant_level=1))

349

if (os.WIFEXITED(condition)

350

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

297

if os.WIFEXITED(condition) \

298

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

351

299

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

352

300

vars(self))

353

# Emit D-Bus signal

354

self.CheckerCompleted(dbus.Boolean(True),

355

dbus.UInt16(condition),

356

dbus.String(command))

357

self.bump_timeout()

301

self.last_checked_ok = now

302

gobject.source_remove(self.stop_initiator_tag)

303

self.stop_initiator_tag = gobject.timeout_add\

304

(self._timeout_milliseconds,

305

self.stop)

358

306

elif not os.WIFEXITED(condition):

359

307

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

360

308

vars(self))

361

# Emit D-Bus signal

362

self.CheckerCompleted(dbus.Boolean(False),

363

dbus.UInt16(condition),

364

dbus.String(command))

365

309

else:

366

310

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

367

311

vars(self))

368

# Emit D-Bus signal

369

self.CheckerCompleted(dbus.Boolean(False),

370

dbus.UInt16(condition),

371

dbus.String(command))

372

373

def bump_timeout(self):

374

"""Bump up the timeout for this client.

375

This should only be called when the client has been seen,

376

alive and well.

377

"""

378

self.last_checked_ok = datetime.datetime.utcnow()

379

gobject.source_remove(self.stop_initiator_tag)

380

self.stop_initiator_tag = (gobject.timeout_add

381

(self._timeout_milliseconds,

382

self.stop))

383

self.PropertyChanged(dbus.String(u"last_checked_ok"),

384

(_datetime_to_dbus_struct

385

(self.last_checked_ok,

386

variant_level=1)))

387

388

312

def start_checker(self):

389

313

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

390

314

If a checker already exists, leave it running and do

399

323

# is as it should be.

400

324

if self.checker is None:

401

325

try:

402

# In case checker_command has exactly one % operator

403

command = self.checker_command % self.host

326

# In case check_command has exactly one % operator

327

command = self.check_command % self.fqdn

404

328

except TypeError:

405

329

# Escape attributes for the shell

406

330

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

407

331

for key, val in

408

332

vars(self).iteritems())

409

333

try:

410

command = self.checker_command % escaped_attrs

334

command = self.check_command % escaped_attrs

411

335

except TypeError, error:

412

336

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

413

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

337

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

414

338

return True # Try again later

415

339

try:

416

340

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

417

341

command, self.name)

418

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

419

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

420

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

421

# always replaced by /dev/null.)

422

342

self.checker = subprocess.Popen(command,

423

343

close_fds=True,

424

344

shell=True, cwd="/")

425

# Emit D-Bus signal

426

self.CheckerStarted(command)

427

self.PropertyChanged(dbus.String("checker_running"),

428

dbus.Boolean(True, variant_level=1))

429

self.checker_callback_tag = (gobject.child_watch_add

430

(self.checker.pid,

431

self.checker_callback,

432

data=command))

433

except OSError, error:

345

self.checker_callback_tag = gobject.child_watch_add\

346

(self.checker.pid,

347

self.checker_callback)

348

except subprocess.OSError, error:

434

349

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

435

350

error)

436

351

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

437

352

return True

438

439

353

def stop_checker(self):

440

354

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

441

355

if self.checker_callback_tag:

443

357

self.checker_callback_tag = None

444

358

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

445

359

return

446

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

360

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

447

361

try:

448

362

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

449

363

#os.sleep(0.5)

453

367

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

454

368

raise

455

369

self.checker = None

456

self.PropertyChanged(dbus.String(u"checker_running"),

457

dbus.Boolean(False, variant_level=1))

458

459

370

def still_valid(self):

460

371

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

461

if not getattr(self, "started", False):

462

return False

463

now = datetime.datetime.utcnow()

372

now = datetime.datetime.now()

464

373

if self.last_checked_ok is None:

465

374

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

466

375

else:

467

376

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

468

469

## D-Bus methods & signals

470

_interface = u"org.mandos_system.Mandos.Client"

471

472

# BumpTimeout - method

473

BumpTimeout = dbus.service.method(_interface)(bump_timeout)

474

BumpTimeout.__name__ = "BumpTimeout"

475

476

# CheckerCompleted - signal

477

@dbus.service.signal(_interface, signature="bqs")

478

def CheckerCompleted(self, success, condition, command):

479

"D-Bus signal"

480

pass

481

482

# CheckerStarted - signal

483

@dbus.service.signal(_interface, signature="s")

484

def CheckerStarted(self, command):

485

"D-Bus signal"

486

pass

487

488

# GetAllProperties - method

489

@dbus.service.method(_interface, out_signature="a{sv}")

490

def GetAllProperties(self):

491

"D-Bus method"

492

return dbus.Dictionary({

493

dbus.String("name"):

494

dbus.String(self.name, variant_level=1),

495

dbus.String("fingerprint"):

496

dbus.String(self.fingerprint, variant_level=1),

497

dbus.String("host"):

498

dbus.String(self.host, variant_level=1),

499

dbus.String("created"):

500

_datetime_to_dbus_struct(self.created,

501

variant_level=1),

502

dbus.String("last_started"):

503

(_datetime_to_dbus_struct(self.last_started,

504

variant_level=1)

505

if self.last_started is not None

506

else dbus.Boolean(False, variant_level=1)),

507

dbus.String("started"):

508

dbus.Boolean(self.started, variant_level=1),

509

dbus.String("last_checked_ok"):

510

(_datetime_to_dbus_struct(self.last_checked_ok,

511

variant_level=1)

512

if self.last_checked_ok is not None

513

else dbus.Boolean (False, variant_level=1)),

514

dbus.String("timeout"):

515

dbus.UInt64(self._timeout_milliseconds,

516

variant_level=1),

517

dbus.String("interval"):

518

dbus.UInt64(self._interval_milliseconds,

519

variant_level=1),

520

dbus.String("checker"):

521

dbus.String(self.checker_command,

522

variant_level=1),

523

dbus.String("checker_running"):

524

dbus.Boolean(self.checker is not None,

525

variant_level=1),

526

}, signature="sv")

527

528

# IsStillValid - method

529

IsStillValid = (dbus.service.method(_interface, out_signature="b")

530

(still_valid))

531

IsStillValid.__name__ = "IsStillValid"

532

533

# PropertyChanged - signal

534

@dbus.service.signal(_interface, signature="sv")

535

def PropertyChanged(self, property, value):

536

"D-Bus signal"

537

pass

538

539

# SetChecker - method

540

@dbus.service.method(_interface, in_signature="s")

541

def SetChecker(self, checker):

542

"D-Bus setter method"

543

self.checker_command = checker

544

545

# SetHost - method

546

@dbus.service.method(_interface, in_signature="s")

547

def SetHost(self, host):

548

"D-Bus setter method"

549

self.host = host

550

551

# SetInterval - method

552

@dbus.service.method(_interface, in_signature="t")

553

def SetInterval(self, milliseconds):

554

self.interval = datetime.timdeelta(0, 0, 0, milliseconds)

555

556

# SetSecret - method

557

@dbus.service.method(_interface, in_signature="ay",

558

byte_arrays=True)

559

def SetSecret(self, secret):

560

"D-Bus setter method"

561

self.secret = str(secret)

562

563

# SetTimeout - method

564

@dbus.service.method(_interface, in_signature="t")

565

def SetTimeout(self, milliseconds):

566

self.timeout = datetime.timedelta(0, 0, 0, milliseconds)

567

568

# Start - method

569

Start = dbus.service.method(_interface)(start)

570

Start.__name__ = "Start"

571

572

# StartChecker - method

573

@dbus.service.method(_interface)

574

def StartChecker(self):

575

"D-Bus method"

576

self.start_checker()

577

578

# Stop - method

579

@dbus.service.method(_interface)

580

def Stop(self):

581

"D-Bus method"

582

self.stop()

583

584

# StopChecker - method

585

StopChecker = dbus.service.method(_interface)(stop_checker)

586

StopChecker.__name__ = "StopChecker"

587

588

del _interface

589

377

590

378

591

379

def peer_certificate(session):

592

380

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

593

381

# If not an OpenPGP certificate...

594

if (gnutls.library.functions

595

.gnutls_certificate_type_get(session._c_object)

596

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

382

if gnutls.library.functions.gnutls_certificate_type_get\

383

(session._c_object) \

384

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:

597

385

# ...do the normal thing

598

386

return session.peer_certificate

599

387

list_size = ctypes.c_uint()

600

cert_list = (gnutls.library.functions

601

.gnutls_certificate_get_peers

602

(session._c_object, ctypes.byref(list_size)))

388

cert_list = gnutls.library.functions.gnutls_certificate_get_peers\

389

(session._c_object, ctypes.byref(list_size))

603

390

if list_size.value == 0:

604

391

return None

605

392

cert = cert_list[0]

609

396

def fingerprint(openpgp):

610

397

"Convert an OpenPGP bytestring to a hexdigit fingerprint string"

611

398

# New GnuTLS "datum" with the OpenPGP public key

612

datum = (gnutls.library.types

613

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

614

ctypes.POINTER

615

(ctypes.c_ubyte)),

616

ctypes.c_uint(len(openpgp))))

399

datum = gnutls.library.types.gnutls_datum_t\

400

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

401

ctypes.POINTER(ctypes.c_ubyte)),

402

ctypes.c_uint(len(openpgp)))

617

403

# New empty GnuTLS certificate

618

404

crt = gnutls.library.types.gnutls_openpgp_crt_t()

619

(gnutls.library.functions

620

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

405

gnutls.library.functions.gnutls_openpgp_crt_init\

406

(ctypes.byref(crt))

621

407

# Import the OpenPGP public key into the certificate

622

(gnutls.library.functions

623

.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),

624

gnutls.library.constants

625

.GNUTLS_OPENPGP_FMT_RAW))

626

# Verify the self signature in the key

627

crtverify = ctypes.c_uint()

628

(gnutls.library.functions

629

.gnutls_openpgp_crt_verify_self(crt, 0, ctypes.byref(crtverify)))

630

if crtverify.value != 0:

631

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

632

raise gnutls.errors.CertificateSecurityError("Verify failed")

408

gnutls.library.functions.gnutls_openpgp_crt_import\

409

(crt, ctypes.byref(datum),

410

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

633

411

# New buffer for the fingerprint

634

buf = ctypes.create_string_buffer(20)

635

buf_len = ctypes.c_size_t()

412

buffer = ctypes.create_string_buffer(20)

413

buffer_length = ctypes.c_size_t()

636

414

# Get the fingerprint from the certificate into the buffer

637

(gnutls.library.functions

638

.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),

639

ctypes.byref(buf_len)))

415

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\

416

(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))

640

417

# Deinit the certificate

641

418

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

642

419

# Convert the buffer to a Python bytestring

643

fpr = ctypes.string_at(buf, buf_len.value)

420

fpr = ctypes.string_at(buffer, buffer_length.value)

644

421

# Convert the bytestring to hexadecimal notation

645

422

hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)

646

423

return hex_fpr

647

424

648

425

649

class TCP_handler(SocketServer.BaseRequestHandler, object):

426

class tcp_handler(SocketServer.BaseRequestHandler, object):

650

427

"""A TCP request handler class.

651

428

Instantiated by IPv6_TCPServer for each request to handle it.

652

429

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

653

430

654

431

def handle(self):

655

432

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

656

unicode(self.client_address))

657

session = (gnutls.connection

658

.ClientSession(self.request,

659

gnutls.connection

660

.X509Credentials()))

433

unicode(self.client_address))

434

session = gnutls.connection.ClientSession\

435

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

661

436

662

437

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

663

438

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

676

451

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

677

452

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

678

453

# "+DHE-DSS"))

679

# Use a fallback default, since this MUST be set.

680

priority = self.server.settings.get("priority", "NORMAL")

681

(gnutls.library.functions

682

.gnutls_priority_set_direct(session._c_object,

683

priority, None))

454

priority = "NORMAL" # Fallback default, since this

455

# MUST be set.

456

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

457

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

458

gnutls.library.functions.gnutls_priority_set_direct\

459

(session._c_object, priority, None);

684

460

685

461

try:

686

462

session.handshake()

696

472

session.bye()

697

473

return

698

474

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

475

client = None

699

476

for c in self.server.clients:

700

477

if c.fingerprint == fpr:

701

478

client = c

702

479

break

703

else:

480

if not client:

704

481

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

705

482

fpr)

706

483

session.bye()

713

490

vars(client))

714

491

session.bye()

715

492

return

716

## This won't work here, since we're in a fork.

717

# client.bump_timeout()

718

493

sent_size = 0

719

494

while sent_size < len(client.secret):

720

495

sent = session.send(client.secret[sent_size:])

725

500

session.bye()

726

501

727

502

728

class IPv6_TCPServer(SocketServer.ForkingMixIn,

729

SocketServer.TCPServer, object):

503

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

730

504

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

731

505

Attributes:

732

506

settings: Server settings

733

507

clients: Set() of Client objects

734

enabled: Boolean; whether this server is activated yet

735

508

"""

736

509

address_family = socket.AF_INET6

737

510

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

741

514

if "clients" in kwargs:

742

515

self.clients = kwargs["clients"]

743

516

del kwargs["clients"]

744

self.enabled = False

745

super(IPv6_TCPServer, self).__init__(*args, **kwargs)

517

return super(type(self), self).__init__(*args, **kwargs)

746

518

def server_bind(self):

747

519

"""This overrides the normal server_bind() function

748

520

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

767

539

in6addr_any = "::"

768

540

self.server_address = (in6addr_any,

769

541

self.server_address[1])

770

elif not self.server_address[1]:

542

elif self.server_address[1] is None:

771

543

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

772

544

0)

773

# if self.settings["interface"]:

774

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

775

# 0, # port

776

# 0, # flowinfo

777

# if_nametoindex

778

# (self.settings

779

# ["interface"]))

780

return super(IPv6_TCPServer, self).server_bind()

781

def server_activate(self):

782

if self.enabled:

783

return super(IPv6_TCPServer, self).server_activate()

784

def enable(self):

785

self.enabled = True

545

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

786

546

787

547

788

548

def string_to_delta(interval):

798

558

datetime.timedelta(1)

799

559

>>> string_to_delta(u'1w')

800

560

datetime.timedelta(7)

801

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

802

datetime.timedelta(0, 330)

803

561

"""

804

timevalue = datetime.timedelta(0)

805

for s in interval.split():

806

try:

807

suffix = unicode(s[-1])

808

value = int(s[:-1])

809

if suffix == u"d":

810

delta = datetime.timedelta(value)

811

elif suffix == u"s":

812

delta = datetime.timedelta(0, value)

813

elif suffix == u"m":

814

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

815

elif suffix == u"h":

816

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

817

elif suffix == u"w":

818

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

819

else:

820

raise ValueError

821

except (ValueError, IndexError):

562

try:

563

suffix=unicode(interval[-1])

564

value=int(interval[:-1])

565

if suffix == u"d":

566

delta = datetime.timedelta(value)

567

elif suffix == u"s":

568

delta = datetime.timedelta(0, value)

569

elif suffix == u"m":

570

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

571

elif suffix == u"h":

572

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

573

elif suffix == u"w":

574

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

575

else:

822

576

raise ValueError

823

timevalue += delta

824

return timevalue

577

except (ValueError, IndexError):

578

raise ValueError

579

return delta

825

580

826

581

827

582

def server_state_changed(state):

828

583

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

829

584

if state == avahi.SERVER_COLLISION:

830

logger.error(u"Zeroconf server name collision")

585

logger.error(u"Server name collision")

831

586

service.remove()

832

587

elif state == avahi.SERVER_RUNNING:

833

588

service.add()

835

590

836

591

def entry_group_state_changed(state, error):

837

592

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

838

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

593

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

839

594

840

595

if state == avahi.ENTRY_GROUP_ESTABLISHED:

841

logger.debug(u"Zeroconf service established.")

596

logger.debug(u"Service established.")

842

597

elif state == avahi.ENTRY_GROUP_COLLISION:

843

logger.warning(u"Zeroconf service name collision.")

598

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

844

599

service.rename()

845

600

elif state == avahi.ENTRY_GROUP_FAILURE:

846

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

601

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

847

602

unicode(error))

848

603

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

849

604

851

606

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

852

607

global if_nametoindex

853

608

try:

854

if_nametoindex = (ctypes.cdll.LoadLibrary

855

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

856

.if_nametoindex)

609

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

610

import ctypes.util

611

if_nametoindex = ctypes.cdll.LoadLibrary\

612

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

857

613

except (OSError, AttributeError):

858

614

if "struct" not in sys.modules:

859

615

import struct

862

618

def if_nametoindex(interface):

863

619

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

864

620

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

865

with closing(socket.socket()) as s:

866

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

867

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

621

s = socket.socket()

622

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

623

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

624

s.close()

868

625

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

869

626

return interface_index

870

627

return if_nametoindex(interface)

871

628

872

629

873

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

630

def daemon(nochdir, noclose):

874

631

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

875

632

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

876

633

if os.fork():

878

635

os.setsid()

879

636

if not nochdir:

880

637

os.chdir("/")

881

if os.fork():

882

sys.exit()

883

638

if not noclose:

884

639

# Close all standard open file descriptors

885

640

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

894

649

895

650

896

651

def main():

897

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

652

global main_loop_started

653

main_loop_started = False

654

655

parser = OptionParser()

898

656

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

899

657

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

900

658

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

903

661

help="Port number to receive requests on")

904

662

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

905

663

help="Run self-test")

906

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

664

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

907

665

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

908

666

" terminal")

909

667

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

914

672

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

915

673

help="Directory to search for configuration"

916

674

" files")

917

options = parser.parse_args()[0]

675

(options, args) = parser.parse_args()

918

676

919

677

if options.check:

920

678

import doctest

934

692

# Parse config file for server-global settings

935

693

server_config = ConfigParser.SafeConfigParser(server_defaults)

936

694

del server_defaults

937

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

695

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

696

server_section = "server"

938

697

# Convert the SafeConfigParser object to a dict

939

server_settings = server_config.defaults()

698

server_settings = dict(server_config.items(server_section))

940

699

# Use getboolean on the boolean config option

941

server_settings["debug"] = (server_config.getboolean

942

("DEFAULT", "debug"))

700

server_settings["debug"] = server_config.getboolean\

701

(server_section, "debug")

943

702

del server_config

944

703

945

704

# Override the settings from the config file with command line

952

711

del options

953

712

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

954

713

955

debug = server_settings["debug"]

956

957

if not debug:

958

syslogger.setLevel(logging.WARNING)

959

console.setLevel(logging.WARNING)

960

961

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

962

syslogger.setFormatter(logging.Formatter

963

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

964

' %%(message)s'

965

% server_settings["servicename"]))

966

967

714

# Parse config file with clients

968

715

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

969

716

"interval": "5m",

970

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

971

"host": "",

717

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

972

718

}

973

719

client_config = ConfigParser.SafeConfigParser(client_defaults)

974

720

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

975

721

"clients.conf"))

976

722

977

clients = Set()

978

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

979

server_settings["port"]),

980

TCP_handler,

981

settings=server_settings,

982

clients=clients)

983

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

984

try:

985

pidfile = open(pidfilename, "w")

986

except IOError, error:

987

logger.error("Could not open file %r", pidfilename)

988

989

try:

990

uid = pwd.getpwnam("_mandos").pw_uid

991

except KeyError:

992

try:

993

uid = pwd.getpwnam("mandos").pw_uid

994

except KeyError:

995

try:

996

uid = pwd.getpwnam("nobody").pw_uid

997

except KeyError:

998

uid = 65534

999

try:

1000

gid = pwd.getpwnam("_mandos").pw_gid

1001

except KeyError:

1002

try:

1003

gid = pwd.getpwnam("mandos").pw_gid

1004

except KeyError:

1005

try:

1006

gid = pwd.getpwnam("nogroup").pw_gid

1007

except KeyError:

1008

gid = 65534

1009

try:

1010

os.setuid(uid)

1011

os.setgid(gid)

1012

except OSError, error:

1013

if error[0] != errno.EPERM:

1014

raise error

1015

1016

723

global service

1017

724

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

1018

servicetype = "_mandos._tcp", )

725

type = "_mandos._tcp", );

1019

726

if server_settings["interface"]:

1020

service.interface = (if_nametoindex

1021

(server_settings["interface"]))

727

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

1022

728

1023

729

global main_loop

1024

730

global bus

1027

733

DBusGMainLoop(set_as_default=True )

1028

734

main_loop = gobject.MainLoop()

1029

735

bus = dbus.SystemBus()

1030

server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,

1031

avahi.DBUS_PATH_SERVER),

1032

avahi.DBUS_INTERFACE_SERVER)

736

server = dbus.Interface(

737

bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),

738

avahi.DBUS_INTERFACE_SERVER )

1033

739

# End of Avahi example code

1034

bus_name = dbus.service.BusName(u"org.mandos-system.Mandos", bus)

740

741

debug = server_settings["debug"]

742

743

if debug:

744

console = logging.StreamHandler()

745

# console.setLevel(logging.DEBUG)

746

console.setFormatter(logging.Formatter\

747

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

748

logger.addHandler(console)

749

del console

750

751

clients = Set()

752

def remove_from_clients(client):

753

clients.remove(client)

754

if not clients:

755

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

756

sys.exit()

1035

757

1036

758

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

759

stop_hook = remove_from_clients,

1037

760

config

1038

761

= dict(client_config.items(section)))

1039

762

for section in client_config.sections()))

1040

if not clients:

1041

logger.critical(u"No clients defined")

1042

sys.exit(1)

1043

1044

if debug:

1045

# Redirect stdin so all checkers get /dev/null

1046

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

1047

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

1048

if null > 2:

1049

os.close(null)

1050

else:

1051

# No console logging

1052

logger.removeHandler(console)

1053

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

1054

daemon()

1055

1056

try:

1057

pid = os.getpid()

1058

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

1059

pidfile.close()

1060

del pidfile

1061

except IOError:

1062

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

1063

pidfilename, pid)

1064

except NameError:

1065

# "pidfile" was never created

1066

pass

1067

del pidfilename

763

764

if not debug:

765

daemon(False, False)

1068

766

1069

767

def cleanup():

1070

768

"Cleanup function; run on exit"

1087

785

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

1088

786

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

1089

787

1090

class MandosServer(dbus.service.Object):

1091

"""A D-Bus proxy object"""

1092

def __init__(self):

1093

dbus.service.Object.__init__(self, bus,

1094

"/Mandos")

1095

_interface = u"org.mandos_system.Mandos"

1096

1097

@dbus.service.signal(_interface, signature="oa{sv}")

1098

def ClientAdded(self, objpath, properties):

1099

"D-Bus signal"

1100

pass

1101

1102

@dbus.service.signal(_interface, signature="o")

1103

def ClientRemoved(self, objpath):

1104

"D-Bus signal"

1105

pass

1106

1107

@dbus.service.method(_interface, out_signature="ao")

1108

def GetAllClients(self):

1109

return dbus.Array(c.dbus_object_path for c in clients)

1110

1111

@dbus.service.method(_interface, out_signature="a{oa{sv}}")

1112

def GetAllClientsWithProperties(self):

1113

return dbus.Dictionary(

1114

((c.dbus_object_path, c.GetAllProperties())

1115

for c in clients),

1116

signature="oa{sv}")

1117

1118

@dbus.service.method(_interface, in_signature="o")

1119

def RemoveClient(self, object_path):

1120

for c in clients:

1121

if c.dbus_object_path == object_path:

1122

c.stop()

1123

clients.remove(c)

1124

return

1125

raise KeyError

1126

1127

del _interface

1128

1129

mandos_server = MandosServer()

1130

1131

788

for client in clients:

1132

# Emit D-Bus signal

1133

mandos_server.ClientAdded(client.dbus_object_path,

1134

client.GetAllProperties())

1135

789

client.start()

1136

790

1137

tcp_server.enable()

1138

tcp_server.server_activate()

1139

791

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

792

server_settings["port"]),

793

tcp_handler,

794

settings=server_settings,

795

clients=clients)

1140

796

# Find out what port we got

1141

797

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

1142

798

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

1156

812

1157

813

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

1158

814

lambda *args, **kwargs:

1159

(tcp_server.handle_request

1160

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

815

tcp_server.handle_request\

816

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

1161

817

1162

logger.debug(u"Starting main loop")

818

logger.debug("Starting main loop")

819

main_loop_started = True

1163

820

main_loop.run()

1164

821

except AvahiError, error:

1165

822

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