/mandos/trunk : revision 518.2.3

1

#!/usr/bin/python2.7

1

#!/usr/bin/python

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

from future_builtins import *

38

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

67

65

import types

68

66

import binascii

69

67

import tempfile

70

import itertools

71

import collections

72

68

73

69

import dbus

74

70

import dbus.service

79

75

import ctypes.util

80

76

import xml.dom.minidom

81

77

import inspect

78

import GnuPGInterface

82

79

83

80

try:

84

81

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

88

85

except ImportError:

89

86

SO_BINDTODEVICE = None

90

87

91

version = "1.6.7"

88

89

version = "1.4.1"

92

90

stored_state_file = "clients.pickle"

93

91

94

92

logger = logging.getLogger()

95

syslogger = None

93

syslogger = (logging.handlers.SysLogHandler

94

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

95

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

96

97

try:

98

if_nametoindex = (ctypes.cdll.LoadLibrary

111

return interface_index

112

113

114

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

114

def initlogger(level=logging.WARNING):

115

"""init logger and add loglevel"""

116

117

global syslogger

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

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

122

117

syslogger.setFormatter(logging.Formatter

123

118

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

124

119

' %(message)s'))

125

120

logger.addHandler(syslogger)

126

121

127

if debug:

128

console = logging.StreamHandler()

129

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

130

' [%(process)d]:'

131

' %(levelname)s:'

132

' %(message)s'))

133

logger.addHandler(console)

122

console = logging.StreamHandler()

123

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

124

' [%(process)d]:'

125

' %(levelname)s:'

126

' %(message)s'))

127

logger.addHandler(console)

134

128

logger.setLevel(level)

135

129

136

130

137

class PGPError(Exception):

138

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

131

class CryptoError(Exception):

139

132

pass

140

133

141

134

142

class PGPEngine(object):

135

class Crypto(object):

143

136

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

144

137

def __init__(self):

138

self.gnupg = GnuPGInterface.GnuPG()

145

139

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

146

self.gnupgargs = ['--batch',

147

'--home', self.tempdir,

148

'--force-mdc',

149

'--quiet',

150

'--no-use-agent']

140

self.gnupg = GnuPGInterface.GnuPG()

141

self.gnupg.options.meta_interactive = False

142

self.gnupg.options.homedir = self.tempdir

143

self.gnupg.options.extra_args.extend(['--force-mdc',

144

'--quiet'])

151

145

152

146

def __enter__(self):

153

147

return self

154

148

155

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

149

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

156

150

self._cleanup()

157

151

return False

158

152

175

169

def password_encode(self, password):

176

170

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

177

171

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

178

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

179

if len(encoded) > 2048:

180

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

181

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

182

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

183

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

184

return encoded

172

return b"mandos" + binascii.hexlify(password)

185

173

186

174

def encrypt(self, data, password):

187

passphrase = self.password_encode(password)

188

with tempfile.NamedTemporaryFile(dir=self.tempdir

189

) as passfile:

190

passfile.write(passphrase)

191

passfile.flush()

192

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

193

'--passphrase-file',

194

passfile.name]

195

+ self.gnupgargs,

196

stdin = subprocess.PIPE,

197

stdout = subprocess.PIPE,

198

stderr = subprocess.PIPE)

199

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

200

if proc.returncode != 0:

201

raise PGPError(err)

175

self.gnupg.passphrase = self.password_encode(password)

176

with open(os.devnull) as devnull:

177

try:

178

proc = self.gnupg.run(['--symmetric'],

179

create_fhs=['stdin', 'stdout'],

180

attach_fhs={'stderr': devnull})

181

with contextlib.closing(proc.handles['stdin']) as f:

182

f.write(data)

183

with contextlib.closing(proc.handles['stdout']) as f:

184

ciphertext = f.read()

185

proc.wait()

186

except IOError as e:

187

raise CryptoError(e)

188

self.gnupg.passphrase = None

202

189

return ciphertext

203

190

204

191

def decrypt(self, data, password):

205

passphrase = self.password_encode(password)

206

with tempfile.NamedTemporaryFile(dir = self.tempdir

207

) as passfile:

208

passfile.write(passphrase)

209

passfile.flush()

210

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

211

'--passphrase-file',

212

passfile.name]

213

+ self.gnupgargs,

214

stdin = subprocess.PIPE,

215

stdout = subprocess.PIPE,

216

stderr = subprocess.PIPE)

217

decrypted_plaintext, err = proc.communicate(input

218

= data)

219

if proc.returncode != 0:

220

raise PGPError(err)

192

self.gnupg.passphrase = self.password_encode(password)

193

with open(os.devnull) as devnull:

194

try:

195

proc = self.gnupg.run(['--decrypt'],

196

create_fhs=['stdin', 'stdout'],

197

attach_fhs={'stderr': devnull})

198

with contextlib.closing(proc.handles['stdin'] ) as f:

199

f.write(data)

200

with contextlib.closing(proc.handles['stdout']) as f:

201

decrypted_plaintext = f.read()

202

proc.wait()

203

except IOError as e:

204

raise CryptoError(e)

205

self.gnupg.passphrase = None

221

206

return decrypted_plaintext

222

207

223

208

209

224

210

class AvahiError(Exception):

225

211

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

226

212

self.value = value

243

229

Used to optionally bind to the specified interface.

244

230

name: string; Example: 'Mandos'

245

231

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

246

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

232

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

247

233

port: integer; what port to announce

248

234

TXT: list of strings; TXT record for the service

249

235

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

255

241

server: D-Bus Server

256

242

bus: dbus.SystemBus()

257

243

"""

258

259

244

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

260

245

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

261

246

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

274

259

self.server = None

275

260

self.bus = bus

276

261

self.entry_group_state_changed_match = None

277

278

262

def rename(self):

279

263

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

280

264

if self.rename_count >= self.max_renames:

290

274

try:

291

275

self.add()

292

276

except dbus.exceptions.DBusException as error:

293

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

277

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

294

278

self.cleanup()

295

279

os._exit(1)

296

280

self.rename_count += 1

297

298

281

def remove(self):

299

282

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

300

283

if self.entry_group_state_changed_match is not None:

302

285

self.entry_group_state_changed_match = None

303

286

if self.group is not None:

304

287

self.group.Reset()

305

306

288

def add(self):

307

289

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

308

290

self.remove()

325

307

dbus.UInt16(self.port),

326

308

avahi.string_array_to_txt_array(self.TXT))

327

309

self.group.Commit()

328

329

310

def entry_group_state_changed(self, state, error):

330

311

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

331

312

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

338

319

elif state == avahi.ENTRY_GROUP_FAILURE:

339

320

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

340

321

unicode(error))

341

raise AvahiGroupError("State changed: {!s}"

342

.format(error))

343

322

raise AvahiGroupError("State changed: %s"

323

% unicode(error))

344

324

def cleanup(self):

345

325

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

346

326

if self.group is not None:

351

331

pass

352

332

self.group = None

353

333

self.remove()

354

355

334

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

356

335

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

357

336

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

376

355

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

377

356

else:

378

357

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

379

380

358

def activate(self):

381

359

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

382

360

if self.server is None:

389

367

self.server_state_changed)

390

368

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

391

369

392

393

370

class AvahiServiceToSyslog(AvahiService):

394

371

def rename(self):

395

372

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

396

373

ret = AvahiService.rename(self)

397

374

syslogger.setFormatter(logging.Formatter

398

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

399

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

400

.format(self.name)))

375

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

376

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

377

% self.name))

401

378

return ret

402

379

403

380

def _timedelta_to_milliseconds(td):

381

"Convert a datetime.timedelta() to milliseconds"

382

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

383

+ (td.seconds * 1000)

384

+ (td.microseconds // 1000))

385

404

386

class Client(object):

405

387

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

406

388

407

389

Attributes:

408

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

390

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

409

391

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

410

392

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

411

393

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

429

411

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

430

412

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

431

413

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

414

432

415

last_checker_status: integer between 0 and 255 reflecting exit

433

416

status of last checker. -1 reflects crashed

434

checker, -2 means no checker completed yet.

417

checker, or None.

435

418

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

436

419

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

437

420

D-Bus identifiers

438

421

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

439

422

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

440

423

until this client is disabled

441

extended_timeout: extra long timeout when secret has been sent

424

extended_timeout: extra long timeout when password has been sent

442

425

runtime_expansions: Allowed attributes for runtime expansion.

443

426

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

444

427

disabled, or None

445

server_settings: The server_settings dict from main()

446

428

"""

447

429

448

430

runtime_expansions = ("approval_delay", "approval_duration",

449

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

450

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

451

"last_approval_request", "last_checked_ok",

431

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

432

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

452

433

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

453

client_defaults = { "timeout": "PT5M",

454

"extended_timeout": "PT15M",

455

"interval": "PT2M",

456

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

457

"host": "",

458

"approval_delay": "PT0S",

459

"approval_duration": "PT1S",

460

"approved_by_default": "True",

461

"enabled": "True",

462

}

463

464

@staticmethod

465

def config_parser(config):

466

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

467

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

468

with exceptions for any special settings as defined above.

469

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

470

value given the same arguments.

471

"""

472

settings = {}

473

for client_name in config.sections():

474

section = dict(config.items(client_name))

475

client = settings[client_name] = {}

476

477

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

478

# Reformat values from string types to Python types

479

client["approved_by_default"] = config.getboolean(

480

client_name, "approved_by_default")

481

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

482

"enabled")

483

484

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

485

.replace(" ", ""))

486

if "secret" in section:

487

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

488

elif "secfile" in section:

489

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

490

(section["secfile"])),

491

"rb") as secfile:

492

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

493

else:

494

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

495

.format(section))

496

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

497

client["extended_timeout"] = string_to_delta(

498

section["extended_timeout"])

499

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

500

client["approval_delay"] = string_to_delta(

501

section["approval_delay"])

502

client["approval_duration"] = string_to_delta(

503

section["approval_duration"])

504

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

505

client["last_approval_request"] = None

506

client["last_checked_ok"] = None

507

client["last_checker_status"] = -2

508

509

return settings

510

511

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

434

435

def timeout_milliseconds(self):

436

"Return the 'timeout' attribute in milliseconds"

437

return _timedelta_to_milliseconds(self.timeout)

438

439

def extended_timeout_milliseconds(self):

440

"Return the 'extended_timeout' attribute in milliseconds"

441

return _timedelta_to_milliseconds(self.extended_timeout)

442

443

def interval_milliseconds(self):

444

"Return the 'interval' attribute in milliseconds"

445

return _timedelta_to_milliseconds(self.interval)

446

447

def approval_delay_milliseconds(self):

448

return _timedelta_to_milliseconds(self.approval_delay)

449

450

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

451

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

452

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

453

attribute."""

512

454

self.name = name

513

if server_settings is None:

514

server_settings = {}

515

self.server_settings = server_settings

516

# adding all client settings

517

for setting, value in settings.items():

518

setattr(self, setting, value)

519

520

if self.enabled:

521

if not hasattr(self, "last_enabled"):

522

self.last_enabled = datetime.datetime.utcnow()

523

if not hasattr(self, "expires"):

524

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

525

+ self.timeout)

526

else:

527

self.last_enabled = None

528

self.expires = None

529

455

if config is None:

456

config = {}

530

457

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

531

458

# Uppercase and remove spaces from fingerprint for later

532

459

# comparison purposes with return value from the fingerprint()

533

460

# function

461

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

462

.replace(" ", ""))

534

463

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

535

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

536

datetime.datetime.utcnow())

537

538

# attributes specific for this server instance

464

if "secret" in config:

465

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

466

elif "secfile" in config:

467

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

468

(config["secfile"])),

469

"rb") as secfile:

470

self.secret = secfile.read()

471

else:

472

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

473

% self.name)

474

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

475

self.created = datetime.datetime.utcnow()

476

self.enabled = config.get("enabled", True)

477

self.last_approval_request = None

478

if self.enabled:

479

self.last_enabled = datetime.datetime.utcnow()

480

else:

481

self.last_enabled = None

482

self.last_checked_ok = None

483

self.last_checker_status = None

484

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

485

self.extended_timeout = string_to_delta(config

486

["extended_timeout"])

487

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

539

488

self.checker = None

540

489

self.checker_initiator_tag = None

541

490

self.disable_initiator_tag = None

491

if self.enabled:

492

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

493

else:

494

self.expires = None

542

495

self.checker_callback_tag = None

496

self.checker_command = config["checker"]

543

497

self.current_checker_command = None

544

self.approved = None

498

self._approved = None

499

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

500

True)

545

501

self.approvals_pending = 0

502

self.approval_delay = string_to_delta(

503

config["approval_delay"])

504

self.approval_duration = string_to_delta(

505

config["approval_duration"])

546

506

self.changedstate = (multiprocessing_manager

547

507

.Condition(multiprocessing_manager

548

508

.Lock()))

568

528

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

569

529

# Already enabled

570

530

return

531

self.send_changedstate()

571

532

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

572

533

self.enabled = True

573

534

self.last_enabled = datetime.datetime.utcnow()

574

535

self.init_checker()

575

self.send_changedstate()

576

536

577

537

def disable(self, quiet=True):

578

538

"""Disable this client."""

579

539

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

580

540

return False

581

541

if not quiet:

542

self.send_changedstate()

543

if not quiet:

582

544

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

583

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

545

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

584

546

gobject.source_remove(self.disable_initiator_tag)

585

547

self.disable_initiator_tag = None

586

548

self.expires = None

587

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

549

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

588

550

gobject.source_remove(self.checker_initiator_tag)

589

551

self.checker_initiator_tag = None

590

552

self.stop_checker()

591

553

self.enabled = False

592

if not quiet:

593

self.send_changedstate()

594

554

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

595

555

return False

596

556

600

560

def init_checker(self):

601

561

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

602

562

# and every interval from then on.

603

if self.checker_initiator_tag is not None:

604

gobject.source_remove(self.checker_initiator_tag)

605

563

self.checker_initiator_tag = (gobject.timeout_add

606

(int(self.interval

607

.total_seconds() * 1000),

564

(self.interval_milliseconds(),

608

565

self.start_checker))

609

566

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

610

if self.disable_initiator_tag is not None:

611

gobject.source_remove(self.disable_initiator_tag)

612

567

self.disable_initiator_tag = (gobject.timeout_add

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

568

(self.timeout_milliseconds(),

569

self.disable))

616

570

# Also start a new checker *right now*.

617

571

self.start_checker()

618

572

621

575

self.checker_callback_tag = None

622

576

self.checker = None

623

577

if os.WIFEXITED(condition):

624

self.last_checker_status = os.WEXITSTATUS(condition)

578

self.last_checker_status = os.WEXITSTATUS(condition)

625

579

if self.last_checker_status == 0:

626

580

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

627

581

vars(self))

634

588

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

635

589

vars(self))

636

590

637

def checked_ok(self):

638

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

639

self.last_checked_ok = datetime.datetime.utcnow()

640

self.last_checker_status = 0

641

self.bump_timeout()

642

643

def bump_timeout(self, timeout=None):

644

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

591

def checked_ok(self, timeout=None):

592

"""Bump up the timeout for this client.

593

594

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

595

alive and well.

596

"""

645

597

if timeout is None:

646

598

timeout = self.timeout

599

self.last_checked_ok = datetime.datetime.utcnow()

647

600

if self.disable_initiator_tag is not None:

648

601

gobject.source_remove(self.disable_initiator_tag)

649

self.disable_initiator_tag = None

650

602

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

651

603

self.disable_initiator_tag = (gobject.timeout_add

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

604

(_timedelta_to_milliseconds

605

(timeout), self.disable))

654

606

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

655

607

656

608

def need_approval(self):

662

614

If a checker already exists, leave it running and do

663

615

nothing."""

664

616

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

665

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

666

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

667

# would inevitably timeout, since no checker would get a

668

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

617

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

618

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

619

# client would inevitably timeout, since no checker would get

620

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

669

621

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

670

622

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

671

623

# should be.

673

625

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

674

626

try:

675

627

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

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

628

except (AttributeError, OSError) as error:

629

if (isinstance(error, OSError)

630

and error.errno != errno.ECHILD):

631

raise error

681

632

else:

682

633

if pid:

683

634

logger.warning("Checker was a zombie")

686

637

self.current_checker_command)

687

638

# Start a new checker if needed

688

639

if self.checker is None:

689

# Escape attributes for the shell

690

escaped_attrs = { attr:

691

re.escape(unicode(getattr(self,

692

attr)))

693

for attr in self.runtime_expansions }

694

640

try:

695

command = self.checker_command % escaped_attrs

696

except TypeError as error:

697

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

698

self.checker_command, exc_info=error)

699

return True # Try again later

641

# In case checker_command has exactly one % operator

642

command = self.checker_command % self.host

643

except TypeError:

644

# Escape attributes for the shell

645

escaped_attrs = dict(

646

(attr,

647

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

648

errors=

649

'replace')))

650

for attr in

651

self.runtime_expansions)

652

653

try:

654

command = self.checker_command % escaped_attrs

655

except TypeError as error:

656

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

657

' %s', self.checker_command, error)

658

return True # Try again later

700

659

self.current_checker_command = command

701

660

try:

702

661

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

705

664

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

706

665

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

707

666

# always replaced by /dev/null.)

708

# The exception is when not debugging but nevertheless

709

# running in the foreground; use the previously

710

# created wnull.

711

popen_args = {}

712

if (not self.server_settings["debug"]

713

and self.server_settings["foreground"]):

714

popen_args.update({"stdout": wnull,

715

"stderr": wnull })

716

667

self.checker = subprocess.Popen(command,

717

668

close_fds=True,

718

shell=True, cwd="/",

719

**popen_args)

720

except OSError as error:

721

logger.error("Failed to start subprocess",

722

exc_info=error)

723

return True

724

self.checker_callback_tag = (gobject.child_watch_add

725

(self.checker.pid,

726

self.checker_callback,

727

data=command))

728

# The checker may have completed before the gobject

729

# watch was added. Check for this.

730

try:

669

shell=True, cwd="/")

670

self.checker_callback_tag = (gobject.child_watch_add

671

(self.checker.pid,

672

self.checker_callback,

673

data=command))

674

# The checker may have completed before the gobject

675

# watch was added. Check for this.

731

676

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

677

if pid:

678

gobject.source_remove(self.checker_callback_tag)

679

self.checker_callback(pid, status, command)

732

680

except OSError as error:

733

if error.errno == errno.ECHILD:

734

# This should never happen

735

logger.error("Child process vanished",

736

exc_info=error)

737

return True

738

raise

739

if pid:

740

gobject.source_remove(self.checker_callback_tag)

741

self.checker_callback(pid, status, command)

681

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

682

error)

742

683

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

743

684

return True

744

685

751

692

return

752

693

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

753

694

try:

754

self.checker.terminate()

695

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

755

696

#time.sleep(0.5)

756

697

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

757

# self.checker.kill()

698

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

758

699

except OSError as error:

759

700

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

760

701

raise

777

718

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

778

719

if byte_arrays and signature != "ay":

779

720

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

780

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

721

" signature %r" % signature)

781

722

def decorator(func):

782

723

func._dbus_is_property = True

783

724

func._dbus_interface = dbus_interface

791

732

return decorator

792

733

793

734

794

def dbus_interface_annotations(dbus_interface):

795

"""Decorator for marking functions returning interface annotations

796

797

Usage:

798

799

@dbus_interface_annotations("org.example.Interface")

800

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

801

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

802

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

803

"false"}

804

"""

805

def decorator(func):

806

func._dbus_is_interface = True

807

func._dbus_interface = dbus_interface

808

func._dbus_name = dbus_interface

809

return func

810

return decorator

811

812

813

def dbus_annotations(annotations):

814

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

815

Usage:

816

817

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

818

access="r")

819

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

820

"org.freedesktop.DBus.Property."

821

"EmitsChangedSignal": "false"})

822

def Property_dbus_property(self):

823

return dbus.Boolean(False)

824

"""

825

def decorator(func):

826

func._dbus_annotations = annotations

827

return func

828

return decorator

829

830

831

735

class DBusPropertyException(dbus.exceptions.DBusException):

832

736

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

833

737

"""

856

760

"""

857

761

858

762

@staticmethod

859

def _is_dbus_thing(thing):

860

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

861

862

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

863

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

864

"""

865

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

866

False)

763

def _is_dbus_property(obj):

764

return getattr(obj, "_dbus_is_property", False)

867

765

868

def _get_all_dbus_things(self, thing):

766

def _get_all_dbus_properties(self):

869

767

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

870

768

"""

871

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

872

name),

873

athing.__get__(self))

769

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

874

770

for cls in self.__class__.__mro__

875

for name, athing in

876

inspect.getmembers(cls,

877

self._is_dbus_thing(thing)))

771

for name, prop in

772

inspect.getmembers(cls, self._is_dbus_property))

878

773

879

774

def _get_dbus_property(self, interface_name, property_name):

880

775

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

882

777

"""

883

778

for cls in self.__class__.__mro__:

884

779

for name, value in (inspect.getmembers

885

(cls,

886

self._is_dbus_thing("property"))):

780

(cls, self._is_dbus_property)):

887

781

if (value._dbus_name == property_name

888

782

and value._dbus_interface == interface_name):

889

783

return value.__get__(self)

917

811

# The byte_arrays option is not supported yet on

918

812

# signatures other than "ay".

919

813

if prop._dbus_signature != "ay":

920

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

921

"'ay' signature {!r}"

922

.format(prop._dbus_signature))

923

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

924

for byte in value))

814

raise ValueError

815

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

816

for byte in value))

925

817

prop(value)

926

818

927

819

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

933

825

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

934

826

"""

935

827

properties = {}

936

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

828

for name, prop in self._get_all_dbus_properties():

937

829

if (interface_name

938

830

and interface_name != prop._dbus_interface):

939

831

# Interface non-empty but did not match

954

846

path_keyword='object_path',

955

847

connection_keyword='connection')

956

848

def Introspect(self, object_path, connection):

957

"""Overloading of standard D-Bus method.

958

959

Inserts property tags and interface annotation tags.

849

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

960

850

"""

961

851

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

962

852

connection)

969

859

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

970

860

return e

971

861

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

972

# Add property tags

973

862

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

974

863

for name, prop

975

in self._get_all_dbus_things("property")

864

in self._get_all_dbus_properties()

976

865

if prop._dbus_interface

977

866

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

978

867

if_tag.appendChild(tag)

979

# Add annotation tags

980

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

981

for tag in if_tag.getElementsByTagName(typ):

982

annots = dict()

983

for name, prop in (self.

984

_get_all_dbus_things(typ)):

985

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

986

and prop._dbus_interface

987

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

988

annots.update(getattr

989

(prop,

990

"_dbus_annotations",

991

{}))

992

for name, value in annots.items():

993

ann_tag = document.createElement(

994

"annotation")

995

ann_tag.setAttribute("name", name)

996

ann_tag.setAttribute("value", value)

997

tag.appendChild(ann_tag)

998

# Add interface annotation tags

999

for annotation, value in dict(

1000

itertools.chain.from_iterable(

1001

annotations().items()

1002

for name, annotations in

1003

self._get_all_dbus_things("interface")

1004

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

1005

)).items():

1006

ann_tag = document.createElement("annotation")

1007

ann_tag.setAttribute("name", annotation)

1008

ann_tag.setAttribute("value", value)

1009

if_tag.appendChild(ann_tag)

1010

868

# Add the names to the return values for the

1011

869

# "org.freedesktop.DBus.Properties" methods

1012

870

if (if_tag.getAttribute("name")

1027

885

except (AttributeError, xml.dom.DOMException,

1028

886

xml.parsers.expat.ExpatError) as error:

1029

887

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

1030

exc_info=error)

888

error)

1031

889

return xmlstring

1032

890

1033

891

1034

def datetime_to_dbus(dt, variant_level=0):

892

def datetime_to_dbus (dt, variant_level=0):

1035

893

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

1036

894

if dt is None:

1037

895

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

1039

897

variant_level=variant_level)

1040

898

1041

899

1042

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1043

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

1044

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

1045

interface names according to the "alt_interface_names" mapping.

1046

Usage:

1047

1048

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

1049

"net.example.AlternateInterface"})

1050

class SampleDBusObject(dbus.service.Object):

1051

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

1052

def SampleDBusMethod():

1053

pass

1054

1055

The above "SampleDBusMethod" on "SampleDBusObject" will be

1056

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

1057

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

1058

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

1059

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

1060

1061

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

1062

(from DBusObjectWithProperties) and interfaces (from the

1063

dbus_interface_annotations decorator).

900

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

901

.__metaclass__):

902

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

903

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

1064

904

"""

1065

def wrapper(cls):

1066

for orig_interface_name, alt_interface_name in (

1067

alt_interface_names.items()):

1068

attr = {}

1069

interface_names = set()

1070

# Go though all attributes of the class

1071

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

905

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

906

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

907

# methods, signals, or properties in them

908

for base in (b for b in bases

909

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

910

# Go though all attributes of the base class

911

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

1072

912

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

1073

913

# with the wrong interface name

1074

914

if (not hasattr(attribute, "_dbus_interface")

1075

915

or not attribute._dbus_interface

1076

.startswith(orig_interface_name)):

916

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

1077

917

continue

1078

918

# Create an alternate D-Bus interface name based on

1079

919

# the current name

1080

920

alt_interface = (attribute._dbus_interface

1081

.replace(orig_interface_name,

1082

alt_interface_name))

1083

interface_names.add(alt_interface)

921

.replace("se.recompile.Mandos",

922

"se.bsnet.fukt.Mandos"))

1084

923

# Is this a D-Bus signal?

1085

924

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

1086

# Extract the original non-method undecorated

1087

# function by black magic

925

# Extract the original non-method function by

926

# black magic

1088

927

nonmethod_func = (dict(

1089

928

zip(attribute.func_code.co_freevars,

1090

929

attribute.__closure__))["func"]

1101

940

nonmethod_func.func_name,

1102

941

nonmethod_func.func_defaults,

1103

942

nonmethod_func.func_closure)))

1104

# Copy annotations, if any

1105

try:

1106

new_function._dbus_annotations = (

1107

dict(attribute._dbus_annotations))

1108

except AttributeError:

1109

pass

1110

943

# Define a creator of a function to call both the

1111

# original and alternate functions, so both the

1112

# original and alternate signals gets sent when

1113

# the function is called

944

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

945

# signals gets sent when the function is called

1114

946

def fixscope(func1, func2):

1115

947

"""This function is a scope container to pass

1116

948

func1 and func2 to the "call_both" function

1123

955

return call_both

1124

956

# Create the "call_both" function and add it to

1125

957

# the class

1126

attr[attrname] = fixscope(attribute, new_function)

958

attr[attrname] = fixscope(attribute,

959

new_function)

1127

960

# Is this a D-Bus method?

1128

961

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

1129

962

# Create a new, but exactly alike, function

1140

973

attribute.func_name,

1141

974

attribute.func_defaults,

1142

975

attribute.func_closure)))

1143

# Copy annotations, if any

1144

try:

1145

attr[attrname]._dbus_annotations = (

1146

dict(attribute._dbus_annotations))

1147

except AttributeError:

1148

pass

1149

976

# Is this a D-Bus property?

1150

977

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

1151

978

# Create a new, but exactly alike, function

1165

992

attribute.func_name,

1166

993

attribute.func_defaults,

1167

994

attribute.func_closure)))

1168

# Copy annotations, if any

1169

try:

1170

attr[attrname]._dbus_annotations = (

1171

dict(attribute._dbus_annotations))

1172

except AttributeError:

1173

pass

1174

# Is this a D-Bus interface?

1175

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

1176

# Create a new, but exactly alike, function

1177

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

1178

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

1179

# to the class.

1180

attr[attrname] = (dbus_interface_annotations

1181

(alt_interface)

1182

(types.FunctionType

1183

(attribute.func_code,

1184

attribute.func_globals,

1185

attribute.func_name,

1186

attribute.func_defaults,

1187

attribute.func_closure)))

1188

if deprecate:

1189

# Deprecate all alternate interfaces

1190

iname="_AlternateDBusNames_interface_annotation{}"

1191

for interface_name in interface_names:

1192

@dbus_interface_annotations(interface_name)

1193

def func(self):

1194

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

1195

"true" }

1196

# Find an unused name

1197

for aname in (iname.format(i)

1198

for i in itertools.count()):

1199

if aname not in attr:

1200

attr[aname] = func

1201

break

1202

if interface_names:

1203

# Replace the class with a new subclass of it with

1204

# methods, signals, etc. as created above.

1205

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

1206

(cls,), attr)

1207

return cls

1208

return wrapper

1209

1210

1211

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

1212

"se.bsnet.fukt.Mandos"})

995

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

996

997

1213

998

class ClientDBus(Client, DBusObjectWithProperties):

1214

999

"""A Client class using D-Bus

1215

1000

1226

1011

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

1227

1012

self.bus = bus

1228

1013

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

1014

1015

self._approvals_pending = 0

1229

1016

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

1230

1017

# the D-Bus

1231

1018

client_object_name = unicode(self.name).translate(

1235

1022

("/clients/" + client_object_name))

1236

1023

DBusObjectWithProperties.__init__(self, self.bus,

1237

1024

self.dbus_object_path)

1238

1025

1239

1026

def notifychangeproperty(transform_func,

1240

1027

dbus_name, type_func=lambda x: x,

1241

1028

variant_level=1):

1249

1036

to the D-Bus. Default: no transform

1250

1037

variant_level: D-Bus variant level. Default: 1

1251

1038

"""

1252

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

1039

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

1253

1040

def setter(self, value):

1254

1041

if hasattr(self, "dbus_object_path"):

1255

1042

if (not hasattr(self, attrname) or

1264

1051

1265

1052

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

1266

1053

1054

1267

1055

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1268

1056

approvals_pending = notifychangeproperty(dbus.Boolean,

1269

1057

"ApprovalPending",

1276

1064

checker is not None)

1277

1065

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1278

1066

"LastCheckedOK")

1279

last_checker_status = notifychangeproperty(dbus.Int16,

1280

"LastCheckerStatus")

1281

1067

last_approval_request = notifychangeproperty(

1282

1068

datetime_to_dbus, "LastApprovalRequest")

1283

1069

approved_by_default = notifychangeproperty(dbus.Boolean,

1284

1070

"ApprovedByDefault")

1285

approval_delay = notifychangeproperty(dbus.UInt64,

1071

approval_delay = notifychangeproperty(dbus.UInt16,

1286

1072

"ApprovalDelay",

1287

1073

type_func =

1288

lambda td: td.total_seconds()

1289

* 1000)

1074

_timedelta_to_milliseconds)

1290

1075

approval_duration = notifychangeproperty(

1291

dbus.UInt64, "ApprovalDuration",

1292

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

1076

dbus.UInt16, "ApprovalDuration",

1077

type_func = _timedelta_to_milliseconds)

1293

1078

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

1294

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

1295

type_func = lambda td:

1296

td.total_seconds() * 1000)

1079

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

1080

type_func =

1081

_timedelta_to_milliseconds)

1297

1082

extended_timeout = notifychangeproperty(

1298

dbus.UInt64, "ExtendedTimeout",

1299

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

1300

interval = notifychangeproperty(dbus.UInt64,

1083

dbus.UInt16, "ExtendedTimeout",

1084

type_func = _timedelta_to_milliseconds)

1085

interval = notifychangeproperty(dbus.UInt16,

1301

1086

"Interval",

1302

1087

type_func =

1303

lambda td: td.total_seconds()

1304

* 1000)

1088

_timedelta_to_milliseconds)

1305

1089

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

1306

1090

1307

1091

del notifychangeproperty

1335

1119

*args, **kwargs)

1336

1120

1337

1121

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

1338

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

1122

old_checker = self.checker

1123

if self.checker is not None:

1124

old_checker_pid = self.checker.pid

1125

else:

1126

old_checker_pid = None

1339

1127

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

1340

1128

# Only if new checker process was started

1341

1129

if (self.checker is not None

1345

1133

return r

1346

1134

1347

1135

def _reset_approved(self):

1348

self.approved = None

1136

self._approved = None

1349

1137

return False

1350

1138

1351

1139

def approve(self, value=True):

1352

self.approved = value

1353

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

1354

* 1000), self._reset_approved)

1355

1140

self.send_changedstate()

1141

self._approved = value

1142

gobject.timeout_add(_timedelta_to_milliseconds

1143

(self.approval_duration),

1144

self._reset_approved)

1145

1356

1146

1357

1147

## D-Bus methods, signals & properties

1358

1148

_interface = "se.recompile.Mandos.Client"

1359

1149

1360

## Interfaces

1361

1362

@dbus_interface_annotations(_interface)

1363

def _foo(self):

1364

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

1365

"false"}

1366

1367

1150

## Signals

1368

1151

1369

1152

# CheckerCompleted - signal

1405

1188

"D-Bus signal"

1406

1189

return self.need_approval()

1407

1190

1191

# NeRwequest - signal

1192

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

1193

def NewRequest(self, ip):

1194

"""D-Bus signal

1195

Is sent after a client request a password.

1196

"""

1197

pass

1198

1408

1199

## Methods

1409

1200

1410

1201

# Approve - method

1460

1251

access="readwrite")

1461

1252

def ApprovalDelay_dbus_property(self, value=None):

1462

1253

if value is None: # get

1463

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

1464

* 1000)

1254

return dbus.UInt64(self.approval_delay_milliseconds())

1465

1255

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

1466

1256

1467

1257

# ApprovalDuration - property

1469

1259

access="readwrite")

1470

1260

def ApprovalDuration_dbus_property(self, value=None):

1471

1261

if value is None: # get

1472

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

1473

* 1000)

1262

return dbus.UInt64(_timedelta_to_milliseconds(

1263

self.approval_duration))

1474

1264

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

1475

1265

1476

1266

# Name - property

1489

1279

def Host_dbus_property(self, value=None):

1490

1280

if value is None: # get

1491

1281

return dbus.String(self.host)

1492

self.host = unicode(value)

1282

self.host = value

1493

1283

1494

1284

# Created - property

1495

1285

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

1521

1311

return

1522

1312

return datetime_to_dbus(self.last_checked_ok)

1523

1313

1524

# LastCheckerStatus - property

1525

@dbus_service_property(_interface, signature="n",

1526

access="read")

1527

def LastCheckerStatus_dbus_property(self):

1528

return dbus.Int16(self.last_checker_status)

1529

1530

1314

# Expires - property

1531

1315

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

1532

1316

def Expires_dbus_property(self):

1542

1326

access="readwrite")

1543

1327

def Timeout_dbus_property(self, value=None):

1544

1328

if value is None: # get

1545

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

1546

old_timeout = self.timeout

1329

return dbus.UInt64(self.timeout_milliseconds())

1547

1330

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

1548

# Reschedule disabling

1549

if self.enabled:

1550

now = datetime.datetime.utcnow()

1551

self.expires += self.timeout - old_timeout

1552

if self.expires <= now:

1553

# The timeout has passed

1554

self.disable()

1555

else:

1556

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

1557

is None):

1558

return

1559

gobject.source_remove(self.disable_initiator_tag)

1560

self.disable_initiator_tag = (

1561

gobject.timeout_add(

1562

int((self.expires - now).total_seconds()

1563

* 1000), self.disable))

1331

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

1332

return

1333

# Reschedule timeout

1334

gobject.source_remove(self.disable_initiator_tag)

1335

self.disable_initiator_tag = None

1336

self.expires = None

1337

time_to_die = _timedelta_to_milliseconds((self

1338

.last_checked_ok

1339

+ self.timeout)

1340

- datetime.datetime

1341

.utcnow())

1342

if time_to_die <= 0:

1343

# The timeout has passed

1344

self.disable()

1345

else:

1346

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

1347

+ datetime.timedelta(milliseconds =

1348

time_to_die))

1349

self.disable_initiator_tag = (gobject.timeout_add

1350

(time_to_die, self.disable))

1564

1351

1565

1352

# ExtendedTimeout - property

1566

1353

@dbus_service_property(_interface, signature="t",

1567

1354

access="readwrite")

1568

1355

def ExtendedTimeout_dbus_property(self, value=None):

1569

1356

if value is None: # get

1570

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

1571

* 1000)

1357

return dbus.UInt64(self.extended_timeout_milliseconds())

1572

1358

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

1573

1359

1574

1360

# Interval - property

1576

1362

access="readwrite")

1577

1363

def Interval_dbus_property(self, value=None):

1578

1364

if value is None: # get

1579

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

1365

return dbus.UInt64(self.interval_milliseconds())

1580

1366

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

1581

1367

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

1582

1368

return

1593

1379

def Checker_dbus_property(self, value=None):

1594

1380

if value is None: # get

1595

1381

return dbus.String(self.checker_command)

1596

self.checker_command = unicode(value)

1382

self.checker_command = value

1597

1383

1598

1384

# CheckerRunning - property

1599

1385

@dbus_service_property(_interface, signature="b",

1628

1414

raise KeyError()

1629

1415

1630

1416

def __getattribute__(self, name):

1631

if name == '_pipe':

1417

if(name == '_pipe'):

1632

1418

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

1633

1419

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

1634

1420

data = self._pipe.recv()

1641

1427

return func

1642

1428

1643

1429

def __setattr__(self, name, value):

1644

if name == '_pipe':

1430

if(name == '_pipe'):

1645

1431

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

1646

1432

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

1647

1433

1648

1434

1435

class ClientDBusTransitional(ClientDBus):

1436

__metaclass__ = AlternateDBusNamesMetaclass

1437

1438

1649

1439

class ClientHandler(socketserver.BaseRequestHandler, object):

1650

1440

"""A class to handle client connections.

1651

1441

1687

1477

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

1688

1478

try:

1689

1479

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

1690

raise RuntimeError(line)

1480

raise RuntimeError

1691

1481

except (ValueError, IndexError, RuntimeError) as error:

1692

1482

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

1693

1483

return

1712

1502

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

1713

1503

return

1714

1504

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

1505

if self.server.use_dbus:

1506

# Emit D-Bus signal

1507

client.NewRequest(str(self.client_address))

1715

1508

1716

1509

try:

1717

1510

client = ProxyClient(child_pipe, fpr,

1733

1526

client.Rejected("Disabled")

1734

1527

return

1735

1528

1736

if client.approved or not client.approval_delay:

1529

if client._approved or not client.approval_delay:

1737

1530

#We are approved or approval is disabled

1738

1531

break

1739

elif client.approved is None:

1532

elif client._approved is None:

1740

1533

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

1741

1534

client.name)

1742

1535

if self.server.use_dbus:

1743

1536

# Emit D-Bus signal

1744

1537

client.NeedApproval(

1745

client.approval_delay.total_seconds()

1746

* 1000, client.approved_by_default)

1538

client.approval_delay_milliseconds(),

1539

client.approved_by_default)

1747

1540

else:

1748

1541

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

1749

1542

client.name)

1755

1548

#wait until timeout or approved

1756

1549

time = datetime.datetime.now()

1757

1550

client.changedstate.acquire()

1758

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

1551

(client.changedstate.wait

1552

(float(client._timedelta_to_milliseconds(delay)

1553

/ 1000)))

1759

1554

client.changedstate.release()

1760

1555

time2 = datetime.datetime.now()

1761

1556

if (time2 - time) >= delay:

1777

1572

try:

1778

1573

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

1779

1574

except gnutls.errors.GNUTLSError as error:

1780

logger.warning("gnutls send failed",

1781

exc_info=error)

1575

logger.warning("gnutls send failed")

1782

1576

return

1783

1577

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

1784

1578

sent, len(client.secret)

1787

1581

1788

1582

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

1789

1583

# bump the timeout using extended_timeout

1790

client.bump_timeout(client.extended_timeout)

1584

client.checked_ok(client.extended_timeout)

1791

1585

if self.server.use_dbus:

1792

1586

# Emit D-Bus signal

1793

1587

client.GotSecret()

1798

1592

try:

1799

1593

session.bye()

1800

1594

except gnutls.errors.GNUTLSError as error:

1801

logger.warning("GnuTLS bye failed",

1802

exc_info=error)

1595

logger.warning("GnuTLS bye failed")

1803

1596

1804

1597

@staticmethod

1805

1598

def peer_certificate(session):

1870

1663

def sub_process_main(self, request, address):

1871

1664

try:

1872

1665

self.finish_request(request, address)

1873

except Exception:

1666

except:

1874

1667

self.handle_error(request, address)

1875

1668

self.close_request(request)

1876

1669

1877

1670

def process_request(self, request, address):

1878

1671

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

1879

1672

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

1880

args = (request, address))

1673

args = (request,

1674

address))

1881

1675

proc.start()

1882

1676

return proc

1883

1677

1898

1692

1899

1693

def add_pipe(self, parent_pipe, proc):

1900

1694

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

1901

raise NotImplementedError()

1695

raise NotImplementedError

1902

1696

1903

1697

1904

1698

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1911

1705

use_ipv6: Boolean; to use IPv6 or not

1912

1706

"""

1913

1707

def __init__(self, server_address, RequestHandlerClass,

1914

interface=None, use_ipv6=True, socketfd=None):

1915

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

1916

creating a new one with socket.socket().

1917

"""

1708

interface=None, use_ipv6=True):

1918

1709

self.interface = interface

1919

1710

if use_ipv6:

1920

1711

self.address_family = socket.AF_INET6

1921

if socketfd is not None:

1922

# Save the file descriptor

1923

self.socketfd = socketfd

1924

# Save the original socket.socket() function

1925

self.socket_socket = socket.socket

1926

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

1927

#

1928

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

1929

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

1930

# patching socket.socket.)

1931

#

1932

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

1933

@functools.wraps(socket.socket)

1934

def socket_wrapper(*args, **kwargs):

1935

# Restore original function so subsequent calls are

1936

# not affected.

1937

socket.socket = self.socket_socket

1938

del self.socket_socket

1939

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

1940

# saved file descriptor.

1941

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

1942

# Replace socket.socket() function with wrapper

1943

socket.socket = socket_wrapper

1944

# The socketserver.TCPServer.__init__ will call

1945

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

1946

# socket_wrapper(), if socketfd was set.

1947

1712

socketserver.TCPServer.__init__(self, server_address,

1948

1713

RequestHandlerClass)

1949

1950

1714

def server_bind(self):

1951

1715

"""This overrides the normal server_bind() function

1952

1716

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

1960

1724

try:

1961

1725

self.socket.setsockopt(socket.SOL_SOCKET,

1962

1726

SO_BINDTODEVICE,

1963

str(self.interface + '\0'))

1727

str(self.interface

1728

+ '\0'))

1964

1729

except socket.error as error:

1965

if error.errno == errno.EPERM:

1966

logger.error("No permission to bind to"

1967

" interface %s", self.interface)

1968

elif error.errno == errno.ENOPROTOOPT:

1730

if error[0] == errno.EPERM:

1731

logger.error("No permission to"

1732

" bind to interface %s",

1733

self.interface)

1734

elif error[0] == errno.ENOPROTOOPT:

1969

1735

logger.error("SO_BINDTODEVICE not available;"

1970

1736

" cannot bind to interface %s",

1971

1737

self.interface)

1972

elif error.errno == errno.ENODEV:

1973

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

1974

" cannot bind", self.interface)

1975

1738

else:

1976

1739

raise

1977

1740

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

1980

1743

if self.address_family == socket.AF_INET6:

1981

1744

any_address = "::" # in6addr_any

1982

1745

else:

1983

any_address = "0.0.0.0" # INADDR_ANY

1746

any_address = socket.INADDR_ANY

1984

1747

self.server_address = (any_address,

1985

1748

self.server_address[1])

1986

1749

elif not self.server_address[1]:

2007

1770

"""

2008

1771

def __init__(self, server_address, RequestHandlerClass,

2009

1772

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

2010

gnutls_priority=None, use_dbus=True, socketfd=None):

1773

gnutls_priority=None, use_dbus=True):

2011

1774

self.enabled = False

2012

1775

self.clients = clients

2013

1776

if self.clients is None:

2017

1780

IPv6_TCPServer.__init__(self, server_address,

2018

1781

RequestHandlerClass,

2019

1782

interface = interface,

2020

use_ipv6 = use_ipv6,

2021

socketfd = socketfd)

1783

use_ipv6 = use_ipv6)

2022

1784

def server_activate(self):

2023

1785

if self.enabled:

2024

1786

return socketserver.TCPServer.server_activate(self)

2037

1799

2038

1800

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

2039

1801

proc = None, client_object=None):

1802

condition_names = {

1803

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

1804

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

1805

# blocking).

1806

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

1807

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

1808

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

1809

# broken, usually for pipes and

1810

# sockets).

1811

}

1812

conditions_string = ' | '.join(name

1813

for cond, name in

1814

condition_names.iteritems()

1815

if cond & condition)

2040

1816

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

2041

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

1817

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

2042

1818

# Wait for other process to exit

2043

1819

proc.join()

2044

1820

return False

2102

1878

return True

2103

1879

2104

1880

2105

def rfc3339_duration_to_delta(duration):

2106

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

2107

2108

>>> rfc3339_duration_to_delta("P7D")

2109

datetime.timedelta(7)

2110

>>> rfc3339_duration_to_delta("PT60S")

2111

datetime.timedelta(0, 60)

2112

>>> rfc3339_duration_to_delta("PT60M")

2113

datetime.timedelta(0, 3600)

2114

>>> rfc3339_duration_to_delta("PT24H")

2115

datetime.timedelta(1)

2116

>>> rfc3339_duration_to_delta("P1W")

2117

datetime.timedelta(7)

2118

>>> rfc3339_duration_to_delta("PT5M30S")

2119

datetime.timedelta(0, 330)

2120

>>> rfc3339_duration_to_delta("P1DT3M20S")

2121

datetime.timedelta(1, 200)

2122

"""

2123

2124

# Parsing an RFC 3339 duration with regular expressions is not

2125

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

2126

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

2127

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

2128

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

2129

# avoid excessive use of external libraries.

2130

2131

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

2132

Token = collections.namedtuple("Token",

2133

("regexp", # To match token; if

2134

# "value" is not None,

2135

# must have a "group"

2136

# containing digits

2137

"value", # datetime.timedelta or

2138

# None

2139

"followers")) # Tokens valid after

2140

# this token

2141

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

2142

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

2143

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

2144

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

2145

datetime.timedelta(seconds=1),

2146

frozenset((token_end,)))

2147

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

2148

datetime.timedelta(minutes=1),

2149

frozenset((token_second, token_end)))

2150

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

2151

datetime.timedelta(hours=1),

2152

frozenset((token_minute, token_end)))

2153

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

2154

None,

2155

frozenset((token_hour, token_minute,

2156

token_second)))

2157

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

2158

datetime.timedelta(days=1),

2159

frozenset((token_time, token_end)))

2160

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

2161

datetime.timedelta(weeks=4),

2162

frozenset((token_day, token_end)))

2163

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

2164

datetime.timedelta(weeks=52),

2165

frozenset((token_month, token_end)))

2166

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

2167

datetime.timedelta(weeks=1),

2168

frozenset((token_end,)))

2169

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

2170

frozenset((token_year, token_month,

2171

token_day, token_time,

2172

token_week)))

2173

# Define starting values

2174

value = datetime.timedelta() # Value so far

2175

found_token = None

2176

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

2177

s = duration # String left to parse

2178

# Loop until end token is found

2179

while found_token is not token_end:

2180

# Search for any currently valid tokens

2181

for token in followers:

2182

match = token.regexp.match(s)

2183

if match is not None:

2184

# Token found

2185

if token.value is not None:

2186

# Value found, parse digits

2187

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

2188

# Add to value so far

2189

value += factor * token.value

2190

# Strip token from string

2191

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

2192

# Go to found token

2193

found_token = token

2194

# Set valid next tokens

2195

followers = found_token.followers

2196

break

2197

else:

2198

# No currently valid tokens were found

2199

raise ValueError("Invalid RFC 3339 duration")

2200

# End token found

2201

return value

2202

2203

2204

1881

def string_to_delta(interval):

2205

1882

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

2206

1883

2217

1894

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

2218

1895

datetime.timedelta(0, 330)

2219

1896

"""

2220

2221

try:

2222

return rfc3339_duration_to_delta(interval)

2223

except ValueError:

2224

pass

2225

2226

1897

timevalue = datetime.timedelta(0)

2227

1898

for s in interval.split():

2228

1899

try:

2239

1910

elif suffix == "w":

2240

1911

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

2241

1912

else:

2242

raise ValueError("Unknown suffix {!r}"

2243

.format(suffix))

2244

except IndexError as e:

1913

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

1914

except (ValueError, IndexError) as e:

2245

1915

raise ValueError(*(e.args))

2246

1916

timevalue += delta

2247

1917

return timevalue

2260

1930

sys.exit()

2261

1931

if not noclose:

2262

1932

# Close all standard open file descriptors

2263

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

1933

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

2264

1934

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

2265

raise OSError(errno.ENODEV, "{} not a character device"

2266

.format(os.devnull))

1935

raise OSError(errno.ENODEV,

1936

"%s not a character device"

1937

% os.path.devnull)

2267

1938

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

2268

1939

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

2269

1940

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

2278

1949

2279

1950

parser = argparse.ArgumentParser()

2280

1951

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

2281

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

1952

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

2282

1953

help="show version number and exit")

2283

1954

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

2284

1955

help="Bind to interface IF")

2290

1961

help="Run self-test")

2291

1962

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

2292

1963

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

2293

" to terminal", default=None)

1964

" to terminal")

2294

1965

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

2295

1966

help="Debug level for stdout output")

2296

1967

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

2303

1974

" files")

2304

1975

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

2305

1976

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

2306

" system bus interface", default=None)

1977

" system bus interface")

2307

1978

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

2308

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

2309

default=None)

1979

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

2310

1980

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

2311

1981

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

2312

" state", default=None)

2313

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

2314

help="Specify a file descriptor to a network"

2315

" socket to use instead of creating one")

1982

" state")

2316

1983

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

2317

1984

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

2318

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

2319

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

2320

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

2321

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

2322

default=None)

2323

1985

2324

1986

options = parser.parse_args()

2325

1987

2326

1988

if options.check:

2327

1989

import doctest

2328

fail_count, test_count = doctest.testmod()

2329

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

1990

doctest.testmod()

1991

sys.exit()

2330

1992

2331

1993

# Default values for config file for server-global settings

2332

1994

server_defaults = { "interface": "",

2334

1996

"port": "",

2335

1997

"debug": "False",

2336

1998

"priority":

2337

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

1999

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

2338

2000

"servicename": "Mandos",

2339

2001

"use_dbus": "True",

2340

2002

"use_ipv6": "True",

2341

2003

"debuglevel": "",

2342

2004

"restore": "True",

2343

"socket": "",

2344

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

2345

"foreground": "False",

2346

"zeroconf": "True",

2005

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

2347

2006

}

2348

2007

2349

2008

# Parse config file for server-global settings

2354

2013

# Convert the SafeConfigParser object to a dict

2355

2014

server_settings = server_config.defaults()

2356

2015

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

2357

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

2016

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

2358

2017

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

2359

2018

option)

2360

2019

if server_settings["port"]:

2361

2020

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

2362

2021

"port")

2363

if server_settings["socket"]:

2364

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

2365

"socket")

2366

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

2367

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

2368

# happen with a supplied network socket.

2369

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

2370

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

2371

["socket"])

2372

2022

del server_config

2373

2023

2374

2024

# Override the settings from the config file with command line

2376

2026

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

2377

2027

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

2378

2028

"use_dbus", "use_ipv6", "debuglevel", "restore",

2379

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

2029

"statedir"):

2380

2030

value = getattr(options, option)

2381

2031

if value is not None:

2382

2032

server_settings[option] = value

2385

2035

for option in server_settings.keys():

2386

2036

if type(server_settings[option]) is str:

2387

2037

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

2388

# Force all boolean options to be boolean

2389

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

2390

"foreground", "zeroconf"):

2391

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

2392

# Debug implies foreground

2393

if server_settings["debug"]:

2394

server_settings["foreground"] = True

2395

2038

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

2396

2039

2397

2040

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

2398

2041

2399

if (not server_settings["zeroconf"] and

2400

not (server_settings["port"]

2401

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

2402

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

2403

" Zeroconf")

2404

2405

2042

# For convenience

2406

2043

debug = server_settings["debug"]

2407

2044

debuglevel = server_settings["debuglevel"]

2409

2046

use_ipv6 = server_settings["use_ipv6"]

2410

2047

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

2411

2048

stored_state_file)

2412

foreground = server_settings["foreground"]

2413

zeroconf = server_settings["zeroconf"]

2414

2049

2415

2050

if debug:

2416

initlogger(debug, logging.DEBUG)

2051

initlogger(logging.DEBUG)

2417

2052

else:

2418

2053

if not debuglevel:

2419

initlogger(debug)

2054

initlogger()

2420

2055

else:

2421

2056

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

2422

initlogger(debug, level)

2057

initlogger(level)

2423

2058

2424

2059

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

2425

2060

syslogger.setFormatter(logging.Formatter

2426

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

2427

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

2428

.format(server_settings

2429

["servicename"])))

2061

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

2062

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

2063

% server_settings["servicename"]))

2430

2064

2431

2065

# Parse config file with clients

2432

client_config = configparser.SafeConfigParser(Client

2433

.client_defaults)

2066

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

2067

"extended_timeout": "15m",

2068

"interval": "2m",

2069

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

2070

"host": "",

2071

"approval_delay": "0s",

2072

"approval_duration": "1s",

2073

}

2074

client_config = configparser.SafeConfigParser(client_defaults)

2434

2075

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

2435

2076

"clients.conf"))

2436

2077

2437

2078

global mandos_dbus_service

2438

2079

mandos_dbus_service = None

2439

2080

2440

socketfd = None

2441

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

2442

socketfd = server_settings["socket"]

2443

2081

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

2444

2082

server_settings["port"]),

2445

2083

ClientHandler,

2448

2086

use_ipv6=use_ipv6,

2449

2087

gnutls_priority=

2450

2088

server_settings["priority"],

2451

use_dbus=use_dbus,

2452

socketfd=socketfd)

2453

if not foreground:

2454

pidfilename = "/run/mandos.pid"

2455

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

2456

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

2457

pidfile = None

2089

use_dbus=use_dbus)

2090

if not debug:

2091

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

2458

2092

try:

2459

2093

pidfile = open(pidfilename, "w")

2460

except IOError as e:

2461

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

2462

exc_info=e)

2094

except IOError:

2095

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

2463

2096

2464

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

2097

try:

2098

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

2099

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

2100

except KeyError:

2465

2101

try:

2466

uid = pwd.getpwnam(name).pw_uid

2467

gid = pwd.getpwnam(name).pw_gid

2468

break

2102

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

2103

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

2469

2104

except KeyError:

2470

continue

2471

else:

2472

uid = 65534

2473

gid = 65534

2105

try:

2106

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

2107

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

2108

except KeyError:

2109

uid = 65534

2110

gid = 65534

2474

2111

try:

2475

2112

os.setgid(gid)

2476

2113

os.setuid(uid)

2477

2114

except OSError as error:

2478

if error.errno != errno.EPERM:

2479

raise

2115

if error[0] != errno.EPERM:

2116

raise error

2480

2117

2481

2118

if debug:

2482

2119

# Enable all possible GnuTLS debugging

2493

2130

.gnutls_global_set_log_function(debug_gnutls))

2494

2131

2495

2132

# Redirect stdin so all checkers get /dev/null

2496

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

2133

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

2497

2134

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

2498

2135

if null > 2:

2499

2136

os.close(null)

2137

else:

2138

# No console logging

2139

logger.removeHandler(console)

2500

2140

2501

2141

# Need to fork before connecting to D-Bus

2502

if not foreground:

2142

if not debug:

2503

2143

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

2504

2144

daemon()

2505

2145

2506

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

2507

# need to inform gobject that threads will be used.

2508

gobject.threads_init()

2509

2510

2146

global main_loop

2511

2147

# From the Avahi example code

2512

DBusGMainLoop(set_as_default=True)

2148

DBusGMainLoop(set_as_default=True )

2513

2149

main_loop = gobject.MainLoop()

2514

2150

bus = dbus.SystemBus()

2515

2151

# End of Avahi example code

2521

2157

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

2522

2158

do_not_queue=True))

2523

2159

except dbus.exceptions.NameExistsException as e:

2524

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

2160

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

2525

2161

use_dbus = False

2526

2162

server_settings["use_dbus"] = False

2527

2163

tcp_server.use_dbus = False

2528

if zeroconf:

2529

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2530

service = AvahiServiceToSyslog(name =

2531

server_settings["servicename"],

2532

servicetype = "_mandos._tcp",

2533

protocol = protocol, bus = bus)

2534

if server_settings["interface"]:

2535

service.interface = (if_nametoindex

2536

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

2164

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2165

service = AvahiServiceToSyslog(name =

2166

server_settings["servicename"],

2167

servicetype = "_mandos._tcp",

2168

protocol = protocol, bus = bus)

2169

if server_settings["interface"]:

2170

service.interface = (if_nametoindex

2171

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

2537

2172

2538

2173

global multiprocessing_manager

2539

2174

multiprocessing_manager = multiprocessing.Manager()

2540

2175

2541

2176

client_class = Client

2542

2177

if use_dbus:

2543

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

2544

2545

client_settings = Client.config_parser(client_config)

2178

client_class = functools.partial(ClientDBusTransitional,

2179

bus = bus)

2180

2181

special_settings = {

2182

# Some settings need to be accessd by special methods;

2183

# booleans need .getboolean(), etc. Here is a list of them:

2184

"approved_by_default":

2185

lambda section:

2186

client_config.getboolean(section, "approved_by_default"),

2187

"enabled":

2188

lambda section:

2189

client_config.getboolean(section, "enabled"),

2190

}

2191

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

2192

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

2193

# with exceptions for any special settings as defined above

2194

client_settings = dict((clientname,

2195

dict((setting,

2196

(value

2197

if setting not in special_settings

2198

else special_settings[setting]

2199

(clientname)))

2200

for setting, value in

2201

client_config.items(clientname)))

2202

for clientname in client_config.sections())

2203

2546

2204

old_client_settings = {}

2547

clients_data = {}

2548

2549

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

2550

global wnull

2551

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

2552

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

2553

# mode

2554

if debug or not foreground:

2555

wnull.close()

2205

clients_data = []

2556

2206

2557

2207

# Get client data and settings from last running state.

2558

2208

if server_settings["restore"]:

2562

2212

(stored_state))

2563

2213

os.remove(stored_state_path)

2564

2214

except IOError as e:

2565

if e.errno == errno.ENOENT:

2566

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

2567

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

2568

else:

2569

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

2570

exc_info=e)

2215

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

2216

.format(e))

2217

if e.errno != errno.ENOENT:

2571

2218

raise

2572

except EOFError as e:

2573

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

2574

"EOFError:", exc_info=e)

2575

2219

2576

with PGPEngine() as pgp:

2577

for client_name, client in clients_data.items():

2578

# Skip removed clients

2579

if client_name not in client_settings:

2580

continue

2220

with Crypto() as crypt:

2221

for client in clients_data:

2222

client_name = client["name"]

2581

2223

2582

2224

# Decide which value to use after restoring saved state.

2583

2225

# We have three different values: Old config file,

2592

2234

if (name != "secret" and

2593

2235

value != old_client_settings[client_name]

2594

2236

[name]):

2595

client[name] = value

2237

setattr(client, name, value)

2596

2238

except KeyError:

2597

2239

pass

2598

2240

2599

2241

# Clients who has passed its expire date can still be

2600

# enabled if its last checker was successful. Clients

2601

# whose checker succeeded before we stored its state is

2602

# assumed to have successfully run all checkers during

2603

# downtime.

2604

if client["enabled"]:

2605

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

2606

if not client["last_checked_ok"]:

2607

logger.warning(

2608

"disabling client {} - Client never "

2609

"performed a successful checker"

2610

.format(client_name))

2611

client["enabled"] = False

2612

elif client["last_checker_status"] != 0:

2613

logger.warning(

2614

"disabling client {} - Client last"

2615

" checker failed with error code {}"

2616

.format(client_name,

2617

client["last_checker_status"]))

2242

# enabled if its last checker was sucessful. Clients

2243

# whose checker failed before we stored its state is

2244

# assumed to have failed all checkers during downtime.

2245

if client["enabled"] and client["last_checked_ok"]:

2246

if ((datetime.datetime.utcnow()

2247

- client["last_checked_ok"])

2248

> client["interval"]):

2249

if client["last_checker_status"] != 0:

2618

2250

client["enabled"] = False

2619

2251

else:

2620

2252

client["expires"] = (datetime.datetime

2621

2253

.utcnow()

2622

2254

+ client["timeout"])

2623

logger.debug("Last checker succeeded,"

2624

" keeping {} enabled"

2625

.format(client_name))

2255

2256

client["changedstate"] = (multiprocessing_manager

2257

.Condition

2258

(multiprocessing_manager

2259

.Lock()))

2260

if use_dbus:

2261

new_client = (ClientDBusTransitional.__new__

2262

(ClientDBusTransitional))

2263

tcp_server.clients[client_name] = new_client

2264

new_client.bus = bus

2265

for name, value in client.iteritems():

2266

setattr(new_client, name, value)

2267

client_object_name = unicode(client_name).translate(

2268

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

2269

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

2270

new_client.dbus_object_path = (dbus.ObjectPath

2271

("/clients/"

2272

+ client_object_name))

2273

DBusObjectWithProperties.__init__(new_client,

2274

new_client.bus,

2275

new_client

2276

.dbus_object_path)

2277

else:

2278

tcp_server.clients[client_name] = (Client.__new__

2279

(Client))

2280

for name, value in client.iteritems():

2281

setattr(tcp_server.clients[client_name],

2282

name, value)

2283

2626

2284

try:

2627

client["secret"] = (

2628

pgp.decrypt(client["encrypted_secret"],

2629

client_settings[client_name]

2630

["secret"]))

2631

except PGPError:

2285

tcp_server.clients[client_name].secret = (

2286

crypt.decrypt(tcp_server.clients[client_name]

2287

.encrypted_secret,

2288

client_settings[client_name]

2289

["secret"]))

2290

except CryptoError:

2632

2291

# If decryption fails, we use secret from new settings

2633

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

2634

.format(client_name))

2635

client["secret"] = (

2292

tcp_server.clients[client_name].secret = (

2636

2293

client_settings[client_name]["secret"])

2637

2294

2638

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

2639

for client_name in (set(old_client_settings)

2640

- set(client_settings)):

2641

del clients_data[client_name]

2642

for client_name in (set(client_settings)

2643

- set(old_client_settings)):

2644

clients_data[client_name] = client_settings[client_name]

2645

2646

# Create all client objects

2647

for client_name, client in clients_data.items():

2648

tcp_server.clients[client_name] = client_class(

2649

name = client_name, settings = client,

2650

server_settings = server_settings)

2295

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

2296

for clientname in set(old_client_settings) - set(client_settings):

2297

del tcp_server.clients[clientname]

2298

for clientname in set(client_settings) - set(old_client_settings):

2299

tcp_server.clients[clientname] = (client_class(name

2300

= clientname,

2301

config =

2302

client_settings

2303

[clientname]))

2651

2304

2652

2305

if not tcp_server.clients:

2653

2306

logger.warning("No clients defined")

2654

2655

if not foreground:

2656

if pidfile is not None:

2657

try:

2658

with pidfile:

2659

pid = os.getpid()

2660

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

2661

except IOError:

2662

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

2663

pidfilename, pid)

2664

del pidfile

2307

2308

if not debug:

2309

try:

2310

with pidfile:

2311

pid = os.getpid()

2312

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

2313

del pidfile

2314

except IOError:

2315

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

2316

pidfilename, pid)

2317

except NameError:

2318

# "pidfile" was never created

2319

pass

2665

2320

del pidfilename

2321

2322

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

2666

2323

2667

2324

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

2668

2325

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

2669

2326

2670

2327

if use_dbus:

2671

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

2672

"se.bsnet.fukt.Mandos"})

2673

class MandosDBusService(DBusObjectWithProperties):

2328

class MandosDBusService(dbus.service.Object):

2674

2329

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

2675

2330

def __init__(self):

2676

2331

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

2677

2332

_interface = "se.recompile.Mandos"

2678

2333

2679

@dbus_interface_annotations(_interface)

2680

def _foo(self):

2681

return { "org.freedesktop.DBus.Property"

2682

".EmitsChangedSignal":

2683

"false"}

2684

2685

2334

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

2686

2335

def ClientAdded(self, objpath):

2687

2336

"D-Bus signal"

2729

2378

2730

2379

del _interface

2731

2380

2732

mandos_dbus_service = MandosDBusService()

2381

class MandosDBusServiceTransitional(MandosDBusService):

2382

__metaclass__ = AlternateDBusNamesMetaclass

2383

mandos_dbus_service = MandosDBusServiceTransitional()

2733

2384

2734

2385

def cleanup():

2735

2386

"Cleanup function; run on exit"

2736

if zeroconf:

2737

service.cleanup()

2387

service.cleanup()

2738

2388

2739

2389

multiprocessing.active_children()

2740

wnull.close()

2741

2390

if not (tcp_server.clients or client_settings):

2742

2391

return

2743

2392

2744

2393

# Store client before exiting. Secrets are encrypted with key

2745

2394

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

2746

2395

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

2747

clients = {}

2748

with PGPEngine() as pgp:

2396

clients = []

2397

with Crypto() as crypt:

2749

2398

for client in tcp_server.clients.itervalues():

2750

2399

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

2751

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

2752

key)

2400

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

2401

key)

2753

2402

client_dict = {}

2754

2403

2755

# A list of attributes that can not be pickled

2756

# + secret.

2757

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

2758

"checker", "server_settings" }

2404

# A list of attributes that will not be stored when

2405

# shutting down.

2406

exclude = set(("bus", "changedstate", "secret"))

2759

2407

for name, typ in (inspect.getmembers

2760

2408

(dbus.service.Object)):

2761

2409

exclude.add(name)

2766

2414

if attr not in exclude:

2767

2415

client_dict[attr] = getattr(client, attr)

2768

2416

2769

clients[client.name] = client_dict

2417

clients.append(client_dict)

2770

2418

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

2771

2419

2772

2420

try:

2773

with (tempfile.NamedTemporaryFile

2774

(mode='wb', suffix=".pickle", prefix='clients-',

2775

dir=os.path.dirname(stored_state_path),

2776

delete=False)) as stored_state:

2421

with os.fdopen(os.open(stored_state_path,

2422

os.O_CREAT|os.O_WRONLY|os.O_TRUNC,

2423

0600), "wb") as stored_state:

2777

2424

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

2778

tempname=stored_state.name

2779

os.rename(tempname, stored_state_path)

2780

2425

except (IOError, OSError) as e:

2781

if not debug:

2782

try:

2783

os.remove(tempname)

2784

except NameError:

2785

pass

2786

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

2787

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

2788

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

2789

else:

2790

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

2791

exc_info=e)

2426

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

2427

.format(e))

2428

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

2792

2429

raise

2793

2430

2794

2431

# Delete all clients, and settings from config

2819

2456

tcp_server.server_activate()

2820

2457

2821

2458

# Find out what port we got

2822

if zeroconf:

2823

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

2459

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

2824

2460

if use_ipv6:

2825

2461

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

2826

" flowinfo %d, scope_id %d",

2827

*tcp_server.socket.getsockname())

2462

" flowinfo %d, scope_id %d"

2463

% tcp_server.socket.getsockname())

2828

2464

else: # IPv4

2829

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

2830

*tcp_server.socket.getsockname())

2465

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

2466

% tcp_server.socket.getsockname())

2831

2467

2832

2468

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

2833

2469

2834

2470

try:

2835

if zeroconf:

2836

# From the Avahi example code

2837

try:

2838

service.activate()

2839

except dbus.exceptions.DBusException as error:

2840

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

2841

cleanup()

2842

sys.exit(1)

2843

# End of Avahi example code

2471

# From the Avahi example code

2472

try:

2473

service.activate()

2474

except dbus.exceptions.DBusException as error:

2475

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

2476

cleanup()

2477

sys.exit(1)

2478

# End of Avahi example code

2844

2479

2845

2480

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

2846

2481

lambda *args, **kwargs:

2850

2485

logger.debug("Starting main loop")

2851

2486

main_loop.run()

2852

2487

except AvahiError as error:

2853

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

2488

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

2854

2489

cleanup()

2855

2490

sys.exit(1)

2856

2491

except KeyboardInterrupt:

2861

2496

# Must run before the D-Bus bus name gets deregistered

2862

2497

cleanup()

2863

2498

2499

2864

2500

if __name__ == '__main__':

2865

2501

main()