/mandos/release : revision 237.7.297

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

2

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

3

#

4

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

11

# "AvahiService" class, and some lines in "main".

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

import SocketServer as socketserver

37

from future_builtins import *

38

39

try:

40

import SocketServer as socketserver

41

except ImportError:

42

import socketserver

38

43

import socket

39

44

import argparse

40

45

import datetime

45

50

import gnutls.library.functions

46

51

import gnutls.library.constants

47

52

import gnutls.library.types

48

import ConfigParser as configparser

53

try:

54

import ConfigParser as configparser

55

except ImportError:

56

import configparser

49

57

import sys

50

58

import re

51

59

import os

60

68

import struct

61

69

import fcntl

62

70

import functools

63

import cPickle as pickle

71

try:

72

import cPickle as pickle

73

except ImportError:

74

import pickle

64

75

import multiprocessing

65

76

import types

77

import binascii

78

import tempfile

79

import itertools

80

import collections

66

81

67

82

import dbus

68

83

import dbus.service

69

import gobject

84

try:

85

import gobject

86

except ImportError:

87

from gi.repository import GObject as gobject

70

88

import avahi

71

89

from dbus.mainloop.glib import DBusGMainLoop

72

90

import ctypes

82

100

except ImportError:

83

101

SO_BINDTODEVICE = None

84

102

85

86

version = "1.4.0"

87

88

#logger = logging.getLogger('mandos')

89

logger = logging.Logger('mandos')

90

syslogger = (logging.handlers.SysLogHandler

91

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

92

address = str("/dev/log")))

93

syslogger.setFormatter(logging.Formatter

94

('Mandos [%(process)d]: %(levelname)s:'

95

' %(message)s'))

96

logger.addHandler(syslogger)

97

98

console = logging.StreamHandler()

99

console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'

100

' %(levelname)s:'

101

' %(message)s'))

102

logger.addHandler(console)

103

if sys.version_info.major == 2:

104

str = unicode

105

106

version = "1.6.9"

107

stored_state_file = "clients.pickle"

108

109

logger = logging.getLogger()

110

syslogger = None

111

112

try:

113

if_nametoindex = ctypes.cdll.LoadLibrary(

114

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

115

except (OSError, AttributeError):

116

117

def if_nametoindex(interface):

118

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

119

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

120

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

121

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

122

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

123

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

124

return interface_index

125

126

127

def initlogger(debug, level=logging.WARNING):

128

"""init logger and add loglevel"""

129

130

global syslogger

131

syslogger = (logging.handlers.SysLogHandler(

132

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

133

address = "/dev/log"))

134

syslogger.setFormatter(logging.Formatter

135

('Mandos [%(process)d]: %(levelname)s:'

136

' %(message)s'))

137

logger.addHandler(syslogger)

138

139

if debug:

140

console = logging.StreamHandler()

141

console.setFormatter(logging.Formatter('%(asctime)s %(name)s'

142

' [%(process)d]:'

143

' %(levelname)s:'

144

' %(message)s'))

145

logger.addHandler(console)

146

logger.setLevel(level)

147

148

149

class PGPError(Exception):

150

"""Exception if encryption/decryption fails"""

151

pass

152

153

154

class PGPEngine(object):

155

"""A simple class for OpenPGP symmetric encryption & decryption"""

156

157

def __init__(self):

158

self.tempdir = tempfile.mkdtemp(prefix="mandos-")

159

self.gnupgargs = ['--batch',

160

'--home', self.tempdir,

161

'--force-mdc',

162

'--quiet',

163

'--no-use-agent']

164

165

def __enter__(self):

166

return self

167

168

def __exit__(self, exc_type, exc_value, traceback):

169

self._cleanup()

170

return False

171

172

def __del__(self):

173

self._cleanup()

174

175

def _cleanup(self):

176

if self.tempdir is not None:

177

# Delete contents of tempdir

178

for root, dirs, files in os.walk(self.tempdir,

179

topdown = False):

180

for filename in files:

181

os.remove(os.path.join(root, filename))

182

for dirname in dirs:

183

os.rmdir(os.path.join(root, dirname))

184

# Remove tempdir

185

os.rmdir(self.tempdir)

186

self.tempdir = None

187

188

def password_encode(self, password):

189

# Passphrase can not be empty and can not contain newlines or

190

# NUL bytes. So we prefix it and hex encode it.

191

encoded = b"mandos" + binascii.hexlify(password)

192

if len(encoded) > 2048:

193

# GnuPG can't handle long passwords, so encode differently

194

encoded = (b"mandos" + password.replace(b"\\", b"\\\\")

195

.replace(b"\n", b"\\n")

196

.replace(b"\0", b"\\x00"))

197

return encoded

198

199

def encrypt(self, data, password):

200

passphrase = self.password_encode(password)

201

with tempfile.NamedTemporaryFile(

202

dir=self.tempdir) as passfile:

203

passfile.write(passphrase)

204

passfile.flush()

205

proc = subprocess.Popen(['gpg', '--symmetric',

206

'--passphrase-file',

207

passfile.name]

208

+ self.gnupgargs,

209

stdin = subprocess.PIPE,

210

stdout = subprocess.PIPE,

211

stderr = subprocess.PIPE)

212

ciphertext, err = proc.communicate(input = data)

213

if proc.returncode != 0:

214

raise PGPError(err)

215

return ciphertext

216

217

def decrypt(self, data, password):

218

passphrase = self.password_encode(password)

219

with tempfile.NamedTemporaryFile(

220

dir = self.tempdir) as passfile:

221

passfile.write(passphrase)

222

passfile.flush()

223

proc = subprocess.Popen(['gpg', '--decrypt',

224

'--passphrase-file',

225

passfile.name]

226

+ self.gnupgargs,

227

stdin = subprocess.PIPE,

228

stdout = subprocess.PIPE,

229

stderr = subprocess.PIPE)

230

decrypted_plaintext, err = proc.communicate(input = data)

231

if proc.returncode != 0:

232

raise PGPError(err)

233

return decrypted_plaintext

234

103

235

104

236

class AvahiError(Exception):

105

237

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

106

238

self.value = value

107

super(AvahiError, self).__init__(value, *args, **kwargs)

108

def __unicode__(self):

109

return unicode(repr(self.value))

239

return super(AvahiError, self).__init__(value, *args,

240

**kwargs)

241

110

242

111

243

class AvahiServiceError(AvahiError):

112

244

pass

113

245

246

114

247

class AvahiGroupError(AvahiError):

115

248

pass

116

249

123

256

Used to optionally bind to the specified interface.

124

257

name: string; Example: 'Mandos'

125

258

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

126

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

259

See <https://www.iana.org/assignments/service-names-port-numbers>

127

260

port: integer; what port to announce

128

261

TXT: list of strings; TXT record for the service

129

262

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

135

268

server: D-Bus Server

136

269

bus: dbus.SystemBus()

137

270

"""

138

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

139

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

140

domain = "", host = "", max_renames = 32768,

141

protocol = avahi.PROTO_UNSPEC, bus = None):

271

272

def __init__(self,

273

interface = avahi.IF_UNSPEC,

274

name = None,

275

servicetype = None,

276

port = None,

277

TXT = None,

278

domain = "",

279

host = "",

280

max_renames = 32768,

281

protocol = avahi.PROTO_UNSPEC,

282

bus = None):

142

283

self.interface = interface

143

284

self.name = name

144

285

self.type = servicetype

153

294

self.server = None

154

295

self.bus = bus

155

296

self.entry_group_state_changed_match = None

156

def rename(self):

297

298

def rename(self, remove=True):

157

299

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

158

300

if self.rename_count >= self.max_renames:

159

301

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

160

302

" after %i retries, exiting.",

161

303

self.rename_count)

162

304

raise AvahiServiceError("Too many renames")

163

self.name = unicode(self.server

164

.GetAlternativeServiceName(self.name))

305

self.name = str(

306

self.server.GetAlternativeServiceName(self.name))

307

self.rename_count += 1

165

308

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

166

309

self.name)

167

syslogger.setFormatter(logging.Formatter

168

('Mandos (%s) [%%(process)d]:'

169

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

170

% self.name))

171

self.remove()

310

if remove:

311

self.remove()

172

312

try:

173

313

self.add()

174

314

except dbus.exceptions.DBusException as error:

175

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

176

self.cleanup()

177

os._exit(1)

178

self.rename_count += 1

315

if (error.get_dbus_name()

316

== "org.freedesktop.Avahi.CollisionError"):

317

logger.info("Local Zeroconf service name collision.")

318

return self.rename(remove=False)

319

else:

320

logger.critical("D-Bus Exception", exc_info=error)

321

self.cleanup()

322

os._exit(1)

323

179

324

def remove(self):

180

325

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

181

326

if self.entry_group_state_changed_match is not None:

183

328

self.entry_group_state_changed_match = None

184

329

if self.group is not None:

185

330

self.group.Reset()

331

186

332

def add(self):

187

333

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

188

334

self.remove()

193

339

avahi.DBUS_INTERFACE_ENTRY_GROUP)

194

340

self.entry_group_state_changed_match = (

195

341

self.group.connect_to_signal(

196

'StateChanged', self .entry_group_state_changed))

342

'StateChanged', self.entry_group_state_changed))

197

343

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

198

344

self.name, self.type)

199

345

self.group.AddService(

205

351

dbus.UInt16(self.port),

206

352

avahi.string_array_to_txt_array(self.TXT))

207

353

self.group.Commit()

354

208

355

def entry_group_state_changed(self, state, error):

209

356

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

210

357

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

216

363

self.rename()

217

364

elif state == avahi.ENTRY_GROUP_FAILURE:

218

365

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

219

unicode(error))

220

raise AvahiGroupError("State changed: %s"

221

% unicode(error))

366

str(error))

367

raise AvahiGroupError("State changed: {!s}".format(error))

368

222

369

def cleanup(self):

223

370

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

224

371

if self.group is not None:

225

372

try:

226

373

self.group.Free()

227

374

except (dbus.exceptions.UnknownMethodException,

228

dbus.exceptions.DBusException) as e:

375

dbus.exceptions.DBusException):

229

376

pass

230

377

self.group = None

231

378

self.remove()

379

232

380

def server_state_changed(self, state, error=None):

233

381

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

234

382

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

235

bad_states = { avahi.SERVER_INVALID:

236

"Zeroconf server invalid",

237

avahi.SERVER_REGISTERING: None,

238

avahi.SERVER_COLLISION:

239

"Zeroconf server name collision",

240

avahi.SERVER_FAILURE:

241

"Zeroconf server failure" }

383

bad_states = {

384

avahi.SERVER_INVALID: "Zeroconf server invalid",

385

avahi.SERVER_REGISTERING: None,

386

avahi.SERVER_COLLISION: "Zeroconf server name collision",

387

avahi.SERVER_FAILURE: "Zeroconf server failure",

388

}

242

389

if state in bad_states:

243

390

if bad_states[state] is not None:

244

391

if error is None:

253

400

logger.debug("Unknown state: %r", state)

254

401

else:

255

402

logger.debug("Unknown state: %r: %r", state, error)

403

256

404

def activate(self):

257

405

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

258

406

if self.server is None:

262

410

follow_name_owner_changes=True),

263

411

avahi.DBUS_INTERFACE_SERVER)

264

412

self.server.connect_to_signal("StateChanged",

265

self.server_state_changed)

413

self.server_state_changed)

266

414

self.server_state_changed(self.server.GetState())

267

415

268

416

269

def _timedelta_to_milliseconds(td):

270

"Convert a datetime.timedelta() to milliseconds"

271

return ((td.days * 24 * 60 * 60 * 1000)

272

+ (td.seconds * 1000)

273

+ (td.microseconds // 1000))

274

417

class AvahiServiceToSyslog(AvahiService):

418

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

419

"""Add the new name to the syslog messages"""

420

ret = AvahiService.rename(self, *args, **kwargs)

421

syslogger.setFormatter(logging.Formatter(

422

'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'

423

.format(self.name)))

424

return ret

425

426

275

427

class Client(object):

276

428

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

277

429

278

430

Attributes:

279

_approved: bool(); 'None' if not yet approved/disapproved

431

approved: bool(); 'None' if not yet approved/disapproved

280

432

approval_delay: datetime.timedelta(); Time to wait for approval

281

433

approval_duration: datetime.timedelta(); Duration of one approval

282

434

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

289

441

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

290

442

checker_initiator_tag: a gobject event source tag, or None

291

443

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

444

client_structure: Object describing what attributes a client has

445

and is used for storing the client at exit

292

446

current_checker_command: string; current running checker_command

293

disable_hook: If set, called by disable() as disable_hook(self)

294

447

disable_initiator_tag: a gobject event source tag, or None

295

448

enabled: bool()

296

449

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

299

452

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

300

453

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

301

454

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

302

last_enabled: datetime.datetime(); (UTC)

455

last_checker_status: integer between 0 and 255 reflecting exit

456

status of last checker. -1 reflects crashed

457

checker, -2 means no checker completed yet.

458

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

303

459

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

304

460

D-Bus identifiers

305

461

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

306

462

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

307

463

until this client is disabled

308

extended_timeout: extra long timeout when password has been sent

464

extended_timeout: extra long timeout when secret has been sent

309

465

runtime_expansions: Allowed attributes for runtime expansion.

310

466

expires: datetime.datetime(); time (UTC) when a client will be

311

467

disabled, or None

468

server_settings: The server_settings dict from main()

312

469

"""

313

470

314

471

runtime_expansions = ("approval_delay", "approval_duration",

315

"created", "enabled", "fingerprint",

316

"host", "interval", "last_checked_ok",

472

"created", "enabled", "expires",

473

"fingerprint", "host", "interval",

474

"last_approval_request", "last_checked_ok",

317

475

"last_enabled", "name", "timeout")

318

319

def timeout_milliseconds(self):

320

"Return the 'timeout' attribute in milliseconds"

321

return _timedelta_to_milliseconds(self.timeout)

322

323

def extended_timeout_milliseconds(self):

324

"Return the 'extended_timeout' attribute in milliseconds"

325

return _timedelta_to_milliseconds(self.extended_timeout)

326

327

def interval_milliseconds(self):

328

"Return the 'interval' attribute in milliseconds"

329

return _timedelta_to_milliseconds(self.interval)

330

331

def approval_delay_milliseconds(self):

332

return _timedelta_to_milliseconds(self.approval_delay)

333

334

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

335

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

336

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

337

attribute."""

476

client_defaults = {

477

"timeout": "PT5M",

478

"extended_timeout": "PT15M",

479

"interval": "PT2M",

480

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

481

"host": "",

482

"approval_delay": "PT0S",

483

"approval_duration": "PT1S",

484

"approved_by_default": "True",

485

"enabled": "True",

486

}

487

488

@staticmethod

489

def config_parser(config):

490

"""Construct a new dict of client settings of this form:

491

{ client_name: {setting_name: value, ...}, ...}

492

with exceptions for any special settings as defined above.

493

NOTE: Must be a pure function. Must return the same result

494

value given the same arguments.

495

"""

496

settings = {}

497

for client_name in config.sections():

498

section = dict(config.items(client_name))

499

client = settings[client_name] = {}

500

501

client["host"] = section["host"]

502

# Reformat values from string types to Python types

503

client["approved_by_default"] = config.getboolean(

504

client_name, "approved_by_default")

505

client["enabled"] = config.getboolean(client_name,

506

"enabled")

507

508

# Uppercase and remove spaces from fingerprint for later

509

# comparison purposes with return value from the

510

# fingerprint() function

511

client["fingerprint"] = (section["fingerprint"].upper()

512

.replace(" ", ""))

513

if "secret" in section:

514

client["secret"] = section["secret"].decode("base64")

515

elif "secfile" in section:

516

with open(os.path.expanduser(os.path.expandvars

517

(section["secfile"])),

518

"rb") as secfile:

519

client["secret"] = secfile.read()

520

else:

521

raise TypeError("No secret or secfile for section {}"

522

.format(section))

523

client["timeout"] = string_to_delta(section["timeout"])

524

client["extended_timeout"] = string_to_delta(

525

section["extended_timeout"])

526

client["interval"] = string_to_delta(section["interval"])

527

client["approval_delay"] = string_to_delta(

528

section["approval_delay"])

529

client["approval_duration"] = string_to_delta(

530

section["approval_duration"])

531

client["checker_command"] = section["checker"]

532

client["last_approval_request"] = None

533

client["last_checked_ok"] = None

534

client["last_checker_status"] = -2

535

536

return settings

537

538

def __init__(self, settings, name = None, server_settings=None):

338

539

self.name = name

339

if config is None:

340

config = {}

540

if server_settings is None:

541

server_settings = {}

542

self.server_settings = server_settings

543

# adding all client settings

544

for setting, value in settings.items():

545

setattr(self, setting, value)

546

547

if self.enabled:

548

if not hasattr(self, "last_enabled"):

549

self.last_enabled = datetime.datetime.utcnow()

550

if not hasattr(self, "expires"):

551

self.expires = (datetime.datetime.utcnow()

552

+ self.timeout)

553

else:

554

self.last_enabled = None

555

self.expires = None

556

341

557

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

342

# Uppercase and remove spaces from fingerprint for later

343

# comparison purposes with return value from the fingerprint()

344

# function

345

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

346

.replace(" ", ""))

347

558

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

348

if "secret" in config:

349

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

350

elif "secfile" in config:

351

with open(os.path.expanduser(os.path.expandvars

352

(config["secfile"])),

353

"rb") as secfile:

354

self.secret = secfile.read()

355

else:

356

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

357

% self.name)

358

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

359

self.created = datetime.datetime.utcnow()

360

self.enabled = False

361

self.last_approval_request = None

362

self.last_enabled = None

363

self.last_checked_ok = None

364

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

365

self.extended_timeout = string_to_delta(config

366

["extended_timeout"])

367

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

368

self.disable_hook = disable_hook

559

self.created = settings.get("created",

560

datetime.datetime.utcnow())

561

562

# attributes specific for this server instance

369

563

self.checker = None

370

564

self.checker_initiator_tag = None

371

565

self.disable_initiator_tag = None

372

self.expires = None

373

566

self.checker_callback_tag = None

374

self.checker_command = config["checker"]

375

567

self.current_checker_command = None

376

self.last_connect = None

377

self._approved = None

378

self.approved_by_default = config.get("approved_by_default",

379

True)

568

self.approved = None

380

569

self.approvals_pending = 0

381

self.approval_delay = string_to_delta(

382

config["approval_delay"])

383

self.approval_duration = string_to_delta(

384

config["approval_duration"])

385

self.changedstate = (multiprocessing_manager

386

.Condition(multiprocessing_manager

387

.Lock()))

570

self.changedstate = multiprocessing_manager.Condition(

571

multiprocessing_manager.Lock())

572

self.client_structure = [attr

573

for attr in self.__dict__.iterkeys()

574

if not attr.startswith("_")]

575

self.client_structure.append("client_structure")

576

577

for name, t in inspect.getmembers(

578

type(self), lambda obj: isinstance(obj, property)):

579

if not name.startswith("_"):

580

self.client_structure.append(name)

388

581

582

# Send notice to process children that client state has changed

389

583

def send_changedstate(self):

390

self.changedstate.acquire()

391

self.changedstate.notify_all()

392

self.changedstate.release()

584

with self.changedstate:

585

self.changedstate.notify_all()

393

586

394

587

def enable(self):

395

588

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

396

589

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

397

590

# Already enabled

398

591

return

399

self.send_changedstate()

400

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

401

# and every interval from then on.

402

self.checker_initiator_tag = (gobject.timeout_add

403

(self.interval_milliseconds(),

404

self.start_checker))

405

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

406

592

self.expires = datetime.datetime.utcnow() + self.timeout

407

self.disable_initiator_tag = (gobject.timeout_add

408

(self.timeout_milliseconds(),

409

self.disable))

410

593

self.enabled = True

411

594

self.last_enabled = datetime.datetime.utcnow()

412

# Also start a new checker *right now*.

413

self.start_checker()

595

self.init_checker()

596

self.send_changedstate()

414

597

415

598

def disable(self, quiet=True):

416

599

"""Disable this client."""

417

600

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

418

601

return False

419

602

if not quiet:

420

self.send_changedstate()

421

if not quiet:

422

603

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

423

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

604

if getattr(self, "disable_initiator_tag", None) is not None:

424

605

gobject.source_remove(self.disable_initiator_tag)

425

606

self.disable_initiator_tag = None

426

607

self.expires = None

427

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

608

if getattr(self, "checker_initiator_tag", None) is not None:

428

609

gobject.source_remove(self.checker_initiator_tag)

429

610

self.checker_initiator_tag = None

430

611

self.stop_checker()

431

if self.disable_hook:

432

self.disable_hook(self)

433

612

self.enabled = False

613

if not quiet:

614

self.send_changedstate()

434

615

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

435

616

return False

436

617

437

618

def __del__(self):

438

self.disable_hook = None

439

619

self.disable()

440

620

621

def init_checker(self):

622

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

623

# and every interval from then on.

624

if self.checker_initiator_tag is not None:

625

gobject.source_remove(self.checker_initiator_tag)

626

self.checker_initiator_tag = gobject.timeout_add(

627

int(self.interval.total_seconds() * 1000),

628

self.start_checker)

629

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

630

if self.disable_initiator_tag is not None:

631

gobject.source_remove(self.disable_initiator_tag)

632

self.disable_initiator_tag = gobject.timeout_add(

633

int(self.timeout.total_seconds() * 1000), self.disable)

634

# Also start a new checker *right now*.

635

self.start_checker()

636

441

637

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

442

638

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

443

639

self.checker_callback_tag = None

444

640

self.checker = None

445

641

if os.WIFEXITED(condition):

446

exitstatus = os.WEXITSTATUS(condition)

447

if exitstatus == 0:

642

self.last_checker_status = os.WEXITSTATUS(condition)

643

if self.last_checker_status == 0:

448

644

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

449

645

vars(self))

450

646

self.checked_ok()

451

647

else:

452

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

453

vars(self))

648

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

454

649

else:

650

self.last_checker_status = -1

455

651

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

456

652

vars(self))

457

653

458

def checked_ok(self, timeout=None):

459

"""Bump up the timeout for this client.

460

461

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

462

alive and well.

463

"""

654

def checked_ok(self):

655

"""Assert that the client has been seen, alive and well."""

656

self.last_checked_ok = datetime.datetime.utcnow()

657

self.last_checker_status = 0

658

self.bump_timeout()

659

660

def bump_timeout(self, timeout=None):

661

"""Bump up the timeout for this client."""

464

662

if timeout is None:

465

663

timeout = self.timeout

466

self.last_checked_ok = datetime.datetime.utcnow()

467

gobject.source_remove(self.disable_initiator_tag)

468

self.disable_initiator_tag = (gobject.timeout_add

469

(_timedelta_to_milliseconds

470

(timeout), self.disable))

471

self.expires = datetime.datetime.utcnow() + timeout

664

if self.disable_initiator_tag is not None:

665

gobject.source_remove(self.disable_initiator_tag)

666

self.disable_initiator_tag = None

667

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

668

self.disable_initiator_tag = gobject.timeout_add(

669

int(timeout.total_seconds() * 1000), self.disable)

670

self.expires = datetime.datetime.utcnow() + timeout

472

671

473

672

def need_approval(self):

474

673

self.last_approval_request = datetime.datetime.utcnow()

479

678

If a checker already exists, leave it running and do

480

679

nothing."""

481

680

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

482

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

483

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

484

# client would inevitably timeout, since no checker would get

485

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

681

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

682

# slowly and taking more than 'interval' time, then the client

683

# would inevitably timeout, since no checker would get a

684

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

486

685

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

487

686

# than 'timeout' for the client to be disabled, which is as it

488

687

# should be.

490

689

# If a checker exists, make sure it is not a zombie

491

690

try:

492

691

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

493

except (AttributeError, OSError) as error:

494

if (isinstance(error, OSError)

495

and error.errno != errno.ECHILD):

496

raise error

692

except AttributeError:

693

pass

694

except OSError as error:

695

if error.errno != errno.ECHILD:

696

raise

497

697

else:

498

698

if pid:

499

699

logger.warning("Checker was a zombie")

502

702

self.current_checker_command)

503

703

# Start a new checker if needed

504

704

if self.checker is None:

705

# Escape attributes for the shell

706

escaped_attrs = {

707

attr: re.escape(str(getattr(self, attr)))

708

for attr in self.runtime_expansions }

505

709

try:

506

# In case checker_command has exactly one % operator

507

command = self.checker_command % self.host

508

except TypeError:

509

# Escape attributes for the shell

510

escaped_attrs = dict(

511

(attr,

512

re.escape(unicode(str(getattr(self, attr, "")),

513

errors=

514

'replace')))

515

for attr in

516

self.runtime_expansions)

517

518

try:

519

command = self.checker_command % escaped_attrs

520

except TypeError as error:

521

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

522

' %s', self.checker_command, error)

523

return True # Try again later

710

command = self.checker_command % escaped_attrs

711

except TypeError as error:

712

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

713

self.checker_command,

714

exc_info=error)

715

return True # Try again later

524

716

self.current_checker_command = command

525

717

try:

526

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

527

command, self.name)

718

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

719

self.name)

528

720

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

529

721

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

530

722

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

531

723

# always replaced by /dev/null.)

724

# The exception is when not debugging but nevertheless

725

# running in the foreground; use the previously

726

# created wnull.

727

popen_args = {}

728

if (not self.server_settings["debug"]

729

and self.server_settings["foreground"]):

730

popen_args.update({"stdout": wnull,

731

"stderr": wnull })

532

732

self.checker = subprocess.Popen(command,

533

733

close_fds=True,

534

shell=True, cwd="/")

535

self.checker_callback_tag = (gobject.child_watch_add

536

(self.checker.pid,

537

self.checker_callback,

538

data=command))

539

# The checker may have completed before the gobject

540

# watch was added. Check for this.

734

shell=True,

735

cwd="/",

736

**popen_args)

737

except OSError as error:

738

logger.error("Failed to start subprocess",

739

exc_info=error)

740

return True

741

self.checker_callback_tag = gobject.child_watch_add(

742

self.checker.pid, self.checker_callback, data=command)

743

# The checker may have completed before the gobject

744

# watch was added. Check for this.

745

try:

541

746

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

542

if pid:

543

gobject.source_remove(self.checker_callback_tag)

544

self.checker_callback(pid, status, command)

545

747

except OSError as error:

546

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

547

error)

748

if error.errno == errno.ECHILD:

749

# This should never happen

750

logger.error("Child process vanished",

751

exc_info=error)

752

return True

753

raise

754

if pid:

755

gobject.source_remove(self.checker_callback_tag)

756

self.checker_callback(pid, status, command)

548

757

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

549

758

return True

550

759

557

766

return

558

767

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

559

768

try:

560

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

769

self.checker.terminate()

561

770

#time.sleep(0.5)

562

771

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

563

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

772

# self.checker.kill()

564

773

except OSError as error:

565

774

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

566

775

raise

567

776

self.checker = None

568

777

569

778

570

def dbus_service_property(dbus_interface, signature="v",

571

access="readwrite", byte_arrays=False):

779

def dbus_service_property(dbus_interface,

780

signature="v",

781

access="readwrite",

782

byte_arrays=False):

572

783

"""Decorators for marking methods of a DBusObjectWithProperties to

573

784

become properties on the D-Bus.

574

785

583

794

# "Set" method, so we fail early here:

584

795

if byte_arrays and signature != "ay":

585

796

raise ValueError("Byte arrays not supported for non-'ay'"

586

" signature %r" % signature)

797

" signature {!r}".format(signature))

798

587

799

def decorator(func):

588

800

func._dbus_is_property = True

589

801

func._dbus_interface = dbus_interface

594

806

func._dbus_name = func._dbus_name[:-14]

595

807

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

596

808

return func

809

810

return decorator

811

812

813

def dbus_interface_annotations(dbus_interface):

814

"""Decorator for marking functions returning interface annotations

815

816

Usage:

817

818

@dbus_interface_annotations("org.example.Interface")

819

def _foo(self): # Function name does not matter

820

return {"org.freedesktop.DBus.Deprecated": "true",

821

"org.freedesktop.DBus.Property.EmitsChangedSignal":

822

"false"}

823

"""

824

825

def decorator(func):

826

func._dbus_is_interface = True

827

func._dbus_interface = dbus_interface

828

func._dbus_name = dbus_interface

829

return func

830

831

return decorator

832

833

834

def dbus_annotations(annotations):

835

"""Decorator to annotate D-Bus methods, signals or properties

836

Usage:

837

838

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",

839

"org.freedesktop.DBus.Property."

840

"EmitsChangedSignal": "false"})

841

@dbus_service_property("org.example.Interface", signature="b",

842

access="r")

843

def Property_dbus_property(self):

844

return dbus.Boolean(False)

845

"""

846

847

def decorator(func):

848

func._dbus_annotations = annotations

849

return func

850

597

851

return decorator

598

852

599

853

600

854

class DBusPropertyException(dbus.exceptions.DBusException):

601

855

"""A base class for D-Bus property-related exceptions

602

856

"""

603

def __unicode__(self):

604

return unicode(str(self))

857

pass

605

858

606

859

607

860

class DBusPropertyAccessException(DBusPropertyException):

625

878

"""

626

879

627

880

@staticmethod

628

def _is_dbus_property(obj):

629

return getattr(obj, "_dbus_is_property", False)

881

def _is_dbus_thing(thing):

882

"""Returns a function testing if an attribute is a D-Bus thing

883

884

If called like _is_dbus_thing("method") it returns a function

885

suitable for use as predicate to inspect.getmembers().

886

"""

887

return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),

888

False)

630

889

631

def _get_all_dbus_properties(self):

890

def _get_all_dbus_things(self, thing):

632

891

"""Returns a generator of (name, attribute) pairs

633

892

"""

634

return ((prop.__get__(self)._dbus_name, prop.__get__(self))

893

return ((getattr(athing.__get__(self), "_dbus_name", name),

894

athing.__get__(self))

635

895

for cls in self.__class__.__mro__

636

for name, prop in

637

inspect.getmembers(cls, self._is_dbus_property))

896

for name, athing in

897

inspect.getmembers(cls, self._is_dbus_thing(thing)))

638

898

639

899

def _get_dbus_property(self, interface_name, property_name):

640

900

"""Returns a bound method if one exists which is a D-Bus

641

901

property with the specified name and interface.

642

902

"""

643

for cls in self.__class__.__mro__:

644

for name, value in (inspect.getmembers

645

(cls, self._is_dbus_property)):

903

for cls in self.__class__.__mro__:

904

for name, value in inspect.getmembers(

905

cls, self._is_dbus_thing("property")):

646

906

if (value._dbus_name == property_name

647

907

and value._dbus_interface == interface_name):

648

908

return value.__get__(self)

649

909

650

910

# No such property

651

raise DBusPropertyNotFound(self.dbus_object_path + ":"

652

+ interface_name + "."

653

+ property_name)

911

raise DBusPropertyNotFound("{}:{}.{}".format(

912

self.dbus_object_path, interface_name, property_name))

654

913

655

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",

914

@dbus.service.method(dbus.PROPERTIES_IFACE,

915

in_signature="ss",

656

916

out_signature="v")

657

917

def Get(self, interface_name, property_name):

658

918

"""Standard D-Bus property Get() method, see D-Bus standard.

676

936

# The byte_arrays option is not supported yet on

677

937

# signatures other than "ay".

678

938

if prop._dbus_signature != "ay":

679

raise ValueError

680

value = dbus.ByteArray(''.join(unichr(byte)

681

for byte in value))

939

raise ValueError("Byte arrays not supported for non-"

940

"'ay' signature {!r}"

941

.format(prop._dbus_signature))

942

value = dbus.ByteArray(b''.join(chr(byte)

943

for byte in value))

682

944

prop(value)

683

945

684

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",

946

@dbus.service.method(dbus.PROPERTIES_IFACE,

947

in_signature="s",

685

948

out_signature="a{sv}")

686

949

def GetAll(self, interface_name):

687

950

"""Standard D-Bus property GetAll() method, see D-Bus

689

952

690

953

Note: Will not include properties with access="write".

691

954

"""

692

all = {}

693

for name, prop in self._get_all_dbus_properties():

955

properties = {}

956

for name, prop in self._get_all_dbus_things("property"):

694

957

if (interface_name

695

958

and interface_name != prop._dbus_interface):

696

959

# Interface non-empty but did not match

700

963

continue

701

964

value = prop()

702

965

if not hasattr(value, "variant_level"):

703

all[name] = value

966

properties[name] = value

704

967

continue

705

all[name] = type(value)(value, variant_level=

706

value.variant_level+1)

707

return dbus.Dictionary(all, signature="sv")

968

properties[name] = type(value)(

969

value, variant_level = value.variant_level + 1)

970

return dbus.Dictionary(properties, signature="sv")

971

972

@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")

973

def PropertiesChanged(self, interface_name, changed_properties,

974

invalidated_properties):

975

"""Standard D-Bus PropertiesChanged() signal, see D-Bus

976

standard.

977

"""

978

pass

708

979

709

980

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

710

981

out_signature="s",

711

982

path_keyword='object_path',

712

983

connection_keyword='connection')

713

984

def Introspect(self, object_path, connection):

714

"""Standard D-Bus method, overloaded to insert property tags.

985

"""Overloading of standard D-Bus method.

986

987

Inserts property tags and interface annotation tags.

715

988

"""

716

989

xmlstring = dbus.service.Object.Introspect(self, object_path,

717

990

connection)

718

991

try:

719

992

document = xml.dom.minidom.parseString(xmlstring)

993

720

994

def make_tag(document, name, prop):

721

995

e = document.createElement("property")

722

996

e.setAttribute("name", name)

723

997

e.setAttribute("type", prop._dbus_signature)

724

998

e.setAttribute("access", prop._dbus_access)

725

999

return e

1000

726

1001

for if_tag in document.getElementsByTagName("interface"):

1002

# Add property tags

727

1003

for tag in (make_tag(document, name, prop)

728

1004

for name, prop

729

in self._get_all_dbus_properties()

1005

in self._get_all_dbus_things("property")

730

1006

if prop._dbus_interface

731

1007

== if_tag.getAttribute("name")):

732

1008

if_tag.appendChild(tag)

1009

# Add annotation tags

1010

for typ in ("method", "signal", "property"):

1011

for tag in if_tag.getElementsByTagName(typ):

1012

annots = dict()

1013

for name, prop in (self.

1014

_get_all_dbus_things(typ)):

1015

if (name == tag.getAttribute("name")

1016

and prop._dbus_interface

1017

== if_tag.getAttribute("name")):

1018

annots.update(getattr(

1019

prop, "_dbus_annotations", {}))

1020

for name, value in annots.items():

1021

ann_tag = document.createElement(

1022

"annotation")

1023

ann_tag.setAttribute("name", name)

1024

ann_tag.setAttribute("value", value)

1025

tag.appendChild(ann_tag)

1026

# Add interface annotation tags

1027

for annotation, value in dict(

1028

itertools.chain.from_iterable(

1029

annotations().items()

1030

for name, annotations

1031

in self._get_all_dbus_things("interface")

1032

if name == if_tag.getAttribute("name")

1033

)).items():

1034

ann_tag = document.createElement("annotation")

1035

ann_tag.setAttribute("name", annotation)

1036

ann_tag.setAttribute("value", value)

1037

if_tag.appendChild(ann_tag)

733

1038

# Add the names to the return values for the

734

1039

# "org.freedesktop.DBus.Properties" methods

735

1040

if (if_tag.getAttribute("name")

750

1055

except (AttributeError, xml.dom.DOMException,

751

1056

xml.parsers.expat.ExpatError) as error:

752

1057

logger.error("Failed to override Introspection method",

753

error)

1058

exc_info=error)

754

1059

return xmlstring

755

1060

756

1061

757

def datetime_to_dbus (dt, variant_level=0):

1062

def datetime_to_dbus(dt, variant_level=0):

758

1063

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

759

1064

if dt is None:

760

1065

return dbus.String("", variant_level = variant_level)

761

return dbus.String(dt.isoformat(),

762

variant_level=variant_level)

763

764

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

765

.__metaclass__):

766

"""Applied to an empty subclass of a D-Bus object, this metaclass

767

will add additional D-Bus attributes matching a certain pattern.

1066

return dbus.String(dt.isoformat(), variant_level=variant_level)

1067

1068

1069

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1070

"""A class decorator; applied to a subclass of

1071

dbus.service.Object, it will add alternate D-Bus attributes with

1072

interface names according to the "alt_interface_names" mapping.

1073

Usage:

1074

1075

@alternate_dbus_interfaces({"org.example.Interface":

1076

"net.example.AlternateInterface"})

1077

class SampleDBusObject(dbus.service.Object):

1078

@dbus.service.method("org.example.Interface")

1079

def SampleDBusMethod():

1080

pass

1081

1082

The above "SampleDBusMethod" on "SampleDBusObject" will be

1083

reachable via two interfaces: "org.example.Interface" and

1084

"net.example.AlternateInterface", the latter of which will have

1085

its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to

1086

"true", unless "deprecate" is passed with a False value.

1087

1088

This works for methods and signals, and also for D-Bus properties

1089

(from DBusObjectWithProperties) and interfaces (from the

1090

dbus_interface_annotations decorator).

768

1091

"""

769

def __new__(mcs, name, bases, attr):

770

# Go through all the base classes which could have D-Bus

771

# methods, signals, or properties in them

772

for base in (b for b in bases

773

if issubclass(b, dbus.service.Object)):

774

# Go though all attributes of the base class

775

for attrname, attribute in inspect.getmembers(base):

1092

1093

def wrapper(cls):

1094

for orig_interface_name, alt_interface_name in (

1095

alt_interface_names.items()):

1096

attr = {}

1097

interface_names = set()

1098

# Go though all attributes of the class

1099

for attrname, attribute in inspect.getmembers(cls):

776

1100

# Ignore non-D-Bus attributes, and D-Bus attributes

777

1101

# with the wrong interface name

778

1102

if (not hasattr(attribute, "_dbus_interface")

779

or not attribute._dbus_interface

780

.startswith("se.recompile.Mandos")):

1103

or not attribute._dbus_interface.startswith(

1104

orig_interface_name)):

781

1105

continue

782

1106

# Create an alternate D-Bus interface name based on

783

1107

# the current name

784

alt_interface = (attribute._dbus_interface

785

.replace("se.recompile.Mandos",

786

"se.bsnet.fukt.Mandos"))

1108

alt_interface = attribute._dbus_interface.replace(

1109

orig_interface_name, alt_interface_name)

1110

interface_names.add(alt_interface)

787

1111

# Is this a D-Bus signal?

788

1112

if getattr(attribute, "_dbus_is_signal", False):

789

# Extract the original non-method function by

790

# black magic

1113

# Extract the original non-method undecorated

1114

# function by black magic

791

1115

nonmethod_func = (dict(

792

zip(attribute.func_code.co_freevars,

793

attribute.__closure__))["func"]

794

.cell_contents)

1116

zip(attribute.func_code.co_freevars,

1117

attribute.__closure__))

1118

["func"].cell_contents)

795

1119

# Create a new, but exactly alike, function

796

1120

# object, and decorate it to be a new D-Bus signal

797

1121

# with the alternate D-Bus interface name

798

new_function = (dbus.service.signal

799

(alt_interface,

800

attribute._dbus_signature)

1122

new_function = (dbus.service.signal(

1123

alt_interface, attribute._dbus_signature)

801

1124

(types.FunctionType(

802

nonmethod_func.func_code,

803

nonmethod_func.func_globals,

804

nonmethod_func.func_name,

805

nonmethod_func.func_defaults,

806

nonmethod_func.func_closure)))

1125

nonmethod_func.func_code,

1126

nonmethod_func.func_globals,

1127

nonmethod_func.func_name,

1128

nonmethod_func.func_defaults,

1129

nonmethod_func.func_closure)))

1130

# Copy annotations, if any

1131

try:

1132

new_function._dbus_annotations = dict(

1133

attribute._dbus_annotations)

1134

except AttributeError:

1135

pass

807

1136

# Define a creator of a function to call both the

808

# old and new functions, so both the old and new

809

# signals gets sent when the function is called

1137

# original and alternate functions, so both the

1138

# original and alternate signals gets sent when

1139

# the function is called

810

1140

def fixscope(func1, func2):

811

1141

"""This function is a scope container to pass

812

1142

func1 and func2 to the "call_both" function

813

1143

outside of its arguments"""

1144

814

1145

def call_both(*args, **kwargs):

815

1146

"""This function will emit two D-Bus

816

1147

signals by calling func1 and func2"""

817

1148

func1(*args, **kwargs)

818

1149

func2(*args, **kwargs)

1150

819

1151

return call_both

820

1152

# Create the "call_both" function and add it to

821

1153

# the class

822

attr[attrname] = fixscope(attribute,

823

new_function)

1154

attr[attrname] = fixscope(attribute, new_function)

824

1155

# Is this a D-Bus method?

825

1156

elif getattr(attribute, "_dbus_is_method", False):

826

1157

# Create a new, but exactly alike, function

827

1158

# object. Decorate it to be a new D-Bus method

828

1159

# with the alternate D-Bus interface name. Add it

829

1160

# to the class.

830

attr[attrname] = (dbus.service.method

831

(alt_interface,

832

attribute._dbus_in_signature,

833

attribute._dbus_out_signature)

834

(types.FunctionType

835

(attribute.func_code,

836

attribute.func_globals,

837

attribute.func_name,

838

attribute.func_defaults,

839

attribute.func_closure)))

1161

attr[attrname] = (

1162

dbus.service.method(

1163

alt_interface,

1164

attribute._dbus_in_signature,

1165

attribute._dbus_out_signature)

1166

(types.FunctionType(attribute.func_code,

1167

attribute.func_globals,

1168

attribute.func_name,

1169

attribute.func_defaults,

1170

attribute.func_closure)))

1171

# Copy annotations, if any

1172

try:

1173

attr[attrname]._dbus_annotations = dict(

1174

attribute._dbus_annotations)

1175

except AttributeError:

1176

pass

840

1177

# Is this a D-Bus property?

841

1178

elif getattr(attribute, "_dbus_is_property", False):

842

1179

# Create a new, but exactly alike, function

843

1180

# object, and decorate it to be a new D-Bus

844

1181

# property with the alternate D-Bus interface

845

1182

# name. Add it to the class.

846

attr[attrname] = (dbus_service_property

847

(alt_interface,

848

attribute._dbus_signature,

849

attribute._dbus_access,

850

attribute

851

._dbus_get_args_options

852

["byte_arrays"])

853

(types.FunctionType

854

(attribute.func_code,

855

attribute.func_globals,

856

attribute.func_name,

857

attribute.func_defaults,

858

attribute.func_closure)))

859

return type.__new__(mcs, name, bases, attr)

860

1183

attr[attrname] = (dbus_service_property(

1184

alt_interface, attribute._dbus_signature,

1185

attribute._dbus_access,

1186

attribute._dbus_get_args_options

1187

["byte_arrays"])

1188

(types.FunctionType(

1189

attribute.func_code,

1190

attribute.func_globals,

1191

attribute.func_name,

1192

attribute.func_defaults,

1193

attribute.func_closure)))

1194

# Copy annotations, if any

1195

try:

1196

attr[attrname]._dbus_annotations = dict(

1197

attribute._dbus_annotations)

1198

except AttributeError:

1199

pass

1200

# Is this a D-Bus interface?

1201

elif getattr(attribute, "_dbus_is_interface", False):

1202

# Create a new, but exactly alike, function

1203

# object. Decorate it to be a new D-Bus interface

1204

# with the alternate D-Bus interface name. Add it

1205

# to the class.

1206

attr[attrname] = (

1207

dbus_interface_annotations(alt_interface)

1208

(types.FunctionType(attribute.func_code,

1209

attribute.func_globals,

1210

attribute.func_name,

1211

attribute.func_defaults,

1212

attribute.func_closure)))

1213

if deprecate:

1214

# Deprecate all alternate interfaces

1215

iname="_AlternateDBusNames_interface_annotation{}"

1216

for interface_name in interface_names:

1217

1218

@dbus_interface_annotations(interface_name)

1219

def func(self):

1220

return { "org.freedesktop.DBus.Deprecated":

1221

"true" }

1222

# Find an unused name

1223

for aname in (iname.format(i)

1224

for i in itertools.count()):

1225

if aname not in attr:

1226

attr[aname] = func

1227

break

1228

if interface_names:

1229

# Replace the class with a new subclass of it with

1230

# methods, signals, etc. as created above.

1231

cls = type(b"{}Alternate".format(cls.__name__),

1232

(cls, ), attr)

1233

return cls

1234

1235

return wrapper

1236

1237

1238

@alternate_dbus_interfaces({"se.recompile.Mandos":

1239

"se.bsnet.fukt.Mandos"})

861

1240

class ClientDBus(Client, DBusObjectWithProperties):

862

1241

"""A Client class using D-Bus

863

1242

867

1246

"""

868

1247

869

1248

runtime_expansions = (Client.runtime_expansions

870

+ ("dbus_object_path",))

1249

+ ("dbus_object_path", ))

1250

1251

_interface = "se.recompile.Mandos.Client"

871

1252

872

1253

# dbus.service.Object doesn't use super(), so we can't either.

873

1254

874

1255

def __init__(self, bus = None, *args, **kwargs):

875

self._approvals_pending = 0

876

1256

self.bus = bus

877

1257

Client.__init__(self, *args, **kwargs)

878

1258

# Only now, when this client is initialized, can it show up on

879

1259

# the D-Bus

880

client_object_name = unicode(self.name).translate(

1260

client_object_name = str(self.name).translate(

881

1261

{ord("."): ord("_"),

882

1262

ord("-"): ord("_")})

883

self.dbus_object_path = (dbus.ObjectPath

884

("/clients/" + client_object_name))

1263

self.dbus_object_path = dbus.ObjectPath(

1264

"/clients/" + client_object_name)

885

1265

DBusObjectWithProperties.__init__(self, self.bus,

886

1266

self.dbus_object_path)

887

888

def notifychangeproperty(transform_func,

889

dbus_name, type_func=lambda x: x,

890

variant_level=1):

1267

1268

def notifychangeproperty(transform_func, dbus_name,

1269

type_func=lambda x: x,

1270

variant_level=1,

1271

invalidate_only=False,

1272

_interface=_interface):

891

1273

""" Modify a variable so that it's a property which announces

892

1274

its changes to DBus.

893

1275

894

1276

transform_fun: Function that takes a value and a variant_level

895

1277

and transforms it to a D-Bus type.

896

1278

dbus_name: D-Bus name of the variable

898

1280

to the D-Bus. Default: no transform

899

1281

variant_level: D-Bus variant level. Default: 1

900

1282

"""

901

attrname = "_{0}".format(dbus_name)

1283

attrname = "_{}".format(dbus_name)

1284

902

1285

def setter(self, value):

903

1286

if hasattr(self, "dbus_object_path"):

904

1287

if (not hasattr(self, attrname) or

905

1288

type_func(getattr(self, attrname, None))

906

1289

!= type_func(value)):

907

dbus_value = transform_func(type_func(value),

908

variant_level

909

=variant_level)

910

self.PropertyChanged(dbus.String(dbus_name),

911

dbus_value)

1290

if invalidate_only:

1291

self.PropertiesChanged(

1292

_interface, dbus.Dictionary(),

1293

dbus.Array((dbus_name, )))

1294

else:

1295

dbus_value = transform_func(

1296

type_func(value),

1297

variant_level = variant_level)

1298

self.PropertyChanged(dbus.String(dbus_name),

1299

dbus_value)

1300

self.PropertiesChanged(

1301

_interface,

1302

dbus.Dictionary({ dbus.String(dbus_name):

1303

dbus_value }),

1304

dbus.Array())

912

1305

setattr(self, attrname, value)

913

1306

914

1307

return property(lambda self: getattr(self, attrname), setter)

915

1308

916

917

1309

expires = notifychangeproperty(datetime_to_dbus, "Expires")

918

1310

approvals_pending = notifychangeproperty(dbus.Boolean,

919

1311

"ApprovalPending",

921

1313

enabled = notifychangeproperty(dbus.Boolean, "Enabled")

922

1314

last_enabled = notifychangeproperty(datetime_to_dbus,

923

1315

"LastEnabled")

924

checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",

925

type_func = lambda checker:

926

checker is not None)

1316

checker = notifychangeproperty(

1317

dbus.Boolean, "CheckerRunning",

1318

type_func = lambda checker: checker is not None)

927

1319

last_checked_ok = notifychangeproperty(datetime_to_dbus,

928

1320

"LastCheckedOK")

1321

last_checker_status = notifychangeproperty(dbus.Int16,

1322

"LastCheckerStatus")

929

1323

last_approval_request = notifychangeproperty(

930

1324

datetime_to_dbus, "LastApprovalRequest")

931

1325

approved_by_default = notifychangeproperty(dbus.Boolean,

932

1326

"ApprovedByDefault")

933

approval_delay = notifychangeproperty(dbus.UInt16,

934

"ApprovalDelay",

935

type_func =

936

_timedelta_to_milliseconds)

1327

approval_delay = notifychangeproperty(

1328

dbus.UInt64, "ApprovalDelay",

1329

type_func = lambda td: td.total_seconds() * 1000)

937

1330

approval_duration = notifychangeproperty(

938

dbus.UInt16, "ApprovalDuration",

939

type_func = _timedelta_to_milliseconds)

1331

dbus.UInt64, "ApprovalDuration",

1332

type_func = lambda td: td.total_seconds() * 1000)

940

1333

host = notifychangeproperty(dbus.String, "Host")

941

timeout = notifychangeproperty(dbus.UInt16, "Timeout",

942

type_func =

943

_timedelta_to_milliseconds)

1334

timeout = notifychangeproperty(

1335

dbus.UInt64, "Timeout",

1336

type_func = lambda td: td.total_seconds() * 1000)

944

1337

extended_timeout = notifychangeproperty(

945

dbus.UInt16, "ExtendedTimeout",

946

type_func = _timedelta_to_milliseconds)

947

interval = notifychangeproperty(dbus.UInt16,

948

"Interval",

949

type_func =

950

_timedelta_to_milliseconds)

1338

dbus.UInt64, "ExtendedTimeout",

1339

type_func = lambda td: td.total_seconds() * 1000)

1340

interval = notifychangeproperty(

1341

dbus.UInt64, "Interval",

1342

type_func = lambda td: td.total_seconds() * 1000)

951

1343

checker_command = notifychangeproperty(dbus.String, "Checker")

1344

secret = notifychangeproperty(dbus.ByteArray, "Secret",

1345

invalidate_only=True)

952

1346

953

1347

del notifychangeproperty

954

1348

981

1375

*args, **kwargs)

982

1376

983

1377

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

984

old_checker = self.checker

985

if self.checker is not None:

986

old_checker_pid = self.checker.pid

987

else:

988

old_checker_pid = None

1378

old_checker_pid = getattr(self.checker, "pid", None)

989

1379

r = Client.start_checker(self, *args, **kwargs)

990

1380

# Only if new checker process was started

991

1381

if (self.checker is not None

995

1385

return r

996

1386

997

1387

def _reset_approved(self):

998

self._approved = None

1388

self.approved = None

999

1389

return False

1000

1390

1001

1391

def approve(self, value=True):

1392

self.approved = value

1393

gobject.timeout_add(int(self.approval_duration.total_seconds()

1394

* 1000), self._reset_approved)

1002

1395

self.send_changedstate()

1003

self._approved = value

1004

gobject.timeout_add(_timedelta_to_milliseconds

1005

(self.approval_duration),

1006

self._reset_approved)

1007

1008

1396

1009

1397

## D-Bus methods, signals & properties

1010

_interface = "se.recompile.Mandos.Client"

1398

1399

## Interfaces

1011

1400

1012

1401

## Signals

1013

1402

1024

1413

pass

1025

1414

1026

1415

# PropertyChanged - signal

1416

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})

1027

1417

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

1028

1418

def PropertyChanged(self, property, value):

1029

1419

"D-Bus signal"

1093

1483

return dbus.Boolean(bool(self.approvals_pending))

1094

1484

1095

1485

# ApprovedByDefault - property

1096

@dbus_service_property(_interface, signature="b",

1486

@dbus_service_property(_interface,

1487

signature="b",

1097

1488

access="readwrite")

1098

1489

def ApprovedByDefault_dbus_property(self, value=None):

1099

1490

if value is None: # get

1101

1492

self.approved_by_default = bool(value)

1102

1493

1103

1494

# ApprovalDelay - property

1104

@dbus_service_property(_interface, signature="t",

1495

@dbus_service_property(_interface,

1496

signature="t",

1105

1497

access="readwrite")

1106

1498

def ApprovalDelay_dbus_property(self, value=None):

1107

1499

if value is None: # get

1108

return dbus.UInt64(self.approval_delay_milliseconds())

1500

return dbus.UInt64(self.approval_delay.total_seconds()

1501

* 1000)

1109

1502

self.approval_delay = datetime.timedelta(0, 0, 0, value)

1110

1503

1111

1504

# ApprovalDuration - property

1112

@dbus_service_property(_interface, signature="t",

1505

@dbus_service_property(_interface,

1506

signature="t",

1113

1507

access="readwrite")

1114

1508

def ApprovalDuration_dbus_property(self, value=None):

1115

1509

if value is None: # get

1116

return dbus.UInt64(_timedelta_to_milliseconds(

1117

self.approval_duration))

1510

return dbus.UInt64(self.approval_duration.total_seconds()

1511

* 1000)

1118

1512

self.approval_duration = datetime.timedelta(0, 0, 0, value)

1119

1513

1120

1514

# Name - property

1128

1522

return dbus.String(self.fingerprint)

1129

1523

1130

1524

# Host - property

1131

@dbus_service_property(_interface, signature="s",

1525

@dbus_service_property(_interface,

1526

signature="s",

1132

1527

access="readwrite")

1133

1528

def Host_dbus_property(self, value=None):

1134

1529

if value is None: # get

1135

1530

return dbus.String(self.host)

1136

self.host = value

1531

self.host = str(value)

1137

1532

1138

1533

# Created - property

1139

1534

@dbus_service_property(_interface, signature="s", access="read")

1140

1535

def Created_dbus_property(self):

1141

return dbus.String(datetime_to_dbus(self.created))

1536

return datetime_to_dbus(self.created)

1142

1537

1143

1538

# LastEnabled - property

1144

1539

@dbus_service_property(_interface, signature="s", access="read")

1146

1541

return datetime_to_dbus(self.last_enabled)

1147

1542

1148

1543

# Enabled - property

1149

@dbus_service_property(_interface, signature="b",

1544

@dbus_service_property(_interface,

1545

signature="b",

1150

1546

access="readwrite")

1151

1547

def Enabled_dbus_property(self, value=None):

1152

1548

if value is None: # get

1157

1553

self.disable()

1158

1554

1159

1555

# LastCheckedOK - property

1160

@dbus_service_property(_interface, signature="s",

1556

@dbus_service_property(_interface,

1557

signature="s",

1161

1558

access="readwrite")

1162

1559

def LastCheckedOK_dbus_property(self, value=None):

1163

1560

if value is not None:

1165

1562

return

1166

1563

return datetime_to_dbus(self.last_checked_ok)

1167

1564

1565

# LastCheckerStatus - property

1566

@dbus_service_property(_interface, signature="n", access="read")

1567

def LastCheckerStatus_dbus_property(self):

1568

return dbus.Int16(self.last_checker_status)

1569

1168

1570

# Expires - property

1169

1571

@dbus_service_property(_interface, signature="s", access="read")

1170

1572

def Expires_dbus_property(self):

1176

1578

return datetime_to_dbus(self.last_approval_request)

1177

1579

1178

1580

# Timeout - property

1179

@dbus_service_property(_interface, signature="t",

1581

@dbus_service_property(_interface,

1582

signature="t",

1180

1583

access="readwrite")

1181

1584

def Timeout_dbus_property(self, value=None):

1182

1585

if value is None: # get

1183

return dbus.UInt64(self.timeout_milliseconds())

1586

return dbus.UInt64(self.timeout.total_seconds() * 1000)

1587

old_timeout = self.timeout

1184

1588

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

1185

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

1186

return

1187

# Reschedule timeout

1188

gobject.source_remove(self.disable_initiator_tag)

1189

self.disable_initiator_tag = None

1190

self.expires = None

1191

time_to_die = _timedelta_to_milliseconds((self

1192

.last_checked_ok

1193

+ self.timeout)

1194

- datetime.datetime

1195

.utcnow())

1196

if time_to_die <= 0:

1197

# The timeout has passed

1198

self.disable()

1199

else:

1200

self.expires = (datetime.datetime.utcnow()

1201

+ datetime.timedelta(milliseconds =

1202

time_to_die))

1203

self.disable_initiator_tag = (gobject.timeout_add

1204

(time_to_die, self.disable))

1589

# Reschedule disabling

1590

if self.enabled:

1591

now = datetime.datetime.utcnow()

1592

self.expires += self.timeout - old_timeout

1593

if self.expires <= now:

1594

# The timeout has passed

1595

self.disable()

1596

else:

1597

if (getattr(self, "disable_initiator_tag", None)

1598

is None):

1599

return

1600

gobject.source_remove(self.disable_initiator_tag)

1601

self.disable_initiator_tag = gobject.timeout_add(

1602

int((self.expires - now).total_seconds() * 1000),

1603

self.disable)

1205

1604

1206

1605

# ExtendedTimeout - property

1207

@dbus_service_property(_interface, signature="t",

1606

@dbus_service_property(_interface,

1607

signature="t",

1208

1608

access="readwrite")

1209

1609

def ExtendedTimeout_dbus_property(self, value=None):

1210

1610

if value is None: # get

1211

return dbus.UInt64(self.extended_timeout_milliseconds())

1611

return dbus.UInt64(self.extended_timeout.total_seconds()

1612

* 1000)

1212

1613

self.extended_timeout = datetime.timedelta(0, 0, 0, value)

1213

1614

1214

1615

# Interval - property

1215

@dbus_service_property(_interface, signature="t",

1616

@dbus_service_property(_interface,

1617

signature="t",

1216

1618

access="readwrite")

1217

1619

def Interval_dbus_property(self, value=None):

1218

1620

if value is None: # get

1219

return dbus.UInt64(self.interval_milliseconds())

1621

return dbus.UInt64(self.interval.total_seconds() * 1000)

1220

1622

self.interval = datetime.timedelta(0, 0, 0, value)

1221

1623

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

1222

1624

return

1223

# Reschedule checker run

1224

gobject.source_remove(self.checker_initiator_tag)

1225

self.checker_initiator_tag = (gobject.timeout_add

1226

(value, self.start_checker))

1227

self.start_checker() # Start one now, too

1625

if self.enabled:

1626

# Reschedule checker run

1627

gobject.source_remove(self.checker_initiator_tag)

1628

self.checker_initiator_tag = gobject.timeout_add(

1629

value, self.start_checker)

1630

self.start_checker() # Start one now, too

1228

1631

1229

1632

# Checker - property

1230

@dbus_service_property(_interface, signature="s",

1633

@dbus_service_property(_interface,

1634

signature="s",

1231

1635

access="readwrite")

1232

1636

def Checker_dbus_property(self, value=None):

1233

1637

if value is None: # get

1234

1638

return dbus.String(self.checker_command)

1235

self.checker_command = value

1639

self.checker_command = str(value)

1236

1640

1237

1641

# CheckerRunning - property

1238

@dbus_service_property(_interface, signature="b",

1642

@dbus_service_property(_interface,

1643

signature="b",

1239

1644

access="readwrite")

1240

1645

def CheckerRunning_dbus_property(self, value=None):

1241

1646

if value is None: # get

1251

1656

return self.dbus_object_path # is already a dbus.ObjectPath

1252

1657

1253

1658

# Secret = property

1254

@dbus_service_property(_interface, signature="ay",

1255

access="write", byte_arrays=True)

1659

@dbus_service_property(_interface,

1660

signature="ay",

1661

access="write",

1662

byte_arrays=True)

1256

1663

def Secret_dbus_property(self, value):

1257

self.secret = str(value)

1664

self.secret = bytes(value)

1258

1665

1259

1666

del _interface

1260

1667

1267

1674

raise KeyError()

1268

1675

1269

1676

def __getattribute__(self, name):

1270

if(name == '_pipe'):

1677

if name == '_pipe':

1271

1678

return super(ProxyClient, self).__getattribute__(name)

1272

1679

self._pipe.send(('getattr', name))

1273

1680

data = self._pipe.recv()

1274

1681

if data[0] == 'data':

1275

1682

return data[1]

1276

1683

if data[0] == 'function':

1684

1277

1685

def func(*args, **kwargs):

1278

1686

self._pipe.send(('funcall', name, args, kwargs))

1279

1687

return self._pipe.recv()[1]

1688

1280

1689

return func

1281

1690

1282

1691

def __setattr__(self, name, value):

1283

if(name == '_pipe'):

1692

if name == '_pipe':

1284

1693

return super(ProxyClient, self).__setattr__(name, value)

1285

1694

self._pipe.send(('setattr', name, value))

1286

1695

1287

class ClientDBusTransitional(ClientDBus):

1288

__metaclass__ = AlternateDBusNamesMetaclass

1289

1696

1290

1697

class ClientHandler(socketserver.BaseRequestHandler, object):

1291

1698

"""A class to handle client connections.

1296

1703

def handle(self):

1297

1704

with contextlib.closing(self.server.child_pipe) as child_pipe:

1298

1705

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

1299

unicode(self.client_address))

1706

str(self.client_address))

1300

1707

logger.debug("Pipe FD: %d",

1301

1708

self.server.child_pipe.fileno())

1302

1709

1303

session = (gnutls.connection

1304

.ClientSession(self.request,

1305

gnutls.connection

1306

.X509Credentials()))

1710

session = gnutls.connection.ClientSession(

1711

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

1307

1712

1308

1713

# Note: gnutls.connection.X509Credentials is really a

1309

1714

# generic GnuTLS certificate credentials object so long as

1318

1723

priority = self.server.gnutls_priority

1319

1724

if priority is None:

1320

1725

priority = "NORMAL"

1321

(gnutls.library.functions

1322

.gnutls_priority_set_direct(session._c_object,

1323

priority, None))

1726

gnutls.library.functions.gnutls_priority_set_direct(

1727

session._c_object, priority, None)

1324

1728

1325

1729

# Start communication using the Mandos protocol

1326

1730

# Get protocol number

1328

1732

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

1329

1733

try:

1330

1734

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

1331

raise RuntimeError

1735

raise RuntimeError(line)

1332

1736

except (ValueError, IndexError, RuntimeError) as error:

1333

1737

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

1334

1738

return

1346

1750

approval_required = False

1347

1751

try:

1348

1752

try:

1349

fpr = self.fingerprint(self.peer_certificate

1350

(session))

1753

fpr = self.fingerprint(

1754

self.peer_certificate(session))

1351

1755

except (TypeError,

1352

1756

gnutls.errors.GNUTLSError) as error:

1353

1757

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

1368

1772

while True:

1369

1773

if not client.enabled:

1370

1774

logger.info("Client %s is disabled",

1371

client.name)

1775

client.name)

1372

1776

if self.server.use_dbus:

1373

1777

# Emit D-Bus signal

1374

1778

client.Rejected("Disabled")

1375

1779

return

1376

1780

1377

if client._approved or not client.approval_delay:

1781

if client.approved or not client.approval_delay:

1378

1782

#We are approved or approval is disabled

1379

1783

break

1380

elif client._approved is None:

1784

elif client.approved is None:

1381

1785

logger.info("Client %s needs approval",

1382

1786

client.name)

1383

1787

if self.server.use_dbus:

1384

1788

# Emit D-Bus signal

1385

1789

client.NeedApproval(

1386

client.approval_delay_milliseconds(),

1387

client.approved_by_default)

1790

client.approval_delay.total_seconds()

1791

* 1000, client.approved_by_default)

1388

1792

else:

1389

1793

logger.warning("Client %s was not approved",

1390

1794

client.name)

1396

1800

#wait until timeout or approved

1397

1801

time = datetime.datetime.now()

1398

1802

client.changedstate.acquire()

1399

(client.changedstate.wait

1400

(float(client._timedelta_to_milliseconds(delay)

1401

/ 1000)))

1803

client.changedstate.wait(delay.total_seconds())

1402

1804

client.changedstate.release()

1403

1805

time2 = datetime.datetime.now()

1404

1806

if (time2 - time) >= delay:

1420

1822

try:

1421

1823

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

1422

1824

except gnutls.errors.GNUTLSError as error:

1423

logger.warning("gnutls send failed")

1825

logger.warning("gnutls send failed",

1826

exc_info=error)

1424

1827

return

1425

logger.debug("Sent: %d, remaining: %d",

1426

sent, len(client.secret)

1427

- (sent_size + sent))

1828

logger.debug("Sent: %d, remaining: %d", sent,

1829

len(client.secret) - (sent_size

1830

+ sent))

1428

1831

sent_size += sent

1429

1832

1430

1833

logger.info("Sending secret to %s", client.name)

1431

1834

# bump the timeout using extended_timeout

1432

client.checked_ok(client.extended_timeout)

1835

client.bump_timeout(client.extended_timeout)

1433

1836

if self.server.use_dbus:

1434

1837

# Emit D-Bus signal

1435

1838

client.GotSecret()

1440

1843

try:

1441

1844

session.bye()

1442

1845

except gnutls.errors.GNUTLSError as error:

1443

logger.warning("GnuTLS bye failed")

1846

logger.warning("GnuTLS bye failed",

1847

exc_info=error)

1444

1848

1445

1849

@staticmethod

1446

1850

def peer_certificate(session):

1447

1851

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

1448

1852

# If not an OpenPGP certificate...

1449

if (gnutls.library.functions

1450

.gnutls_certificate_type_get(session._c_object)

1853

if (gnutls.library.functions.gnutls_certificate_type_get(

1854

session._c_object)

1451

1855

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1452

1856

# ...do the normal thing

1453

1857

return session.peer_certificate

1467

1871

def fingerprint(openpgp):

1468

1872

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

1469

1873

# New GnuTLS "datum" with the OpenPGP public key

1470

datum = (gnutls.library.types

1471

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

1472

ctypes.POINTER

1473

(ctypes.c_ubyte)),

1474

ctypes.c_uint(len(openpgp))))

1874

datum = gnutls.library.types.gnutls_datum_t(

1875

ctypes.cast(ctypes.c_char_p(openpgp),

1876

ctypes.POINTER(ctypes.c_ubyte)),

1877

ctypes.c_uint(len(openpgp)))

1475

1878

# New empty GnuTLS certificate

1476

1879

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1477

(gnutls.library.functions

1478

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

1880

gnutls.library.functions.gnutls_openpgp_crt_init(

1881

ctypes.byref(crt))

1479

1882

# Import the OpenPGP public key into the certificate

1480

(gnutls.library.functions

1481

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

1482

gnutls.library.constants

1483

.GNUTLS_OPENPGP_FMT_RAW))

1883

gnutls.library.functions.gnutls_openpgp_crt_import(

1884

crt, ctypes.byref(datum),

1885

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

1484

1886

# Verify the self signature in the key

1485

1887

crtverify = ctypes.c_uint()

1486

(gnutls.library.functions

1487

.gnutls_openpgp_crt_verify_self(crt, 0,

1488

ctypes.byref(crtverify)))

1888

gnutls.library.functions.gnutls_openpgp_crt_verify_self(

1889

crt, 0, ctypes.byref(crtverify))

1489

1890

if crtverify.value != 0:

1490

1891

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1491

raise (gnutls.errors.CertificateSecurityError

1492

("Verify failed"))

1892

raise gnutls.errors.CertificateSecurityError(

1893

"Verify failed")

1493

1894

# New buffer for the fingerprint

1494

1895

buf = ctypes.create_string_buffer(20)

1495

1896

buf_len = ctypes.c_size_t()

1496

1897

# Get the fingerprint from the certificate into the buffer

1497

(gnutls.library.functions

1498

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

1499

ctypes.byref(buf_len)))

1898

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(

1899

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

1500

1900

# Deinit the certificate

1501

1901

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1502

1902

# Convert the buffer to a Python bytestring

1503

1903

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

1504

1904

# Convert the bytestring to hexadecimal notation

1505

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

1905

hex_fpr = binascii.hexlify(fpr).upper()

1506

1906

return hex_fpr

1507

1907

1508

1908

1509

1909

class MultiprocessingMixIn(object):

1510

1910

"""Like socketserver.ThreadingMixIn, but with multiprocessing"""

1911

1511

1912

def sub_process_main(self, request, address):

1512

1913

try:

1513

1914

self.finish_request(request, address)

1514

except:

1915

except Exception:

1515

1916

self.handle_error(request, address)

1516

1917

self.close_request(request)

1517

1918

1518

1919

def process_request(self, request, address):

1519

1920

"""Start a new process to process the request."""

1520

1921

proc = multiprocessing.Process(target = self.sub_process_main,

1521

args = (request,

1522

address))

1922

args = (request, address))

1523

1923

proc.start()

1524

1924

return proc

1525

1925

1526

1926

1527

1927

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1528

1928

""" adds a pipe to the MixIn """

1929

1529

1930

def process_request(self, request, client_address):

1530

1931

"""Overrides and wraps the original process_request().

1531

1932

1540

1941

1541

1942

def add_pipe(self, parent_pipe, proc):

1542

1943

"""Dummy function; override as necessary"""

1543

raise NotImplementedError

1944

raise NotImplementedError()

1544

1945

1545

1946

1546

1947

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1552

1953

interface: None or a network interface name (string)

1553

1954

use_ipv6: Boolean; to use IPv6 or not

1554

1955

"""

1956

1555

1957

def __init__(self, server_address, RequestHandlerClass,

1556

interface=None, use_ipv6=True):

1958

interface=None,

1959

use_ipv6=True,

1960

socketfd=None):

1961

"""If socketfd is set, use that file descriptor instead of

1962

creating a new one with socket.socket().

1963

"""

1557

1964

self.interface = interface

1558

1965

if use_ipv6:

1559

1966

self.address_family = socket.AF_INET6

1967

if socketfd is not None:

1968

# Save the file descriptor

1969

self.socketfd = socketfd

1970

# Save the original socket.socket() function

1971

self.socket_socket = socket.socket

1972

# To implement --socket, we monkey patch socket.socket.

1973

#

1974

# (When socketserver.TCPServer is a new-style class, we

1975

# could make self.socket into a property instead of monkey

1976

# patching socket.socket.)

1977

#

1978

# Create a one-time-only replacement for socket.socket()

1979

@functools.wraps(socket.socket)

1980

def socket_wrapper(*args, **kwargs):

1981

# Restore original function so subsequent calls are

1982

# not affected.

1983

socket.socket = self.socket_socket

1984

del self.socket_socket

1985

# This time only, return a new socket object from the

1986

# saved file descriptor.

1987

return socket.fromfd(self.socketfd, *args, **kwargs)

1988

# Replace socket.socket() function with wrapper

1989

socket.socket = socket_wrapper

1990

# The socketserver.TCPServer.__init__ will call

1991

# socket.socket(), which might be our replacement,

1992

# socket_wrapper(), if socketfd was set.

1560

1993

socketserver.TCPServer.__init__(self, server_address,

1561

1994

RequestHandlerClass)

1995

1562

1996

def server_bind(self):

1563

1997

"""This overrides the normal server_bind() function

1564

1998

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

1570

2004

self.interface)

1571

2005

else:

1572

2006

try:

1573

self.socket.setsockopt(socket.SOL_SOCKET,

1574

SO_BINDTODEVICE,

1575

str(self.interface

1576

+ '\0'))

2007

self.socket.setsockopt(

2008

socket.SOL_SOCKET, SO_BINDTODEVICE,

2009

(self.interface + "\0").encode("utf-8"))

1577

2010

except socket.error as error:

1578

if error[0] == errno.EPERM:

1579

logger.error("No permission to"

1580

" bind to interface %s",

1581

self.interface)

1582

elif error[0] == errno.ENOPROTOOPT:

2011

if error.errno == errno.EPERM:

2012

logger.error("No permission to bind to"

2013

" interface %s", self.interface)

2014

elif error.errno == errno.ENOPROTOOPT:

1583

2015

logger.error("SO_BINDTODEVICE not available;"

1584

2016

" cannot bind to interface %s",

1585

2017

self.interface)

2018

elif error.errno == errno.ENODEV:

2019

logger.error("Interface %s does not exist,"

2020

" cannot bind", self.interface)

1586

2021

else:

1587

2022

raise

1588

2023

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

1591

2026

if self.address_family == socket.AF_INET6:

1592

2027

any_address = "::" # in6addr_any

1593

2028

else:

1594

any_address = socket.INADDR_ANY

2029

any_address = "0.0.0.0" # INADDR_ANY

1595

2030

self.server_address = (any_address,

1596

2031

self.server_address[1])

1597

2032

elif not self.server_address[1]:

1598

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

1599

0)

2033

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

1600

2034

# if self.interface:

1601

2035

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

1602

2036

# 0, # port

1616

2050

1617

2051

Assumes a gobject.MainLoop event loop.

1618

2052

"""

2053

1619

2054

def __init__(self, server_address, RequestHandlerClass,

1620

interface=None, use_ipv6=True, clients=None,

1621

gnutls_priority=None, use_dbus=True):

2055

interface=None,

2056

use_ipv6=True,

2057

clients=None,

2058

gnutls_priority=None,

2059

use_dbus=True,

2060

socketfd=None):

1622

2061

self.enabled = False

1623

2062

self.clients = clients

1624

2063

if self.clients is None:

1625

self.clients = set()

2064

self.clients = {}

1626

2065

self.use_dbus = use_dbus

1627

2066

self.gnutls_priority = gnutls_priority

1628

2067

IPv6_TCPServer.__init__(self, server_address,

1629

2068

RequestHandlerClass,

1630

2069

interface = interface,

1631

use_ipv6 = use_ipv6)

2070

use_ipv6 = use_ipv6,

2071

socketfd = socketfd)

2072

1632

2073

def server_activate(self):

1633

2074

if self.enabled:

1634

2075

return socketserver.TCPServer.server_activate(self)

1638

2079

1639

2080

def add_pipe(self, parent_pipe, proc):

1640

2081

# Call "handle_ipc" for both data and EOF events

1641

gobject.io_add_watch(parent_pipe.fileno(),

1642

gobject.IO_IN | gobject.IO_HUP,

1643

functools.partial(self.handle_ipc,

1644

parent_pipe =

1645

parent_pipe,

1646

proc = proc))

2082

gobject.io_add_watch(

2083

parent_pipe.fileno(),

2084

gobject.IO_IN | gobject.IO_HUP,

2085

functools.partial(self.handle_ipc,

2086

parent_pipe = parent_pipe,

2087

proc = proc))

1647

2088

1648

def handle_ipc(self, source, condition, parent_pipe=None,

1649

proc = None, client_object=None):

1650

condition_names = {

1651

gobject.IO_IN: "IN", # There is data to read.

1652

gobject.IO_OUT: "OUT", # Data can be written (without

1653

# blocking).

1654

gobject.IO_PRI: "PRI", # There is urgent data to read.

1655

gobject.IO_ERR: "ERR", # Error condition.

1656

gobject.IO_HUP: "HUP" # Hung up (the connection has been

1657

# broken, usually for pipes and

1658

# sockets).

1659

}

1660

conditions_string = ' | '.join(name

1661

for cond, name in

1662

condition_names.iteritems()

1663

if cond & condition)

2089

def handle_ipc(self, source, condition,

2090

parent_pipe=None,

2091

proc = None,

2092

client_object=None):

1664

2093

# error, or the other end of multiprocessing.Pipe has closed

1665

if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):

2094

if condition & (gobject.IO_ERR | gobject.IO_HUP):

1666

2095

# Wait for other process to exit

1667

2096

proc.join()

1668

2097

return False

1675

2104

fpr = request[1]

1676

2105

address = request[2]

1677

2106

1678

for c in self.clients:

2107

for c in self.clients.itervalues():

1679

2108

if c.fingerprint == fpr:

1680

2109

client = c

1681

2110

break

1689

2118

parent_pipe.send(False)

1690

2119

return False

1691

2120

1692

gobject.io_add_watch(parent_pipe.fileno(),

1693

gobject.IO_IN | gobject.IO_HUP,

1694

functools.partial(self.handle_ipc,

1695

parent_pipe =

1696

parent_pipe,

1697

proc = proc,

1698

client_object =

1699

client))

2121

gobject.io_add_watch(

2122

parent_pipe.fileno(),

2123

gobject.IO_IN | gobject.IO_HUP,

2124

functools.partial(self.handle_ipc,

2125

parent_pipe = parent_pipe,

2126

proc = proc,

2127

client_object = client))

1700

2128

parent_pipe.send(True)

1701

2129

# remove the old hook in favor of the new above hook on

1702

2130

# same fileno

1708

2136

1709

2137

parent_pipe.send(('data', getattr(client_object,

1710

2138

funcname)(*args,

1711

**kwargs)))

2139

**kwargs)))

1712

2140

1713

2141

if command == 'getattr':

1714

2142

attrname = request[1]

1715

2143

if callable(client_object.__getattribute__(attrname)):

1716

parent_pipe.send(('function',))

2144

parent_pipe.send(('function', ))

1717

2145

else:

1718

parent_pipe.send(('data', client_object

1719

.__getattribute__(attrname)))

2146

parent_pipe.send((

2147

'data', client_object.__getattribute__(attrname)))

1720

2148

1721

2149

if command == 'setattr':

1722

2150

attrname = request[1]

1726

2154

return True

1727

2155

1728

2156

2157

def rfc3339_duration_to_delta(duration):

2158

"""Parse an RFC 3339 "duration" and return a datetime.timedelta

2159

2160

>>> rfc3339_duration_to_delta("P7D")

2161

datetime.timedelta(7)

2162

>>> rfc3339_duration_to_delta("PT60S")

2163

datetime.timedelta(0, 60)

2164

>>> rfc3339_duration_to_delta("PT60M")

2165

datetime.timedelta(0, 3600)

2166

>>> rfc3339_duration_to_delta("PT24H")

2167

datetime.timedelta(1)

2168

>>> rfc3339_duration_to_delta("P1W")

2169

datetime.timedelta(7)

2170

>>> rfc3339_duration_to_delta("PT5M30S")

2171

datetime.timedelta(0, 330)

2172

>>> rfc3339_duration_to_delta("P1DT3M20S")

2173

datetime.timedelta(1, 200)

2174

"""

2175

2176

# Parsing an RFC 3339 duration with regular expressions is not

2177

# possible - there would have to be multiple places for the same

2178

# values, like seconds. The current code, while more esoteric, is

2179

# cleaner without depending on a parsing library. If Python had a

2180

# built-in library for parsing we would use it, but we'd like to

2181

# avoid excessive use of external libraries.

2182

2183

# New type for defining tokens, syntax, and semantics all-in-one

2184

Token = collections.namedtuple("Token",

2185

("regexp", # To match token; if

2186

# "value" is not None,

2187

# must have a "group"

2188

# containing digits

2189

"value", # datetime.timedelta or

2190

# None

2191

"followers")) # Tokens valid after

2192

# this token

2193

Token = collections.namedtuple("Token", (

2194

"regexp", # To match token; if "value" is not None, must have

2195

# a "group" containing digits

2196

"value", # datetime.timedelta or None

2197

"followers")) # Tokens valid after this token

2198

# RFC 3339 "duration" tokens, syntax, and semantics; taken from

2199

# the "duration" ABNF definition in RFC 3339, Appendix A.

2200

token_end = Token(re.compile(r"$"), None, frozenset())

2201

token_second = Token(re.compile(r"(\d+)S"),

2202

datetime.timedelta(seconds=1),

2203

frozenset((token_end, )))

2204

token_minute = Token(re.compile(r"(\d+)M"),

2205

datetime.timedelta(minutes=1),

2206

frozenset((token_second, token_end)))

2207

token_hour = Token(re.compile(r"(\d+)H"),

2208

datetime.timedelta(hours=1),

2209

frozenset((token_minute, token_end)))

2210

token_time = Token(re.compile(r"T"),

2211

None,

2212

frozenset((token_hour, token_minute,

2213

token_second)))

2214

token_day = Token(re.compile(r"(\d+)D"),

2215

datetime.timedelta(days=1),

2216

frozenset((token_time, token_end)))

2217

token_month = Token(re.compile(r"(\d+)M"),

2218

datetime.timedelta(weeks=4),

2219

frozenset((token_day, token_end)))

2220

token_year = Token(re.compile(r"(\d+)Y"),

2221

datetime.timedelta(weeks=52),

2222

frozenset((token_month, token_end)))

2223

token_week = Token(re.compile(r"(\d+)W"),

2224

datetime.timedelta(weeks=1),

2225

frozenset((token_end, )))

2226

token_duration = Token(re.compile(r"P"), None,

2227

frozenset((token_year, token_month,

2228

token_day, token_time,

2229

token_week)))

2230

# Define starting values

2231

value = datetime.timedelta() # Value so far

2232

found_token = None

2233

followers = frozenset((token_duration,)) # Following valid tokens

2234

s = duration # String left to parse

2235

# Loop until end token is found

2236

while found_token is not token_end:

2237

# Search for any currently valid tokens

2238

for token in followers:

2239

match = token.regexp.match(s)

2240

if match is not None:

2241

# Token found

2242

if token.value is not None:

2243

# Value found, parse digits

2244

factor = int(match.group(1), 10)

2245

# Add to value so far

2246

value += factor * token.value

2247

# Strip token from string

2248

s = token.regexp.sub("", s, 1)

2249

# Go to found token

2250

found_token = token

2251

# Set valid next tokens

2252

followers = found_token.followers

2253

break

2254

else:

2255

# No currently valid tokens were found

2256

raise ValueError("Invalid RFC 3339 duration")

2257

# End token found

2258

return value

2259

2260

1729

2261

def string_to_delta(interval):

1730

2262

"""Parse a string and return a datetime.timedelta

1731

2263

1742

2274

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

1743

2275

datetime.timedelta(0, 330)

1744

2276

"""

2277

2278

try:

2279

return rfc3339_duration_to_delta(interval)

2280

except ValueError:

2281

pass

2282

1745

2283

timevalue = datetime.timedelta(0)

1746

2284

for s in interval.split():

1747

2285

try:

1748

suffix = unicode(s[-1])

2286

suffix = s[-1]

1749

2287

value = int(s[:-1])

1750

2288

if suffix == "d":

1751

2289

delta = datetime.timedelta(value)

1758

2296

elif suffix == "w":

1759

2297

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

1760

2298

else:

1761

raise ValueError("Unknown suffix %r" % suffix)

1762

except (ValueError, IndexError) as e:

2299

raise ValueError("Unknown suffix {!r}".format(suffix))

2300

except IndexError as e:

1763

2301

raise ValueError(*(e.args))

1764

2302

timevalue += delta

1765

2303

return timevalue

1766

2304

1767

2305

1768

def if_nametoindex(interface):

1769

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

1770

1771

Note: This function cannot accept a unicode string."""

1772

global if_nametoindex

1773

try:

1774

if_nametoindex = (ctypes.cdll.LoadLibrary

1775

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

1776

.if_nametoindex)

1777

except (OSError, AttributeError):

1778

logger.warning("Doing if_nametoindex the hard way")

1779

def if_nametoindex(interface):

1780

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

1781

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

1782

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

1783

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1784

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

1785

interface))

1786

interface_index = struct.unpack(str("I"),

1787

ifreq[16:20])[0]

1788

return interface_index

1789

return if_nametoindex(interface)

1790

1791

1792

2306

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

1793

2307

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

1794

2308

1802

2316

sys.exit()

1803

2317

if not noclose:

1804

2318

# Close all standard open file descriptors

1805

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

2319

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

1806

2320

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

1807

2321

raise OSError(errno.ENODEV,

1808

"%s not a character device"

1809

% os.path.devnull)

2322

"{} not a character device"

2323

.format(os.devnull))

1810

2324

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

1811

2325

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

1812

2326

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

1821

2335

1822

2336

parser = argparse.ArgumentParser()

1823

2337

parser.add_argument("-v", "--version", action="version",

1824

version = "%%(prog)s %s" % version,

2338

version = "%(prog)s {}".format(version),

1825

2339

help="show version number and exit")

1826

2340

parser.add_argument("-i", "--interface", metavar="IF",

1827

2341

help="Bind to interface IF")

1833

2347

help="Run self-test")

1834

2348

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

1835

2349

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

1836

" to terminal")

2350

" to terminal", default=None)

1837

2351

parser.add_argument("--debuglevel", metavar="LEVEL",

1838

2352

help="Debug level for stdout output")

1839

2353

parser.add_argument("--priority", help="GnuTLS"

1846

2360

" files")

1847

2361

parser.add_argument("--no-dbus", action="store_false",

1848

2362

dest="use_dbus", help="Do not provide D-Bus"

1849

" system bus interface")

2363

" system bus interface", default=None)

1850

2364

parser.add_argument("--no-ipv6", action="store_false",

1851

dest="use_ipv6", help="Do not use IPv6")

2365

dest="use_ipv6", help="Do not use IPv6",

2366

default=None)

2367

parser.add_argument("--no-restore", action="store_false",

2368

dest="restore", help="Do not restore stored"

2369

" state", default=None)

2370

parser.add_argument("--socket", type=int,

2371

help="Specify a file descriptor to a network"

2372

" socket to use instead of creating one")

2373

parser.add_argument("--statedir", metavar="DIR",

2374

help="Directory to save/restore state in")

2375

parser.add_argument("--foreground", action="store_true",

2376

help="Run in foreground", default=None)

2377

parser.add_argument("--no-zeroconf", action="store_false",

2378

dest="zeroconf", help="Do not use Zeroconf",

2379

default=None)

2380

1852

2381

options = parser.parse_args()

1853

2382

1854

2383

if options.check:

1855

2384

import doctest

1856

doctest.testmod()

1857

sys.exit()

2385

fail_count, test_count = doctest.testmod()

2386

sys.exit(os.EX_OK if fail_count == 0 else 1)

1858

2387

1859

2388

# Default values for config file for server-global settings

1860

2389

server_defaults = { "interface": "",

1862

2391

"port": "",

1863

2392

"debug": "False",

1864

2393

"priority":

1865

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

2394

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

2395

":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

1866

2396

"servicename": "Mandos",

1867

2397

"use_dbus": "True",

1868

2398

"use_ipv6": "True",

1869

2399

"debuglevel": "",

1870

}

2400

"restore": "True",

2401

"socket": "",

2402

"statedir": "/var/lib/mandos",

2403

"foreground": "False",

2404

"zeroconf": "True",

2405

}

1871

2406

1872

2407

# Parse config file for server-global settings

1873

2408

server_config = configparser.SafeConfigParser(server_defaults)

1874

2409

del server_defaults

1875

server_config.read(os.path.join(options.configdir,

1876

"mandos.conf"))

2410

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

1877

2411

# Convert the SafeConfigParser object to a dict

1878

2412

server_settings = server_config.defaults()

1879

2413

# Use the appropriate methods on the non-string config options

1880

for option in ("debug", "use_dbus", "use_ipv6"):

2414

for option in ("debug", "use_dbus", "use_ipv6", "foreground"):

1881

2415

server_settings[option] = server_config.getboolean("DEFAULT",

1882

2416

option)

1883

2417

if server_settings["port"]:

1884

2418

server_settings["port"] = server_config.getint("DEFAULT",

1885

2419

"port")

2420

if server_settings["socket"]:

2421

server_settings["socket"] = server_config.getint("DEFAULT",

2422

"socket")

2423

# Later, stdin will, and stdout and stderr might, be dup'ed

2424

# over with an opened os.devnull. But we don't want this to

2425

# happen with a supplied network socket.

2426

if 0 <= server_settings["socket"] <= 2:

2427

server_settings["socket"] = os.dup(server_settings

2428

["socket"])

1886

2429

del server_config

1887

2430

1888

2431

# Override the settings from the config file with command line

1889

2432

# options, if set.

1890

2433

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

1891

"priority", "servicename", "configdir",

1892

"use_dbus", "use_ipv6", "debuglevel"):

2434

"priority", "servicename", "configdir", "use_dbus",

2435

"use_ipv6", "debuglevel", "restore", "statedir",

2436

"socket", "foreground", "zeroconf"):

1893

2437

value = getattr(options, option)

1894

2438

if value is not None:

1895

2439

server_settings[option] = value

1896

2440

del options

1897

2441

# Force all strings to be unicode

1898

2442

for option in server_settings.keys():

1899

if type(server_settings[option]) is str:

1900

server_settings[option] = unicode(server_settings[option])

2443

if isinstance(server_settings[option], bytes):

2444

server_settings[option] = (server_settings[option]

2445

.decode("utf-8"))

2446

# Force all boolean options to be boolean

2447

for option in ("debug", "use_dbus", "use_ipv6", "restore",

2448

"foreground", "zeroconf"):

2449

server_settings[option] = bool(server_settings[option])

2450

# Debug implies foreground

2451

if server_settings["debug"]:

2452

server_settings["foreground"] = True

1901

2453

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

1902

2454

1903

2455

##################################################################

1904

2456

2457

if (not server_settings["zeroconf"]

2458

and not (server_settings["port"]

2459

or server_settings["socket"] != "")):

2460

parser.error("Needs port or socket to work without Zeroconf")

2461

1905

2462

# For convenience

1906

2463

debug = server_settings["debug"]

1907

2464

debuglevel = server_settings["debuglevel"]

1908

2465

use_dbus = server_settings["use_dbus"]

1909

2466

use_ipv6 = server_settings["use_ipv6"]

2467

stored_state_path = os.path.join(server_settings["statedir"],

2468

stored_state_file)

2469

foreground = server_settings["foreground"]

2470

zeroconf = server_settings["zeroconf"]

2471

2472

if debug:

2473

initlogger(debug, logging.DEBUG)

2474

else:

2475

if not debuglevel:

2476

initlogger(debug)

2477

else:

2478

level = getattr(logging, debuglevel.upper())

2479

initlogger(debug, level)

1910

2480

1911

2481

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

1912

syslogger.setFormatter(logging.Formatter

1913

('Mandos (%s) [%%(process)d]:'

1914

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

1915

% server_settings["servicename"]))

2482

syslogger.setFormatter(

2483

logging.Formatter('Mandos ({}) [%(process)d]:'

2484

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

2485

server_settings["servicename"])))

1916

2486

1917

2487

# Parse config file with clients

1918

client_defaults = { "timeout": "5m",

1919

"extended_timeout": "15m",

1920

"interval": "2m",

1921

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

1922

"host": "",

1923

"approval_delay": "0s",

1924

"approval_duration": "1s",

1925

}

1926

client_config = configparser.SafeConfigParser(client_defaults)

2488

client_config = configparser.SafeConfigParser(Client

2489

.client_defaults)

1927

2490

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

1928

2491

"clients.conf"))

1929

2492

1930

2493

global mandos_dbus_service

1931

2494

mandos_dbus_service = None

1932

2495

1933

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

1934

server_settings["port"]),

1935

ClientHandler,

1936

interface=(server_settings["interface"]

1937

or None),

1938

use_ipv6=use_ipv6,

1939

gnutls_priority=

1940

server_settings["priority"],

1941

use_dbus=use_dbus)

1942

if not debug:

1943

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

2496

socketfd = None

2497

if server_settings["socket"] != "":

2498

socketfd = server_settings["socket"]

2499

tcp_server = MandosServer(

2500

(server_settings["address"], server_settings["port"]),

2501

ClientHandler,

2502

interface=(server_settings["interface"] or None),

2503

use_ipv6=use_ipv6,

2504

gnutls_priority=server_settings["priority"],

2505

use_dbus=use_dbus,

2506

socketfd=socketfd)

2507

if not foreground:

2508

pidfilename = "/run/mandos.pid"

2509

if not os.path.isdir("/run/."):

2510

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

2511

pidfile = None

1944

2512

try:

1945

2513

pidfile = open(pidfilename, "w")

1946

except IOError:

1947

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

2514

except IOError as e:

2515

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

2516

exc_info=e)

1948

2517

1949

try:

1950

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

1951

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

1952

except KeyError:

2518

for name in ("_mandos", "mandos", "nobody"):

1953

2519

try:

1954

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

1955

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

2520

uid = pwd.getpwnam(name).pw_uid

2521

gid = pwd.getpwnam(name).pw_gid

2522

break

1956

2523

except KeyError:

1957

try:

1958

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

1959

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

1960

except KeyError:

1961

uid = 65534

1962

gid = 65534

2524

continue

2525

else:

2526

uid = 65534

2527

gid = 65534

1963

2528

try:

1964

2529

os.setgid(gid)

1965

2530

os.setuid(uid)

1966

2531

except OSError as error:

1967

if error[0] != errno.EPERM:

1968

raise error

1969

1970

if not debug and not debuglevel:

1971

syslogger.setLevel(logging.WARNING)

1972

console.setLevel(logging.WARNING)

1973

if debuglevel:

1974

level = getattr(logging, debuglevel.upper())

1975

syslogger.setLevel(level)

1976

console.setLevel(level)

2532

if error.errno != errno.EPERM:

2533

raise

1977

2534

1978

2535

if debug:

1979

2536

# Enable all possible GnuTLS debugging

1986

2543

def debug_gnutls(level, string):

1987

2544

logger.debug("GnuTLS: %s", string[:-1])

1988

2545

1989

(gnutls.library.functions

1990

.gnutls_global_set_log_function(debug_gnutls))

2546

gnutls.library.functions.gnutls_global_set_log_function(

2547

debug_gnutls)

1991

2548

1992

2549

# Redirect stdin so all checkers get /dev/null

1993

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

2550

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

1994

2551

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

1995

2552

if null > 2:

1996

2553

os.close(null)

1997

else:

1998

# No console logging

1999

logger.removeHandler(console)

2000

2554

2001

2555

# Need to fork before connecting to D-Bus

2002

if not debug:

2556

if not foreground:

2003

2557

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

2004

2558

daemon()

2005

2559

2560

# multiprocessing will use threads, so before we use gobject we

2561

# need to inform gobject that threads will be used.

2562

gobject.threads_init()

2563

2006

2564

global main_loop

2007

2565

# From the Avahi example code

2008

DBusGMainLoop(set_as_default=True )

2566

DBusGMainLoop(set_as_default=True)

2009

2567

main_loop = gobject.MainLoop()

2010

2568

bus = dbus.SystemBus()

2011

2569

# End of Avahi example code

2012

2570

if use_dbus:

2013

2571

try:

2014

2572

bus_name = dbus.service.BusName("se.recompile.Mandos",

2015

bus, do_not_queue=True)

2016

old_bus_name = (dbus.service.BusName

2017

("se.bsnet.fukt.Mandos", bus,

2018

do_not_queue=True))

2573

bus,

2574

do_not_queue=True)

2575

old_bus_name = dbus.service.BusName(

2576

"se.bsnet.fukt.Mandos", bus,

2577

do_not_queue=True)

2019

2578

except dbus.exceptions.NameExistsException as e:

2020

logger.error(unicode(e) + ", disabling D-Bus")

2579

logger.error("Disabling D-Bus:", exc_info=e)

2021

2580

use_dbus = False

2022

2581

server_settings["use_dbus"] = False

2023

2582

tcp_server.use_dbus = False

2024

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2025

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

2026

servicetype = "_mandos._tcp",

2027

protocol = protocol, bus = bus)

2028

if server_settings["interface"]:

2029

service.interface = (if_nametoindex

2030

(str(server_settings["interface"])))

2583

if zeroconf:

2584

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2585

service = AvahiServiceToSyslog(

2586

name = server_settings["servicename"],

2587

servicetype = "_mandos._tcp",

2588

protocol = protocol,

2589

bus = bus)

2590

if server_settings["interface"]:

2591

service.interface = if_nametoindex(

2592

server_settings["interface"].encode("utf-8"))

2031

2593

2032

2594

global multiprocessing_manager

2033

2595

multiprocessing_manager = multiprocessing.Manager()

2034

2596

2035

2597

client_class = Client

2036

2598

if use_dbus:

2037

client_class = functools.partial(ClientDBusTransitional,

2038

bus = bus)

2039

def client_config_items(config, section):

2040

special_settings = {

2041

"approved_by_default":

2042

lambda: config.getboolean(section,

2043

"approved_by_default"),

2044

}

2045

for name, value in config.items(section):

2599

client_class = functools.partial(ClientDBus, bus = bus)

2600

2601

client_settings = Client.config_parser(client_config)

2602

old_client_settings = {}

2603

clients_data = {}

2604

2605

# This is used to redirect stdout and stderr for checker processes

2606

global wnull

2607

wnull = open(os.devnull, "w") # A writable /dev/null

2608

# Only used if server is running in foreground but not in debug

2609

# mode

2610

if debug or not foreground:

2611

wnull.close()

2612

2613

# Get client data and settings from last running state.

2614

if server_settings["restore"]:

2615

try:

2616

with open(stored_state_path, "rb") as stored_state:

2617

clients_data, old_client_settings = pickle.load(

2618

stored_state)

2619

os.remove(stored_state_path)

2620

except IOError as e:

2621

if e.errno == errno.ENOENT:

2622

logger.warning("Could not load persistent state:"

2623

" {}".format(os.strerror(e.errno)))

2624

else:

2625

logger.critical("Could not load persistent state:",

2626

exc_info=e)

2627

raise

2628

except EOFError as e:

2629

logger.warning("Could not load persistent state: "

2630

"EOFError:",

2631

exc_info=e)

2632

2633

with PGPEngine() as pgp:

2634

for client_name, client in clients_data.items():

2635

# Skip removed clients

2636

if client_name not in client_settings:

2637

continue

2638

2639

# Decide which value to use after restoring saved state.

2640

# We have three different values: Old config file,

2641

# new config file, and saved state.

2642

# New config value takes precedence if it differs from old

2643

# config value, otherwise use saved state.

2644

for name, value in client_settings[client_name].items():

2645

try:

2646

# For each value in new config, check if it

2647

# differs from the old config value (Except for

2648

# the "secret" attribute)

2649

if (name != "secret"

2650

and (value !=

2651

old_client_settings[client_name][name])):

2652

client[name] = value

2653

except KeyError:

2654

pass

2655

2656

# Clients who has passed its expire date can still be

2657

# enabled if its last checker was successful. Clients

2658

# whose checker succeeded before we stored its state is

2659

# assumed to have successfully run all checkers during

2660

# downtime.

2661

if client["enabled"]:

2662

if datetime.datetime.utcnow() >= client["expires"]:

2663

if not client["last_checked_ok"]:

2664

logger.warning(

2665

"disabling client {} - Client never "

2666

"performed a successful checker".format(

2667

client_name))

2668

client["enabled"] = False

2669

elif client["last_checker_status"] != 0:

2670

logger.warning(

2671

"disabling client {} - Client last"

2672

" checker failed with error code"

2673

" {}".format(

2674

client_name,

2675

client["last_checker_status"]))

2676

client["enabled"] = False

2677

else:

2678

client["expires"] = (

2679

datetime.datetime.utcnow()

2680

+ client["timeout"])

2681

logger.debug("Last checker succeeded,"

2682

" keeping {} enabled".format(

2683

client_name))

2046

2684

try:

2047

yield (name, special_settings[name]())

2048

except KeyError:

2049

yield (name, value)

2050

2051

tcp_server.clients.update(set(

2052

client_class(name = section,

2053

config= dict(client_config_items(

2054

client_config, section)))

2055

for section in client_config.sections()))

2685

client["secret"] = pgp.decrypt(

2686

client["encrypted_secret"],

2687

client_settings[client_name]["secret"])

2688

except PGPError:

2689

# If decryption fails, we use secret from new settings

2690

logger.debug("Failed to decrypt {} old secret".format(

2691

client_name))

2692

client["secret"] = (client_settings[client_name]

2693

["secret"])

2694

2695

# Add/remove clients based on new changes made to config

2696

for client_name in (set(old_client_settings)

2697

- set(client_settings)):

2698

del clients_data[client_name]

2699

for client_name in (set(client_settings)

2700

- set(old_client_settings)):

2701

clients_data[client_name] = client_settings[client_name]

2702

2703

# Create all client objects

2704

for client_name, client in clients_data.items():

2705

tcp_server.clients[client_name] = client_class(

2706

name = client_name,

2707

settings = client,

2708

server_settings = server_settings)

2709

2056

2710

if not tcp_server.clients:

2057

2711

logger.warning("No clients defined")

2058

2059

if not debug:

2060

try:

2061

with pidfile:

2062

pid = os.getpid()

2063

pidfile.write(str(pid) + "\n".encode("utf-8"))

2064

del pidfile

2065

except IOError:

2066

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

2067

pidfilename, pid)

2068

except NameError:

2069

# "pidfile" was never created

2070

pass

2712

2713

if not foreground:

2714

if pidfile is not None:

2715

try:

2716

with pidfile:

2717

pid = os.getpid()

2718

pidfile.write("{}\n".format(pid).encode("utf-8"))

2719

except IOError:

2720

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

2721

pidfilename, pid)

2722

del pidfile

2071

2723

del pidfilename

2072

2073

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

2074

2724

2075

2725

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

2076

2726

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

2077

2727

2078

2728

if use_dbus:

2079

class MandosDBusService(dbus.service.Object):

2729

2730

@alternate_dbus_interfaces(

2731

{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })

2732

class MandosDBusService(DBusObjectWithProperties):

2080

2733

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

2734

2081

2735

def __init__(self):

2082

2736

dbus.service.Object.__init__(self, bus, "/")

2737

2083

2738

_interface = "se.recompile.Mandos"

2084

2739

2740

@dbus_interface_annotations(_interface)

2741

def _foo(self):

2742

return {

2743

"org.freedesktop.DBus.Property.EmitsChangedSignal":

2744

"false" }

2745

2085

2746

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

2086

2747

def ClientAdded(self, objpath):

2087

2748

"D-Bus signal"

2100

2761

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

2101

2762

def GetAllClients(self):

2102

2763

"D-Bus method"

2103

return dbus.Array(c.dbus_object_path

2104

for c in tcp_server.clients)

2764

return dbus.Array(c.dbus_object_path for c in

2765

tcp_server.clients.itervalues())

2105

2766

2106

2767

@dbus.service.method(_interface,

2107

2768

out_signature="a{oa{sv}}")

2108

2769

def GetAllClientsWithProperties(self):

2109

2770

"D-Bus method"

2110

2771

return dbus.Dictionary(

2111

((c.dbus_object_path, c.GetAll(""))

2112

for c in tcp_server.clients),

2772

{ c.dbus_object_path: c.GetAll("")

2773

for c in tcp_server.clients.itervalues() },

2113

2774

signature="oa{sv}")

2114

2775

2115

2776

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

2116

2777

def RemoveClient(self, object_path):

2117

2778

"D-Bus method"

2118

for c in tcp_server.clients:

2779

for c in tcp_server.clients.itervalues():

2119

2780

if c.dbus_object_path == object_path:

2120

tcp_server.clients.remove(c)

2781

del tcp_server.clients[c.name]

2121

2782

c.remove_from_connection()

2122

2783

# Don't signal anything except ClientRemoved

2123

2784

c.disable(quiet=True)

2128

2789

2129

2790

del _interface

2130

2791

2131

class MandosDBusServiceTransitional(MandosDBusService):

2132

__metaclass__ = AlternateDBusNamesMetaclass

2133

mandos_dbus_service = MandosDBusServiceTransitional()

2792

mandos_dbus_service = MandosDBusService()

2134

2793

2135

2794

def cleanup():

2136

2795

"Cleanup function; run on exit"

2137

service.cleanup()

2796

if zeroconf:

2797

service.cleanup()

2138

2798

2139

2799

multiprocessing.active_children()

2800

wnull.close()

2801

if not (tcp_server.clients or client_settings):

2802

return

2803

2804

# Store client before exiting. Secrets are encrypted with key

2805

# based on what config file has. If config file is

2806

# removed/edited, old secret will thus be unrecovable.

2807

clients = {}

2808

with PGPEngine() as pgp:

2809

for client in tcp_server.clients.itervalues():

2810

key = client_settings[client.name]["secret"]

2811

client.encrypted_secret = pgp.encrypt(client.secret,

2812

key)

2813

client_dict = {}

2814

2815

# A list of attributes that can not be pickled

2816

# + secret.

2817

exclude = { "bus", "changedstate", "secret",

2818

"checker", "server_settings" }

2819

for name, typ in inspect.getmembers(dbus.service

2820

.Object):

2821

exclude.add(name)

2822

2823

client_dict["encrypted_secret"] = (client

2824

.encrypted_secret)

2825

for attr in client.client_structure:

2826

if attr not in exclude:

2827

client_dict[attr] = getattr(client, attr)

2828

2829

clients[client.name] = client_dict

2830

del client_settings[client.name]["secret"]

2831

2832

try:

2833

with tempfile.NamedTemporaryFile(

2834

mode='wb',

2835

suffix=".pickle",

2836

prefix='clients-',

2837

dir=os.path.dirname(stored_state_path),

2838

delete=False) as stored_state:

2839

pickle.dump((clients, client_settings), stored_state)

2840

tempname = stored_state.name

2841

os.rename(tempname, stored_state_path)

2842

except (IOError, OSError) as e:

2843

if not debug:

2844

try:

2845

os.remove(tempname)

2846

except NameError:

2847

pass

2848

if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):

2849

logger.warning("Could not save persistent state: {}"

2850

.format(os.strerror(e.errno)))

2851

else:

2852

logger.warning("Could not save persistent state:",

2853

exc_info=e)

2854

raise

2855

2856

# Delete all clients, and settings from config

2140

2857

while tcp_server.clients:

2141

client = tcp_server.clients.pop()

2858

name, client = tcp_server.clients.popitem()

2142

2859

if use_dbus:

2143

2860

client.remove_from_connection()

2144

client.disable_hook = None

2145

2861

# Don't signal anything except ClientRemoved

2146

2862

client.disable(quiet=True)

2147

2863

if use_dbus:

2148

2864

# Emit D-Bus signal

2149

mandos_dbus_service.ClientRemoved(client

2150

.dbus_object_path,

2151

client.name)

2865

mandos_dbus_service.ClientRemoved(

2866

client.dbus_object_path, client.name)

2867

client_settings.clear()

2152

2868

2153

2869

atexit.register(cleanup)

2154

2870

2155

for client in tcp_server.clients:

2871

for client in tcp_server.clients.itervalues():

2156

2872

if use_dbus:

2157

2873

# Emit D-Bus signal

2158

2874

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2159

client.enable()

2875

# Need to initiate checking of clients

2876

if client.enabled:

2877

client.init_checker()

2160

2878

2161

2879

tcp_server.enable()

2162

2880

tcp_server.server_activate()

2163

2881

2164

2882

# Find out what port we got

2165

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

2883

if zeroconf:

2884

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

2166

2885

if use_ipv6:

2167

2886

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

2168

" flowinfo %d, scope_id %d"

2169

% tcp_server.socket.getsockname())

2887

" flowinfo %d, scope_id %d",

2888

*tcp_server.socket.getsockname())

2170

2889

else: # IPv4

2171

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

2172

% tcp_server.socket.getsockname())

2890

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

2891

*tcp_server.socket.getsockname())

2173

2892

2174

2893

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

2175

2894

2176

2895

try:

2177

# From the Avahi example code

2178

try:

2179

service.activate()

2180

except dbus.exceptions.DBusException as error:

2181

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

2182

cleanup()

2183

sys.exit(1)

2184

# End of Avahi example code

2896

if zeroconf:

2897

# From the Avahi example code

2898

try:

2899

service.activate()

2900

except dbus.exceptions.DBusException as error:

2901

logger.critical("D-Bus Exception", exc_info=error)

2902

cleanup()

2903

sys.exit(1)

2904

# End of Avahi example code

2185

2905

2186

2906

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

2187

2907

lambda *args, **kwargs:

2191

2911

logger.debug("Starting main loop")

2192

2912

main_loop.run()

2193

2913

except AvahiError as error:

2194

logger.critical("AvahiError: %s", error)

2914

logger.critical("Avahi Error", exc_info=error)

2195

2915

cleanup()

2196

2916

sys.exit(1)

2197

2917

except KeyboardInterrupt: