/mandos/trunk : revision 518.2.9

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

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

142

136

class PGPEngine(object):

143

137

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

144

138

def __init__(self):

139

self.gnupg = GnuPGInterface.GnuPG()

145

140

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

146

self.gnupgargs = ['--batch',

147

'--home', self.tempdir,

148

'--force-mdc',

149

'--quiet',

150

'--no-use-agent']

141

self.gnupg = GnuPGInterface.GnuPG()

142

self.gnupg.options.meta_interactive = False

143

self.gnupg.options.homedir = self.tempdir

144

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

145

'--quiet'])

151

146

152

147

def __enter__(self):

153

148

return self

154

149

155

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

150

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

156

151

self._cleanup()

157

152

return False

158

153

175

170

def password_encode(self, password):

176

171

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

177

172

# 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

173

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

185

174

186

175

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)

176

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

177

with open(os.devnull) as devnull:

178

try:

179

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

180

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

181

attach_fhs={'stderr': devnull})

182

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

183

f.write(data)

184

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

185

ciphertext = f.read()

186

proc.wait()

187

except IOError as e:

188

raise PGPError(e)

189

self.gnupg.passphrase = None

202

190

return ciphertext

203

191

204

192

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)

193

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

194

with open(os.devnull) as devnull:

195

try:

196

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

197

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

198

attach_fhs={'stderr': devnull})

199

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

200

f.write(data)

201

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

202

decrypted_plaintext = f.read()

203

proc.wait()

204

except IOError as e:

205

raise PGPError(e)

206

self.gnupg.passphrase = None

221

207

return decrypted_plaintext

222

208

223

209

210

224

211

class AvahiError(Exception):

225

212

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

226

213

self.value = value

243

230

Used to optionally bind to the specified interface.

244

231

name: string; Example: 'Mandos'

245

232

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

246

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

233

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

247

234

port: integer; what port to announce

248

235

TXT: list of strings; TXT record for the service

249

236

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

255

242

server: D-Bus Server

256

243

bus: dbus.SystemBus()

257

244

"""

258

259

245

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

260

246

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

261

247

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

274

260

self.server = None

275

261

self.bus = bus

276

262

self.entry_group_state_changed_match = None

277

278

263

def rename(self):

279

264

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

280

265

if self.rename_count >= self.max_renames:

290

275

try:

291

276

self.add()

292

277

except dbus.exceptions.DBusException as error:

293

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

278

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

294

279

self.cleanup()

295

280

os._exit(1)

296

281

self.rename_count += 1

297

298

282

def remove(self):

299

283

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

300

284

if self.entry_group_state_changed_match is not None:

302

286

self.entry_group_state_changed_match = None

303

287

if self.group is not None:

304

288

self.group.Reset()

305

306

289

def add(self):

307

290

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

308

291

self.remove()

325

308

dbus.UInt16(self.port),

326

309

avahi.string_array_to_txt_array(self.TXT))

327

310

self.group.Commit()

328

329

311

def entry_group_state_changed(self, state, error):

330

312

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

331

313

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

338

320

elif state == avahi.ENTRY_GROUP_FAILURE:

339

321

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

340

322

unicode(error))

341

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

342

.format(error))

343

323

raise AvahiGroupError("State changed: %s"

324

% unicode(error))

344

325

def cleanup(self):

345

326

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

346

327

if self.group is not None:

351

332

pass

352

333

self.group = None

353

334

self.remove()

354

355

335

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

356

336

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

357

337

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

376

356

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

377

357

else:

378

358

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

379

380

359

def activate(self):

381

360

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

382

361

if self.server is None:

389

368

self.server_state_changed)

390

369

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

391

370

392

393

371

class AvahiServiceToSyslog(AvahiService):

394

372

def rename(self):

395

373

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

396

374

ret = AvahiService.rename(self)

397

375

syslogger.setFormatter(logging.Formatter

398

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

399

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

400

.format(self.name)))

376

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

377

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

378

% self.name))

401

379

return ret

402

380

403

404

381

def timedelta_to_milliseconds(td):

405

382

"Convert a datetime.timedelta() to milliseconds"

406

383

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

407

384

+ (td.seconds * 1000)

408

385

+ (td.microseconds // 1000))

409

410

386

411

387

class Client(object):

412

388

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

413

389

436

412

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

437

413

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

438

414

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

415

439

416

last_checker_status: integer between 0 and 255 reflecting exit

440

417

status of last checker. -1 reflects crashed

441

checker, -2 means no checker completed yet.

418

checker, or None.

442

419

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

443

420

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

444

421

D-Bus identifiers

445

422

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

446

423

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

447

424

until this client is disabled

448

extended_timeout: extra long timeout when secret has been sent

425

extended_timeout: extra long timeout when password has been sent

449

426

runtime_expansions: Allowed attributes for runtime expansion.

450

427

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

451

428

disabled, or None

452

server_settings: The server_settings dict from main()

453

429

"""

454

430

455

431

runtime_expansions = ("approval_delay", "approval_duration",

456

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

457

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

458

"last_approval_request", "last_checked_ok",

432

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

433

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

459

434

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

460

client_defaults = { "timeout": "PT5M",

461

"extended_timeout": "PT15M",

462

"interval": "PT2M",

463

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

464

"host": "",

465

"approval_delay": "PT0S",

466

"approval_duration": "PT1S",

467

"approved_by_default": "True",

468

"enabled": "True",

469

}

470

435

471

436

def timeout_milliseconds(self):

472

437

"Return the 'timeout' attribute in milliseconds"

483

448

def approval_delay_milliseconds(self):

484

449

return timedelta_to_milliseconds(self.approval_delay)

485

450

486

@staticmethod

487

def config_parser(config):

488

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

489

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

490

with exceptions for any special settings as defined above.

491

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

492

value given the same arguments.

493

"""

494

settings = {}

495

for client_name in config.sections():

496

section = dict(config.items(client_name))

497

client = settings[client_name] = {}

498

499

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

500

# Reformat values from string types to Python types

501

client["approved_by_default"] = config.getboolean(

502

client_name, "approved_by_default")

503

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

504

"enabled")

505

506

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

507

.replace(" ", ""))

508

if "secret" in section:

509

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

510

elif "secfile" in section:

511

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

512

(section["secfile"])),

513

"rb") as secfile:

514

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

515

else:

516

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

517

.format(section))

518

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

519

client["extended_timeout"] = string_to_delta(

520

section["extended_timeout"])

521

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

522

client["approval_delay"] = string_to_delta(

523

section["approval_delay"])

524

client["approval_duration"] = string_to_delta(

525

section["approval_duration"])

526

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

527

client["last_approval_request"] = None

528

client["last_checked_ok"] = None

529

client["last_checker_status"] = -2

530

531

return settings

532

533

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

451

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

452

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

453

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

454

attribute."""

534

455

self.name = name

535

if server_settings is None:

536

server_settings = {}

537

self.server_settings = server_settings

538

# adding all client settings

539

for setting, value in settings.iteritems():

540

setattr(self, setting, value)

541

542

if self.enabled:

543

if not hasattr(self, "last_enabled"):

544

self.last_enabled = datetime.datetime.utcnow()

545

if not hasattr(self, "expires"):

546

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

547

+ self.timeout)

548

else:

549

self.last_enabled = None

550

self.expires = None

551

456

if config is None:

457

config = {}

552

458

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

553

459

# Uppercase and remove spaces from fingerprint for later

554

460

# comparison purposes with return value from the fingerprint()

555

461

# function

462

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

463

.replace(" ", ""))

556

464

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

557

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

558

datetime.datetime.utcnow())

559

560

# attributes specific for this server instance

465

if "secret" in config:

466

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

467

elif "secfile" in config:

468

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

469

(config["secfile"])),

470

"rb") as secfile:

471

self.secret = secfile.read()

472

else:

473

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

474

% self.name)

475

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

476

self.created = datetime.datetime.utcnow()

477

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

478

self.last_approval_request = None

479

if self.enabled:

480

self.last_enabled = datetime.datetime.utcnow()

481

else:

482

self.last_enabled = None

483

self.last_checked_ok = None

484

self.last_checker_status = None

485

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

486

self.extended_timeout = string_to_delta(config

487

["extended_timeout"])

488

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

561

489

self.checker = None

562

490

self.checker_initiator_tag = None

563

491

self.disable_initiator_tag = None

492

if self.enabled:

493

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

494

else:

495

self.expires = None

564

496

self.checker_callback_tag = None

497

self.checker_command = config["checker"]

565

498

self.current_checker_command = None

566

499

self.approved = None

500

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

501

True)

567

502

self.approvals_pending = 0

503

self.approval_delay = string_to_delta(

504

config["approval_delay"])

505

self.approval_duration = string_to_delta(

506

config["approval_duration"])

568

507

self.changedstate = (multiprocessing_manager

569

508

.Condition(multiprocessing_manager

570

509

.Lock()))

590

529

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

591

530

# Already enabled

592

531

return

532

self.send_changedstate()

593

533

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

594

534

self.enabled = True

595

535

self.last_enabled = datetime.datetime.utcnow()

596

536

self.init_checker()

597

self.send_changedstate()

598

537

599

538

def disable(self, quiet=True):

600

539

"""Disable this client."""

601

540

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

602

541

return False

603

542

if not quiet:

543

self.send_changedstate()

544

if not quiet:

604

545

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

605

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

546

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

606

547

gobject.source_remove(self.disable_initiator_tag)

607

548

self.disable_initiator_tag = None

608

549

self.expires = None

609

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

550

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

610

551

gobject.source_remove(self.checker_initiator_tag)

611

552

self.checker_initiator_tag = None

612

553

self.stop_checker()

613

554

self.enabled = False

614

if not quiet:

615

self.send_changedstate()

616

555

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

617

556

return False

618

557

622

561

def init_checker(self):

623

562

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

624

563

# and every interval from then on.

625

if self.checker_initiator_tag is not None:

626

gobject.source_remove(self.checker_initiator_tag)

627

564

self.checker_initiator_tag = (gobject.timeout_add

628

565

(self.interval_milliseconds(),

629

566

self.start_checker))

630

567

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

631

if self.disable_initiator_tag is not None:

632

gobject.source_remove(self.disable_initiator_tag)

633

568

self.disable_initiator_tag = (gobject.timeout_add

634

569

(self.timeout_milliseconds(),

635

570

self.disable))

654

589

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

655

590

vars(self))

656

591

657

def checked_ok(self):

658

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

659

self.last_checked_ok = datetime.datetime.utcnow()

660

self.last_checker_status = 0

661

self.bump_timeout()

662

663

def bump_timeout(self, timeout=None):

664

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

592

def checked_ok(self, timeout=None):

593

"""Bump up the timeout for this client.

594

595

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

596

alive and well.

597

"""

665

598

if timeout is None:

666

599

timeout = self.timeout

600

self.last_checked_ok = datetime.datetime.utcnow()

667

601

if self.disable_initiator_tag is not None:

668

602

gobject.source_remove(self.disable_initiator_tag)

669

self.disable_initiator_tag = None

670

603

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

671

604

self.disable_initiator_tag = (gobject.timeout_add

672

605

(timedelta_to_milliseconds

682

615

If a checker already exists, leave it running and do

683

616

nothing."""

684

617

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

685

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

686

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

687

# would inevitably timeout, since no checker would get a

688

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

618

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

619

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

620

# client would inevitably timeout, since no checker would get

621

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

689

622

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

690

623

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

691

624

# should be.

693

626

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

694

627

try:

695

628

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

696

except AttributeError:

697

pass

698

except OSError as error:

699

if error.errno != errno.ECHILD:

700

raise

629

except (AttributeError, OSError) as error:

630

if (isinstance(error, OSError)

631

and error.errno != errno.ECHILD):

632

raise error

701

633

else:

702

634

if pid:

703

635

logger.warning("Checker was a zombie")

706

638

self.current_checker_command)

707

639

# Start a new checker if needed

708

640

if self.checker is None:

709

# Escape attributes for the shell

710

escaped_attrs = dict(

711

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

712

for attr in

713

self.runtime_expansions)

714

641

try:

715

command = self.checker_command % escaped_attrs

716

except TypeError as error:

717

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

718

self.checker_command, exc_info=error)

719

return True # Try again later

642

# In case checker_command has exactly one % operator

643

command = self.checker_command % self.host

644

except TypeError:

645

# Escape attributes for the shell

646

escaped_attrs = dict(

647

(attr,

648

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

649

errors=

650

'replace')))

651

for attr in

652

self.runtime_expansions)

653

654

try:

655

command = self.checker_command % escaped_attrs

656

except TypeError as error:

657

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

658

' %s', self.checker_command, error)

659

return True # Try again later

720

660

self.current_checker_command = command

721

661

try:

722

662

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

725

665

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

726

666

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

727

667

# always replaced by /dev/null.)

728

# The exception is when not debugging but nevertheless

729

# running in the foreground; use the previously

730

# created wnull.

731

popen_args = {}

732

if (not self.server_settings["debug"]

733

and self.server_settings["foreground"]):

734

popen_args.update({"stdout": wnull,

735

"stderr": wnull })

736

668

self.checker = subprocess.Popen(command,

737

669

close_fds=True,

738

shell=True, cwd="/",

739

**popen_args)

740

except OSError as error:

741

logger.error("Failed to start subprocess",

742

exc_info=error)

743

return True

744

self.checker_callback_tag = (gobject.child_watch_add

745

(self.checker.pid,

746

self.checker_callback,

747

data=command))

748

# The checker may have completed before the gobject

749

# watch was added. Check for this.

750

try:

670

shell=True, cwd="/")

671

self.checker_callback_tag = (gobject.child_watch_add

672

(self.checker.pid,

673

self.checker_callback,

674

data=command))

675

# The checker may have completed before the gobject

676

# watch was added. Check for this.

751

677

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

678

if pid:

679

gobject.source_remove(self.checker_callback_tag)

680

self.checker_callback(pid, status, command)

752

681

except OSError as error:

753

if error.errno == errno.ECHILD:

754

# This should never happen

755

logger.error("Child process vanished",

756

exc_info=error)

757

return True

758

raise

759

if pid:

760

gobject.source_remove(self.checker_callback_tag)

761

self.checker_callback(pid, status, command)

682

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

683

error)

762

684

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

763

685

return True

764

686

771

693

return

772

694

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

773

695

try:

774

self.checker.terminate()

696

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

775

697

#time.sleep(0.5)

776

698

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

777

# self.checker.kill()

699

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

778

700

except OSError as error:

779

701

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

780

702

raise

797

719

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

798

720

if byte_arrays and signature != "ay":

799

721

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

800

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

722

" signature %r" % signature)

801

723

def decorator(func):

802

724

func._dbus_is_property = True

803

725

func._dbus_interface = dbus_interface

811

733

return decorator

812

734

813

735

814

def dbus_interface_annotations(dbus_interface):

815

"""Decorator for marking functions returning interface annotations

816

817

Usage:

818

819

@dbus_interface_annotations("org.example.Interface")

820

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

821

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

822

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

823

"false"}

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

return decorator

831

832

833

def dbus_annotations(annotations):

834

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

835

Usage:

836

837

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

838

access="r")

839

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

840

"org.freedesktop.DBus.Property."

841

"EmitsChangedSignal": "false"})

842

def Property_dbus_property(self):

843

return dbus.Boolean(False)

844

"""

845

def decorator(func):

846

func._dbus_annotations = annotations

847

return func

848

return decorator

849

850

851

736

class DBusPropertyException(dbus.exceptions.DBusException):

852

737

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

853

738

"""

876

761

"""

877

762

878

763

@staticmethod

879

def _is_dbus_thing(thing):

880

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

881

882

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

883

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

884

"""

885

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

886

False)

764

def _is_dbus_property(obj):

765

return getattr(obj, "_dbus_is_property", False)

887

766

888

def _get_all_dbus_things(self, thing):

767

def _get_all_dbus_properties(self):

889

768

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

890

769

"""

891

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

892

name),

893

athing.__get__(self))

770

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

894

771

for cls in self.__class__.__mro__

895

for name, athing in

896

inspect.getmembers(cls,

897

self._is_dbus_thing(thing)))

772

for name, prop in

773

inspect.getmembers(cls, self._is_dbus_property))

898

774

899

775

def _get_dbus_property(self, interface_name, property_name):

900

776

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

902

778

"""

903

779

for cls in self.__class__.__mro__:

904

780

for name, value in (inspect.getmembers

905

(cls,

906

self._is_dbus_thing("property"))):

781

(cls, self._is_dbus_property)):

907

782

if (value._dbus_name == property_name

908

783

and value._dbus_interface == interface_name):

909

784

return value.__get__(self)

937

812

# The byte_arrays option is not supported yet on

938

813

# signatures other than "ay".

939

814

if prop._dbus_signature != "ay":

940

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

941

"'ay' signature {0!r}"

942

.format(prop._dbus_signature))

943

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

944

for byte in value))

815

raise ValueError

816

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

817

for byte in value))

945

818

prop(value)

946

819

947

820

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

953

826

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

954

827

"""

955

828

properties = {}

956

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

829

for name, prop in self._get_all_dbus_properties():

957

830

if (interface_name

958

831

and interface_name != prop._dbus_interface):

959

832

# Interface non-empty but did not match

974

847

path_keyword='object_path',

975

848

connection_keyword='connection')

976

849

def Introspect(self, object_path, connection):

977

"""Overloading of standard D-Bus method.

978

979

Inserts property tags and interface annotation tags.

850

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

980

851

"""

981

852

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

982

853

connection)

989

860

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

990

861

return e

991

862

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

992

# Add property tags

993

863

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

994

864

for name, prop

995

in self._get_all_dbus_things("property")

865

in self._get_all_dbus_properties()

996

866

if prop._dbus_interface

997

867

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

998

868

if_tag.appendChild(tag)

999

# Add annotation tags

1000

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

1001

for tag in if_tag.getElementsByTagName(typ):

1002

annots = dict()

1003

for name, prop in (self.

1004

_get_all_dbus_things(typ)):

1005

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

1006

and prop._dbus_interface

1007

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

1008

annots.update(getattr

1009

(prop,

1010

"_dbus_annotations",

1011

{}))

1012

for name, value in annots.iteritems():

1013

ann_tag = document.createElement(

1014

"annotation")

1015

ann_tag.setAttribute("name", name)

1016

ann_tag.setAttribute("value", value)

1017

tag.appendChild(ann_tag)

1018

# Add interface annotation tags

1019

for annotation, value in dict(

1020

itertools.chain.from_iterable(

1021

annotations().iteritems()

1022

for name, annotations in

1023

self._get_all_dbus_things("interface")

1024

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

1025

)).iteritems():

1026

ann_tag = document.createElement("annotation")

1027

ann_tag.setAttribute("name", annotation)

1028

ann_tag.setAttribute("value", value)

1029

if_tag.appendChild(ann_tag)

1030

869

# Add the names to the return values for the

1031

870

# "org.freedesktop.DBus.Properties" methods

1032

871

if (if_tag.getAttribute("name")

1047

886

except (AttributeError, xml.dom.DOMException,

1048

887

xml.parsers.expat.ExpatError) as error:

1049

888

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

1050

exc_info=error)

889

error)

1051

890

return xmlstring

1052

891

1053

892

1054

def datetime_to_dbus(dt, variant_level=0):

893

def datetime_to_dbus (dt, variant_level=0):

1055

894

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

1056

895

if dt is None:

1057

896

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

1059

898

variant_level=variant_level)

1060

899

1061

900

1062

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1063

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

1064

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

1065

interface names according to the "alt_interface_names" mapping.

1066

Usage:

1067

1068

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

1069

"net.example.AlternateInterface"})

1070

class SampleDBusObject(dbus.service.Object):

1071

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

1072

def SampleDBusMethod():

1073

pass

1074

1075

The above "SampleDBusMethod" on "SampleDBusObject" will be

1076

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

1077

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

1078

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

1079

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

1080

1081

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

1082

(from DBusObjectWithProperties) and interfaces (from the

1083

dbus_interface_annotations decorator).

901

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

902

.__metaclass__):

903

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

904

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

1084

905

"""

1085

def wrapper(cls):

1086

for orig_interface_name, alt_interface_name in (

1087

alt_interface_names.iteritems()):

1088

attr = {}

1089

interface_names = set()

1090

# Go though all attributes of the class

1091

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

906

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

907

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

908

# methods, signals, or properties in them

909

for base in (b for b in bases

910

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

911

# Go though all attributes of the base class

912

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

1092

913

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

1093

914

# with the wrong interface name

1094

915

if (not hasattr(attribute, "_dbus_interface")

1095

916

or not attribute._dbus_interface

1096

.startswith(orig_interface_name)):

917

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

1097

918

continue

1098

919

# Create an alternate D-Bus interface name based on

1099

920

# the current name

1100

921

alt_interface = (attribute._dbus_interface

1101

.replace(orig_interface_name,

1102

alt_interface_name))

1103

interface_names.add(alt_interface)

922

.replace("se.recompile.Mandos",

923

"se.bsnet.fukt.Mandos"))

1104

924

# Is this a D-Bus signal?

1105

925

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

1106

# Extract the original non-method undecorated

1107

# function by black magic

926

# Extract the original non-method function by

927

# black magic

1108

928

nonmethod_func = (dict(

1109

929

zip(attribute.func_code.co_freevars,

1110

930

attribute.__closure__))["func"]

1121

941

nonmethod_func.func_name,

1122

942

nonmethod_func.func_defaults,

1123

943

nonmethod_func.func_closure)))

1124

# Copy annotations, if any

1125

try:

1126

new_function._dbus_annotations = (

1127

dict(attribute._dbus_annotations))

1128

except AttributeError:

1129

pass

1130

944

# Define a creator of a function to call both the

1131

# original and alternate functions, so both the

1132

# original and alternate signals gets sent when

1133

# the function is called

945

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

946

# signals gets sent when the function is called

1134

947

def fixscope(func1, func2):

1135

948

"""This function is a scope container to pass

1136

949

func1 and func2 to the "call_both" function

1143

956

return call_both

1144

957

# Create the "call_both" function and add it to

1145

958

# the class

1146

attr[attrname] = fixscope(attribute, new_function)

959

attr[attrname] = fixscope(attribute,

960

new_function)

1147

961

# Is this a D-Bus method?

1148

962

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

1149

963

# Create a new, but exactly alike, function

1160

974

attribute.func_name,

1161

975

attribute.func_defaults,

1162

976

attribute.func_closure)))

1163

# Copy annotations, if any

1164

try:

1165

attr[attrname]._dbus_annotations = (

1166

dict(attribute._dbus_annotations))

1167

except AttributeError:

1168

pass

1169

977

# Is this a D-Bus property?

1170

978

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

1171

979

# Create a new, but exactly alike, function

1185

993

attribute.func_name,

1186

994

attribute.func_defaults,

1187

995

attribute.func_closure)))

1188

# Copy annotations, if any

1189

try:

1190

attr[attrname]._dbus_annotations = (

1191

dict(attribute._dbus_annotations))

1192

except AttributeError:

1193

pass

1194

# Is this a D-Bus interface?

1195

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

1196

# Create a new, but exactly alike, function

1197

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

1198

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

1199

# to the class.

1200

attr[attrname] = (dbus_interface_annotations

1201

(alt_interface)

1202

(types.FunctionType

1203

(attribute.func_code,

1204

attribute.func_globals,

1205

attribute.func_name,

1206

attribute.func_defaults,

1207

attribute.func_closure)))

1208

if deprecate:

1209

# Deprecate all alternate interfaces

1210

iname="_AlternateDBusNames_interface_annotation{0}"

1211

for interface_name in interface_names:

1212

@dbus_interface_annotations(interface_name)

1213

def func(self):

1214

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

1215

"true" }

1216

# Find an unused name

1217

for aname in (iname.format(i)

1218

for i in itertools.count()):

1219

if aname not in attr:

1220

attr[aname] = func

1221

break

1222

if interface_names:

1223

# Replace the class with a new subclass of it with

1224

# methods, signals, etc. as created above.

1225

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

1226

(cls,), attr)

1227

return cls

1228

return wrapper

1229

1230

1231

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

1232

"se.bsnet.fukt.Mandos"})

996

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

997

998

1233

999

class ClientDBus(Client, DBusObjectWithProperties):

1234

1000

"""A Client class using D-Bus

1235

1001

1246

1012

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

1247

1013

self.bus = bus

1248

1014

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

1015

1016

self._approvals_pending = 0

1249

1017

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

1250

1018

# the D-Bus

1251

1019

client_object_name = unicode(self.name).translate(

1255

1023

("/clients/" + client_object_name))

1256

1024

DBusObjectWithProperties.__init__(self, self.bus,

1257

1025

self.dbus_object_path)

1258

1026

1259

1027

def notifychangeproperty(transform_func,

1260

1028

dbus_name, type_func=lambda x: x,

1261

1029

variant_level=1):

1284

1052

1285

1053

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

1286

1054

1055

1287

1056

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1288

1057

approvals_pending = notifychangeproperty(dbus.Boolean,

1289

1058

"ApprovalPending",

1296

1065

checker is not None)

1297

1066

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1298

1067

"LastCheckedOK")

1299

last_checker_status = notifychangeproperty(dbus.Int16,

1300

"LastCheckerStatus")

1301

1068

last_approval_request = notifychangeproperty(

1302

1069

datetime_to_dbus, "LastApprovalRequest")

1303

1070

approved_by_default = notifychangeproperty(dbus.Boolean,

1353

1120

*args, **kwargs)

1354

1121

1355

1122

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

1356

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

1123

old_checker = self.checker

1124

if self.checker is not None:

1125

old_checker_pid = self.checker.pid

1126

else:

1127

old_checker_pid = None

1357

1128

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

1358

1129

# Only if new checker process was started

1359

1130

if (self.checker is not None

1367

1138

return False

1368

1139

1369

1140

def approve(self, value=True):

1141

self.send_changedstate()

1370

1142

self.approved = value

1371

1143

gobject.timeout_add(timedelta_to_milliseconds

1372

1144

(self.approval_duration),

1373

1145

self._reset_approved)

1374

self.send_changedstate()

1146

1375

1147

1376

1148

## D-Bus methods, signals & properties

1377

1149

_interface = "se.recompile.Mandos.Client"

1378

1150

1379

## Interfaces

1380

1381

@dbus_interface_annotations(_interface)

1382

def _foo(self):

1383

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

1384

"false"}

1385

1386

1151

## Signals

1387

1152

1388

1153

# CheckerCompleted - signal

1424

1189

"D-Bus signal"

1425

1190

return self.need_approval()

1426

1191

1192

# NeRwequest - signal

1193

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

1194

def NewRequest(self, ip):

1195

"""D-Bus signal

1196

Is sent after a client request a password.

1197

"""

1198

pass

1199

1427

1200

## Methods

1428

1201

1429

1202

# Approve - method

1539

1312

return

1540

1313

return datetime_to_dbus(self.last_checked_ok)

1541

1314

1542

# LastCheckerStatus - property

1543

@dbus_service_property(_interface, signature="n",

1544

access="read")

1545

def LastCheckerStatus_dbus_property(self):

1546

return dbus.Int16(self.last_checker_status)

1547

1548

1315

# Expires - property

1549

1316

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

1550

1317

def Expires_dbus_property(self):

1561

1328

def Timeout_dbus_property(self, value=None):

1562

1329

if value is None: # get

1563

1330

return dbus.UInt64(self.timeout_milliseconds())

1564

old_timeout = self.timeout

1565

1331

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

1566

# Reschedule disabling

1567

if self.enabled:

1568

now = datetime.datetime.utcnow()

1569

self.expires += self.timeout - old_timeout

1570

if self.expires <= now:

1571

# The timeout has passed

1572

self.disable()

1573

else:

1574

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

1575

is None):

1576

return

1577

gobject.source_remove(self.disable_initiator_tag)

1578

self.disable_initiator_tag = (

1579

gobject.timeout_add(

1580

timedelta_to_milliseconds(self.expires - now),

1581

self.disable))

1332

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

1333

return

1334

# Reschedule timeout

1335

gobject.source_remove(self.disable_initiator_tag)

1336

self.disable_initiator_tag = None

1337

self.expires = None

1338

time_to_die = timedelta_to_milliseconds((self

1339

.last_checked_ok

1340

+ self.timeout)

1341

- datetime.datetime

1342

.utcnow())

1343

if time_to_die <= 0:

1344

# The timeout has passed

1345

self.disable()

1346

else:

1347

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

1348

+ datetime.timedelta(milliseconds =

1349

time_to_die))

1350

self.disable_initiator_tag = (gobject.timeout_add

1351

(time_to_die, self.disable))

1582

1352

1583

1353

# ExtendedTimeout - property

1584

1354

@dbus_service_property(_interface, signature="t",

1663

1433

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

1664

1434

1665

1435

1436

class ClientDBusTransitional(ClientDBus):

1437

__metaclass__ = AlternateDBusNamesMetaclass

1438

1439

1666

1440

class ClientHandler(socketserver.BaseRequestHandler, object):

1667

1441

"""A class to handle client connections.

1668

1442

1704

1478

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

1705

1479

try:

1706

1480

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

1707

raise RuntimeError(line)

1481

raise RuntimeError

1708

1482

except (ValueError, IndexError, RuntimeError) as error:

1709

1483

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

1710

1484

return

1736

1510

except KeyError:

1737

1511

return

1738

1512

1513

if self.server.use_dbus:

1514

# Emit D-Bus signal

1515

client.NewRequest(str(self.client_address))

1516

1739

1517

if client.approval_delay:

1740

1518

delay = client.approval_delay

1741

1519

client.approvals_pending += 1

1772

1550

#wait until timeout or approved

1773

1551

time = datetime.datetime.now()

1774

1552

client.changedstate.acquire()

1775

client.changedstate.wait(

1776

float(timedelta_to_milliseconds(delay)

1777

/ 1000))

1553

(client.changedstate.wait

1554

(float(client.timedelta_to_milliseconds(delay)

1555

/ 1000)))

1778

1556

client.changedstate.release()

1779

1557

time2 = datetime.datetime.now()

1780

1558

if (time2 - time) >= delay:

1796

1574

try:

1797

1575

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

1798

1576

except gnutls.errors.GNUTLSError as error:

1799

logger.warning("gnutls send failed",

1800

exc_info=error)

1577

logger.warning("gnutls send failed")

1801

1578

return

1802

1579

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

1803

1580

sent, len(client.secret)

1806

1583

1807

1584

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

1808

1585

# bump the timeout using extended_timeout

1809

client.bump_timeout(client.extended_timeout)

1586

client.checked_ok(client.extended_timeout)

1810

1587

if self.server.use_dbus:

1811

1588

# Emit D-Bus signal

1812

1589

client.GotSecret()

1817

1594

try:

1818

1595

session.bye()

1819

1596

except gnutls.errors.GNUTLSError as error:

1820

logger.warning("GnuTLS bye failed",

1821

exc_info=error)

1597

logger.warning("GnuTLS bye failed")

1822

1598

1823

1599

@staticmethod

1824

1600

def peer_certificate(session):

1889

1665

def sub_process_main(self, request, address):

1890

1666

try:

1891

1667

self.finish_request(request, address)

1892

except Exception:

1668

except:

1893

1669

self.handle_error(request, address)

1894

1670

self.close_request(request)

1895

1671

1896

1672

def process_request(self, request, address):

1897

1673

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

1898

1674

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

1899

args = (request, address))

1675

args = (request,

1676

address))

1900

1677

proc.start()

1901

1678

return proc

1902

1679

1917

1694

1918

1695

def add_pipe(self, parent_pipe, proc):

1919

1696

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

1920

raise NotImplementedError()

1697

raise NotImplementedError

1921

1698

1922

1699

1923

1700

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1930

1707

use_ipv6: Boolean; to use IPv6 or not

1931

1708

"""

1932

1709

def __init__(self, server_address, RequestHandlerClass,

1933

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

1934

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

1935

creating a new one with socket.socket().

1936

"""

1710

interface=None, use_ipv6=True):

1937

1711

self.interface = interface

1938

1712

if use_ipv6:

1939

1713

self.address_family = socket.AF_INET6

1940

if socketfd is not None:

1941

# Save the file descriptor

1942

self.socketfd = socketfd

1943

# Save the original socket.socket() function

1944

self.socket_socket = socket.socket

1945

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

1946

#

1947

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

1948

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

1949

# patching socket.socket.)

1950

#

1951

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

1952

@functools.wraps(socket.socket)

1953

def socket_wrapper(*args, **kwargs):

1954

# Restore original function so subsequent calls are

1955

# not affected.

1956

socket.socket = self.socket_socket

1957

del self.socket_socket

1958

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

1959

# saved file descriptor.

1960

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

1961

# Replace socket.socket() function with wrapper

1962

socket.socket = socket_wrapper

1963

# The socketserver.TCPServer.__init__ will call

1964

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

1965

# socket_wrapper(), if socketfd was set.

1966

1714

socketserver.TCPServer.__init__(self, server_address,

1967

1715

RequestHandlerClass)

1968

1969

1716

def server_bind(self):

1970

1717

"""This overrides the normal server_bind() function

1971

1718

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

1979

1726

try:

1980

1727

self.socket.setsockopt(socket.SOL_SOCKET,

1981

1728

SO_BINDTODEVICE,

1982

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

1729

str(self.interface

1730

+ '\0'))

1983

1731

except socket.error as error:

1984

if error.errno == errno.EPERM:

1985

logger.error("No permission to bind to"

1986

" interface %s", self.interface)

1987

elif error.errno == errno.ENOPROTOOPT:

1732

if error[0] == errno.EPERM:

1733

logger.error("No permission to"

1734

" bind to interface %s",

1735

self.interface)

1736

elif error[0] == errno.ENOPROTOOPT:

1988

1737

logger.error("SO_BINDTODEVICE not available;"

1989

1738

" cannot bind to interface %s",

1990

1739

self.interface)

1991

elif error.errno == errno.ENODEV:

1992

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

1993

" cannot bind", self.interface)

1994

1740

else:

1995

1741

raise

1996

1742

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

1999

1745

if self.address_family == socket.AF_INET6:

2000

1746

any_address = "::" # in6addr_any

2001

1747

else:

2002

any_address = "0.0.0.0" # INADDR_ANY

1748

any_address = socket.INADDR_ANY

2003

1749

self.server_address = (any_address,

2004

1750

self.server_address[1])

2005

1751

elif not self.server_address[1]:

2026

1772

"""

2027

1773

def __init__(self, server_address, RequestHandlerClass,

2028

1774

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

2029

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

1775

gnutls_priority=None, use_dbus=True):

2030

1776

self.enabled = False

2031

1777

self.clients = clients

2032

1778

if self.clients is None:

2036

1782

IPv6_TCPServer.__init__(self, server_address,

2037

1783

RequestHandlerClass,

2038

1784

interface = interface,

2039

use_ipv6 = use_ipv6,

2040

socketfd = socketfd)

1785

use_ipv6 = use_ipv6)

2041

1786

def server_activate(self):

2042

1787

if self.enabled:

2043

1788

return socketserver.TCPServer.server_activate(self)

2056

1801

2057

1802

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

2058

1803

proc = None, client_object=None):

1804

condition_names = {

1805

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

1806

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

1807

# blocking).

1808

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

1809

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

1810

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

1811

# broken, usually for pipes and

1812

# sockets).

1813

}

1814

conditions_string = ' | '.join(name

1815

for cond, name in

1816

condition_names.iteritems()

1817

if cond & condition)

2059

1818

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

2060

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

1819

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

2061

1820

# Wait for other process to exit

2062

1821

proc.join()

2063

1822

return False

2121

1880

return True

2122

1881

2123

1882

2124

def rfc3339_duration_to_delta(duration):

2125

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

2126

2127

>>> rfc3339_duration_to_delta("P7D")

2128

datetime.timedelta(7)

2129

>>> rfc3339_duration_to_delta("PT60S")

2130

datetime.timedelta(0, 60)

2131

>>> rfc3339_duration_to_delta("PT60M")

2132

datetime.timedelta(0, 3600)

2133

>>> rfc3339_duration_to_delta("PT24H")

2134

datetime.timedelta(1)

2135

>>> rfc3339_duration_to_delta("P1W")

2136

datetime.timedelta(7)

2137

>>> rfc3339_duration_to_delta("PT5M30S")

2138

datetime.timedelta(0, 330)

2139

>>> rfc3339_duration_to_delta("P1DT3M20S")

2140

datetime.timedelta(1, 200)

2141

"""

2142

2143

# Parsing an RFC 3339 duration with regular expressions is not

2144

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

2145

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

2146

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

2147

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

2148

# avoid excessive use of external libraries.

2149

2150

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

2151

Token = collections.namedtuple("Token",

2152

("regexp", # To match token; if

2153

# "value" is not None,

2154

# must have a "group"

2155

# containing digits

2156

"value", # datetime.timedelta or

2157

# None

2158

"followers")) # Tokens valid after

2159

# this token

2160

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

2161

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

2162

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

2163

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

2164

datetime.timedelta(seconds=1),

2165

frozenset((token_end,)))

2166

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

2167

datetime.timedelta(minutes=1),

2168

frozenset((token_second, token_end)))

2169

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

2170

datetime.timedelta(hours=1),

2171

frozenset((token_minute, token_end)))

2172

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

2173

None,

2174

frozenset((token_hour, token_minute,

2175

token_second)))

2176

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

2177

datetime.timedelta(days=1),

2178

frozenset((token_time, token_end)))

2179

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

2180

datetime.timedelta(weeks=4),

2181

frozenset((token_day, token_end)))

2182

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

2183

datetime.timedelta(weeks=52),

2184

frozenset((token_month, token_end)))

2185

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

2186

datetime.timedelta(weeks=1),

2187

frozenset((token_end,)))

2188

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

2189

frozenset((token_year, token_month,

2190

token_day, token_time,

2191

token_week))),

2192

# Define starting values

2193

value = datetime.timedelta() # Value so far

2194

found_token = None

2195

followers = frozenset(token_duration,) # Following valid tokens

2196

s = duration # String left to parse

2197

# Loop until end token is found

2198

while found_token is not token_end:

2199

# Search for any currently valid tokens

2200

for token in followers:

2201

match = token.regexp.match(s)

2202

if match is not None:

2203

# Token found

2204

if token.value is not None:

2205

# Value found, parse digits

2206

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

2207

# Add to value so far

2208

value += factor * token.value

2209

# Strip token from string

2210

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

2211

# Go to found token

2212

found_token = token

2213

# Set valid next tokens

2214

followers = found_token.followers

2215

break

2216

else:

2217

# No currently valid tokens were found

2218

raise ValueError("Invalid RFC 3339 duration")

2219

# End token found

2220

return value

2221

2222

2223

1883

def string_to_delta(interval):

2224

1884

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

2225

1885

2236

1896

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

2237

1897

datetime.timedelta(0, 330)

2238

1898

"""

2239

2240

try:

2241

return rfc3339_duration_to_delta(interval)

2242

except ValueError:

2243

pass

2244

2245

1899

timevalue = datetime.timedelta(0)

2246

1900

for s in interval.split():

2247

1901

try:

2258

1912

elif suffix == "w":

2259

1913

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

2260

1914

else:

2261

raise ValueError("Unknown suffix {0!r}"

2262

.format(suffix))

2263

except IndexError as e:

1915

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

1916

except (ValueError, IndexError) as e:

2264

1917

raise ValueError(*(e.args))

2265

1918

timevalue += delta

2266

1919

return timevalue

2279

1932

sys.exit()

2280

1933

if not noclose:

2281

1934

# Close all standard open file descriptors

2282

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

1935

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

2283

1936

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

2284

1937

raise OSError(errno.ENODEV,

2285

"{0} not a character device"

2286

.format(os.devnull))

1938

"%s not a character device"

1939

% os.path.devnull)

2287

1940

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

2288

1941

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

2289

1942

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

2298

1951

2299

1952

parser = argparse.ArgumentParser()

2300

1953

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

2301

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

1954

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

2302

1955

help="show version number and exit")

2303

1956

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

2304

1957

help="Bind to interface IF")

2310

1963

help="Run self-test")

2311

1964

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

2312

1965

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

2313

" to terminal", default=None)

1966

" to terminal")

2314

1967

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

2315

1968

help="Debug level for stdout output")

2316

1969

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

2323

1976

" files")

2324

1977

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

2325

1978

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

2326

" system bus interface", default=None)

1979

" system bus interface")

2327

1980

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

2328

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

2329

default=None)

1981

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

2330

1982

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

2331

1983

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

2332

" state", default=None)

2333

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

2334

help="Specify a file descriptor to a network"

2335

" socket to use instead of creating one")

1984

" state")

2336

1985

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

2337

1986

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

2338

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

2339

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

2340

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

2341

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

2342

default=None)

2343

1987

2344

1988

options = parser.parse_args()

2345

1989

2346

1990

if options.check:

2347

1991

import doctest

2348

fail_count, test_count = doctest.testmod()

2349

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

1992

doctest.testmod()

1993

sys.exit()

2350

1994

2351

1995

# Default values for config file for server-global settings

2352

1996

server_defaults = { "interface": "",

2354

1998

"port": "",

2355

1999

"debug": "False",

2356

2000

"priority":

2357

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

2001

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

2358

2002

"servicename": "Mandos",

2359

2003

"use_dbus": "True",

2360

2004

"use_ipv6": "True",

2361

2005

"debuglevel": "",

2362

2006

"restore": "True",

2363

"socket": "",

2364

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

2365

"foreground": "False",

2366

"zeroconf": "True",

2007

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

2367

2008

}

2368

2009

2369

2010

# Parse config file for server-global settings

2374

2015

# Convert the SafeConfigParser object to a dict

2375

2016

server_settings = server_config.defaults()

2376

2017

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

2377

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

2018

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

2378

2019

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

2379

2020

option)

2380

2021

if server_settings["port"]:

2381

2022

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

2382

2023

"port")

2383

if server_settings["socket"]:

2384

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

2385

"socket")

2386

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

2387

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

2388

# happen with a supplied network socket.

2389

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

2390

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

2391

["socket"])

2392

2024

del server_config

2393

2025

2394

2026

# Override the settings from the config file with command line

2396

2028

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

2397

2029

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

2398

2030

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

2399

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

2031

"statedir"):

2400

2032

value = getattr(options, option)

2401

2033

if value is not None:

2402

2034

server_settings[option] = value

2405

2037

for option in server_settings.keys():

2406

2038

if type(server_settings[option]) is str:

2407

2039

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

2408

# Force all boolean options to be boolean

2409

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

2410

"foreground", "zeroconf"):

2411

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

2412

# Debug implies foreground

2413

if server_settings["debug"]:

2414

server_settings["foreground"] = True

2415

2040

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

2416

2041

2417

2042

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

2418

2043

2419

if (not server_settings["zeroconf"] and

2420

not (server_settings["port"]

2421

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

2422

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

2423

" Zeroconf")

2424

2425

2044

# For convenience

2426

2045

debug = server_settings["debug"]

2427

2046

debuglevel = server_settings["debuglevel"]

2429

2048

use_ipv6 = server_settings["use_ipv6"]

2430

2049

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

2431

2050

stored_state_file)

2432

foreground = server_settings["foreground"]

2433

zeroconf = server_settings["zeroconf"]

2434

2051

2435

2052

if debug:

2436

initlogger(debug, logging.DEBUG)

2053

initlogger(logging.DEBUG)

2437

2054

else:

2438

2055

if not debuglevel:

2439

initlogger(debug)

2056

initlogger()

2440

2057

else:

2441

2058

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

2442

initlogger(debug, level)

2059

initlogger(level)

2443

2060

2444

2061

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

2445

2062

syslogger.setFormatter(logging.Formatter

2446

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

2447

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

2448

.format(server_settings

2449

["servicename"])))

2063

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

2064

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

2065

% server_settings["servicename"]))

2450

2066

2451

2067

# Parse config file with clients

2452

client_config = configparser.SafeConfigParser(Client

2453

.client_defaults)

2068

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

2069

"extended_timeout": "15m",

2070

"interval": "2m",

2071

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

2072

"host": "",

2073

"approval_delay": "0s",

2074

"approval_duration": "1s",

2075

}

2076

client_config = configparser.SafeConfigParser(client_defaults)

2454

2077

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

2455

2078

"clients.conf"))

2456

2079

2457

2080

global mandos_dbus_service

2458

2081

mandos_dbus_service = None

2459

2082

2460

socketfd = None

2461

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

2462

socketfd = server_settings["socket"]

2463

2083

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

2464

2084

server_settings["port"]),

2465

2085

ClientHandler,

2468

2088

use_ipv6=use_ipv6,

2469

2089

gnutls_priority=

2470

2090

server_settings["priority"],

2471

use_dbus=use_dbus,

2472

socketfd=socketfd)

2473

if not foreground:

2474

pidfilename = "/run/mandos.pid"

2475

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

2476

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

2477

pidfile = None

2091

use_dbus=use_dbus)

2092

if not debug:

2093

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

2478

2094

try:

2479

2095

pidfile = open(pidfilename, "w")

2480

except IOError as e:

2481

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

2482

exc_info=e)

2096

except IOError:

2097

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

2483

2098

2484

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

2099

try:

2100

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

2101

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

2102

except KeyError:

2485

2103

try:

2486

uid = pwd.getpwnam(name).pw_uid

2487

gid = pwd.getpwnam(name).pw_gid

2488

break

2104

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

2105

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

2489

2106

except KeyError:

2490

continue

2491

else:

2492

uid = 65534

2493

gid = 65534

2107

try:

2108

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

2109

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

2110

except KeyError:

2111

uid = 65534

2112

gid = 65534

2494

2113

try:

2495

2114

os.setgid(gid)

2496

2115

os.setuid(uid)

2497

2116

except OSError as error:

2498

if error.errno != errno.EPERM:

2499

raise

2117

if error[0] != errno.EPERM:

2118

raise error

2500

2119

2501

2120

if debug:

2502

2121

# Enable all possible GnuTLS debugging

2513

2132

.gnutls_global_set_log_function(debug_gnutls))

2514

2133

2515

2134

# Redirect stdin so all checkers get /dev/null

2516

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

2135

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

2517

2136

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

2518

2137

if null > 2:

2519

2138

os.close(null)

2139

else:

2140

# No console logging

2141

logger.removeHandler(console)

2520

2142

2521

2143

# Need to fork before connecting to D-Bus

2522

if not foreground:

2144

if not debug:

2523

2145

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

2524

2146

daemon()

2525

2147

2526

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

2527

# need to inform gobject that threads will be used.

2528

gobject.threads_init()

2529

2530

2148

global main_loop

2531

2149

# From the Avahi example code

2532

DBusGMainLoop(set_as_default=True)

2150

DBusGMainLoop(set_as_default=True )

2533

2151

main_loop = gobject.MainLoop()

2534

2152

bus = dbus.SystemBus()

2535

2153

# End of Avahi example code

2541

2159

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

2542

2160

do_not_queue=True))

2543

2161

except dbus.exceptions.NameExistsException as e:

2544

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

2162

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

2545

2163

use_dbus = False

2546

2164

server_settings["use_dbus"] = False

2547

2165

tcp_server.use_dbus = False

2548

if zeroconf:

2549

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2550

service = AvahiServiceToSyslog(name =

2551

server_settings["servicename"],

2552

servicetype = "_mandos._tcp",

2553

protocol = protocol, bus = bus)

2554

if server_settings["interface"]:

2555

service.interface = (if_nametoindex

2556

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

2166

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2167

service = AvahiServiceToSyslog(name =

2168

server_settings["servicename"],

2169

servicetype = "_mandos._tcp",

2170

protocol = protocol, bus = bus)

2171

if server_settings["interface"]:

2172

service.interface = (if_nametoindex

2173

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

2557

2174

2558

2175

global multiprocessing_manager

2559

2176

multiprocessing_manager = multiprocessing.Manager()

2560

2177

2561

2178

client_class = Client

2562

2179

if use_dbus:

2563

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

2564

2565

client_settings = Client.config_parser(client_config)

2180

client_class = functools.partial(ClientDBusTransitional,

2181

bus = bus)

2182

2183

special_settings = {

2184

# Some settings need to be accessd by special methods;

2185

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

2186

"approved_by_default":

2187

lambda section:

2188

client_config.getboolean(section, "approved_by_default"),

2189

"enabled":

2190

lambda section:

2191

client_config.getboolean(section, "enabled"),

2192

}

2193

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

2194

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

2195

# with exceptions for any special settings as defined above

2196

client_settings = dict((clientname,

2197

dict((setting,

2198

(value

2199

if setting not in special_settings

2200

else special_settings[setting]

2201

(clientname)))

2202

for setting, value in

2203

client_config.items(clientname)))

2204

for clientname in client_config.sections())

2205

2566

2206

old_client_settings = {}

2567

clients_data = {}

2568

2569

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

2570

global wnull

2571

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

2572

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

2573

# mode

2574

if debug or not foreground:

2575

wnull.close()

2207

clients_data = []

2576

2208

2577

2209

# Get client data and settings from last running state.

2578

2210

if server_settings["restore"]:

2582

2214

(stored_state))

2583

2215

os.remove(stored_state_path)

2584

2216

except IOError as e:

2585

if e.errno == errno.ENOENT:

2586

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

2587

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

2588

else:

2589

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

2590

exc_info=e)

2217

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

2218

.format(e))

2219

if e.errno != errno.ENOENT:

2591

2220

raise

2592

except EOFError as e:

2593

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

2594

"EOFError:", exc_info=e)

2595

2221

2596

2222

with PGPEngine() as pgp:

2597

for client_name, client in clients_data.iteritems():

2598

# Skip removed clients

2599

if client_name not in client_settings:

2600

continue

2223

for client in clients_data:

2224

client_name = client["name"]

2601

2225

2602

2226

# Decide which value to use after restoring saved state.

2603

2227

# We have three different values: Old config file,

2612

2236

if (name != "secret" and

2613

2237

value != old_client_settings[client_name]

2614

2238

[name]):

2615

client[name] = value

2239

setattr(client, name, value)

2616

2240

except KeyError:

2617

2241

pass

2618

2242

2619

2243

# Clients who has passed its expire date can still be

2620

# enabled if its last checker was successful. Clients

2621

# whose checker succeeded before we stored its state is

2622

# assumed to have successfully run all checkers during

2623

# downtime.

2244

# enabled if its last checker was sucessful. Clients

2245

# whose checker failed before we stored its state is

2246

# assumed to have failed all checkers during downtime.

2624

2247

if client["enabled"]:

2625

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

2626

if not client["last_checked_ok"]:

2627

logger.warning(

2628

"disabling client {0} - Client never "

2629

"performed a successful checker"

2630

.format(client_name))

2631

client["enabled"] = False

2632

elif client["last_checker_status"] != 0:

2633

logger.warning(

2634

"disabling client {0} - Client "

2635

"last checker failed with error code {1}"

2636

.format(client_name,

2637

client["last_checker_status"]))

2248

if client["expires"] <= (datetime.datetime

2249

.utcnow()):

2250

# Client has expired

2251

if client["last_checker_status"] != 0:

2638

2252

client["enabled"] = False

2639

2253

else:

2640

2254

client["expires"] = (datetime.datetime

2641

2255

.utcnow()

2642

2256

+ client["timeout"])

2643

logger.debug("Last checker succeeded,"

2644

" keeping {0} enabled"

2645

.format(client_name))

2257

2258

client["changedstate"] = (multiprocessing_manager

2259

.Condition

2260

(multiprocessing_manager

2261

.Lock()))

2262

if use_dbus:

2263

new_client = (ClientDBusTransitional.__new__

2264

(ClientDBusTransitional))

2265

tcp_server.clients[client_name] = new_client

2266

new_client.bus = bus

2267

for name, value in client.iteritems():

2268

setattr(new_client, name, value)

2269

client_object_name = unicode(client_name).translate(

2270

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

2271

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

2272

new_client.dbus_object_path = (dbus.ObjectPath

2273

("/clients/"

2274

+ client_object_name))

2275

DBusObjectWithProperties.__init__(new_client,

2276

new_client.bus,

2277

new_client

2278

.dbus_object_path)

2279

else:

2280

tcp_server.clients[client_name] = (Client.__new__

2281

(Client))

2282

for name, value in client.iteritems():

2283

setattr(tcp_server.clients[client_name],

2284

name, value)

2285

2646

2286

try:

2647

client["secret"] = (

2648

pgp.decrypt(client["encrypted_secret"],

2287

tcp_server.clients[client_name].secret = (

2288

pgp.decrypt(tcp_server.clients[client_name]

2289

.encrypted_secret,

2649

2290

client_settings[client_name]

2650

2291

["secret"]))

2651

2292

except PGPError:

2652

2293

# If decryption fails, we use secret from new settings

2653

2294

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

2654

2295

.format(client_name))

2655

client["secret"] = (

2296

tcp_server.clients[client_name].secret = (

2656

2297

client_settings[client_name]["secret"])

2657

2298

2658

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

2659

for client_name in (set(old_client_settings)

2660

- set(client_settings)):

2661

del clients_data[client_name]

2662

for client_name in (set(client_settings)

2663

- set(old_client_settings)):

2664

clients_data[client_name] = client_settings[client_name]

2665

2666

# Create all client objects

2667

for client_name, client in clients_data.iteritems():

2668

tcp_server.clients[client_name] = client_class(

2669

name = client_name, settings = client,

2670

server_settings = server_settings)

2299

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

2300

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

2301

del tcp_server.clients[clientname]

2302

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

2303

tcp_server.clients[clientname] = (client_class(name

2304

= clientname,

2305

config =

2306

client_settings

2307

[clientname]))

2671

2308

2672

2309

if not tcp_server.clients:

2673

2310

logger.warning("No clients defined")

2674

2675

if not foreground:

2676

if pidfile is not None:

2677

try:

2678

with pidfile:

2679

pid = os.getpid()

2680

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

2681

except IOError:

2682

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

2683

pidfilename, pid)

2684

del pidfile

2311

2312

if not debug:

2313

try:

2314

with pidfile:

2315

pid = os.getpid()

2316

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

2317

del pidfile

2318

except IOError:

2319

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

2320

pidfilename, pid)

2321

except NameError:

2322

# "pidfile" was never created

2323

pass

2685

2324

del pidfilename

2325

2326

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

2686

2327

2687

2328

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

2688

2329

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

2689

2330

2690

2331

if use_dbus:

2691

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

2692

"se.bsnet.fukt.Mandos"})

2693

class MandosDBusService(DBusObjectWithProperties):

2332

class MandosDBusService(dbus.service.Object):

2694

2333

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

2695

2334

def __init__(self):

2696

2335

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

2697

2336

_interface = "se.recompile.Mandos"

2698

2337

2699

@dbus_interface_annotations(_interface)

2700

def _foo(self):

2701

return { "org.freedesktop.DBus.Property"

2702

".EmitsChangedSignal":

2703

"false"}

2704

2705

2338

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

2706

2339

def ClientAdded(self, objpath):

2707

2340

"D-Bus signal"

2749

2382

2750

2383

del _interface

2751

2384

2752

mandos_dbus_service = MandosDBusService()

2385

class MandosDBusServiceTransitional(MandosDBusService):

2386

__metaclass__ = AlternateDBusNamesMetaclass

2387

mandos_dbus_service = MandosDBusServiceTransitional()

2753

2388

2754

2389

def cleanup():

2755

2390

"Cleanup function; run on exit"

2756

if zeroconf:

2757

service.cleanup()

2391

service.cleanup()

2758

2392

2759

2393

multiprocessing.active_children()

2760

wnull.close()

2761

2394

if not (tcp_server.clients or client_settings):

2762

2395

return

2763

2396

2764

2397

# Store client before exiting. Secrets are encrypted with key

2765

2398

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

2766

2399

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

2767

clients = {}

2400

clients = []

2768

2401

with PGPEngine() as pgp:

2769

2402

for client in tcp_server.clients.itervalues():

2770

2403

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

2772

2405

key)

2773

2406

client_dict = {}

2774

2407

2775

# A list of attributes that can not be pickled

2776

# + secret.

2777

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

2778

"checker", "server_settings"))

2408

# A list of attributes that will not be stored when

2409

# shutting down.

2410

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

2779

2411

for name, typ in (inspect.getmembers

2780

2412

(dbus.service.Object)):

2781

2413

exclude.add(name)

2786

2418

if attr not in exclude:

2787

2419

client_dict[attr] = getattr(client, attr)

2788

2420

2789

clients[client.name] = client_dict

2421

clients.append(client_dict)

2790

2422

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

2791

2423

2792

2424

try:

2793

with (tempfile.NamedTemporaryFile

2794

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

2795

dir=os.path.dirname(stored_state_path),

2796

delete=False)) as stored_state:

2425

with os.fdopen(os.open(stored_state_path,

2426

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

2427

0600), "wb") as stored_state:

2797

2428

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

2798

tempname=stored_state.name

2799

os.rename(tempname, stored_state_path)

2800

2429

except (IOError, OSError) as e:

2801

if not debug:

2802

try:

2803

os.remove(tempname)

2804

except NameError:

2805

pass

2806

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

2807

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

2808

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

2809

else:

2810

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

2811

exc_info=e)

2430

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

2431

.format(e))

2432

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

2812

2433

raise

2813

2434

2814

2435

# Delete all clients, and settings from config

2839

2460

tcp_server.server_activate()

2840

2461

2841

2462

# Find out what port we got

2842

if zeroconf:

2843

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

2463

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

2844

2464

if use_ipv6:

2845

2465

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

2846

" flowinfo %d, scope_id %d",

2847

*tcp_server.socket.getsockname())

2466

" flowinfo %d, scope_id %d"

2467

% tcp_server.socket.getsockname())

2848

2468

else: # IPv4

2849

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

2850

*tcp_server.socket.getsockname())

2469

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

2470

% tcp_server.socket.getsockname())

2851

2471

2852

2472

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

2853

2473

2854

2474

try:

2855

if zeroconf:

2856

# From the Avahi example code

2857

try:

2858

service.activate()

2859

except dbus.exceptions.DBusException as error:

2860

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

2861

cleanup()

2862

sys.exit(1)

2863

# End of Avahi example code

2475

# From the Avahi example code

2476

try:

2477

service.activate()

2478

except dbus.exceptions.DBusException as error:

2479

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

2480

cleanup()

2481

sys.exit(1)

2482

# End of Avahi example code

2864

2483

2865

2484

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

2866

2485

lambda *args, **kwargs:

2870

2489

logger.debug("Starting main loop")

2871

2490

main_loop.run()

2872

2491

except AvahiError as error:

2873

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

2492

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

2874

2493

cleanup()

2875

2494

sys.exit(1)

2876

2495

except KeyboardInterrupt:

2881

2500

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

2882

2501

cleanup()

2883

2502

2503

2884

2504

if __name__ == '__main__':

2885

2505

main()