/mandos/trunk : revision 732

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

2

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

3

#

4

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

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

37

39

import SocketServer as socketserver

38

40

import socket

39

41

import argparse

65

67

import types

66

68

import binascii

67

69

import tempfile

70

import itertools

71

import collections

68

72

69

73

import dbus

70

74

import dbus.service

75

79

import ctypes.util

76

80

import xml.dom.minidom

77

81

import inspect

78

import GnuPGInterface

79

82

80

83

try:

81

84

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

85

88

except ImportError:

86

89

SO_BINDTODEVICE = None

87

90

88

version = "1.5.2"

91

if sys.version_info.major == 2:

92

str = unicode

93

94

version = "1.6.8"

89

95

stored_state_file = "clients.pickle"

90

96

91

97

logger = logging.getLogger()

92

syslogger = (logging.handlers.SysLogHandler

93

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

94

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

98

syslogger = None

95

99

96

100

try:

97

101

if_nametoindex = (ctypes.cdll.LoadLibrary

103

107

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

104

108

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

105

109

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

106

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

107

interface))

108

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

109

ifreq[16:20])[0]

110

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

111

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

110

112

return interface_index

111

113

112

114

113

115

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

114

116

"""init logger and add loglevel"""

115

117

118

global syslogger

119

syslogger = (logging.handlers.SysLogHandler

120

(facility =

121

logging.handlers.SysLogHandler.LOG_DAEMON,

122

address = "/dev/log"))

116

123

syslogger.setFormatter(logging.Formatter

117

124

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

118

125

' %(message)s'))

136

143

class PGPEngine(object):

137

144

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

138

145

def __init__(self):

139

self.gnupg = GnuPGInterface.GnuPG()

140

146

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

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',

146

'--no-use-agent'])

147

self.gnupgargs = ['--batch',

148

'--home', self.tempdir,

149

'--force-mdc',

150

'--quiet',

151

'--no-use-agent']

147

152

148

153

def __enter__(self):

149

154

return self

150

155

151

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

156

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

152

157

self._cleanup()

153

158

return False

154

159

171

176

def password_encode(self, password):

172

177

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

173

178

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

174

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

179

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

180

if len(encoded) > 2048:

181

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

182

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

183

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

184

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

185

return encoded

175

186

176

187

def encrypt(self, data, password):

177

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

178

with open(os.devnull) as devnull:

179

try:

180

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

181

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

182

attach_fhs={'stderr': devnull})

183

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

184

f.write(data)

185

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

186

ciphertext = f.read()

187

proc.wait()

188

except IOError as e:

189

raise PGPError(e)

190

self.gnupg.passphrase = None

188

passphrase = self.password_encode(password)

189

with tempfile.NamedTemporaryFile(dir=self.tempdir

190

) as passfile:

191

passfile.write(passphrase)

192

passfile.flush()

193

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

194

'--passphrase-file',

195

passfile.name]

196

+ self.gnupgargs,

197

stdin = subprocess.PIPE,

198

stdout = subprocess.PIPE,

199

stderr = subprocess.PIPE)

200

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

201

if proc.returncode != 0:

202

raise PGPError(err)

191

203

return ciphertext

192

204

193

205

def decrypt(self, data, password):

194

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

195

with open(os.devnull) as devnull:

196

try:

197

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

198

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

199

attach_fhs={'stderr': devnull})

200

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

201

f.write(data)

202

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

203

decrypted_plaintext = f.read()

204

proc.wait()

205

except IOError as e:

206

raise PGPError(e)

207

self.gnupg.passphrase = None

206

passphrase = self.password_encode(password)

207

with tempfile.NamedTemporaryFile(dir = self.tempdir

208

) as passfile:

209

passfile.write(passphrase)

210

passfile.flush()

211

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

212

'--passphrase-file',

213

passfile.name]

214

+ self.gnupgargs,

215

stdin = subprocess.PIPE,

216

stdout = subprocess.PIPE,

217

stderr = subprocess.PIPE)

218

decrypted_plaintext, err = proc.communicate(input

219

= data)

220

if proc.returncode != 0:

221

raise PGPError(err)

208

222

return decrypted_plaintext

209

223

210

224

211

212

225

class AvahiError(Exception):

213

226

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

214

227

self.value = value

215

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

216

def __unicode__(self):

217

return unicode(repr(self.value))

228

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

229

**kwargs)

218

230

219

231

class AvahiServiceError(AvahiError):

220

232

pass

231

243

Used to optionally bind to the specified interface.

232

244

name: string; Example: 'Mandos'

233

245

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

234

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

246

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

235

247

port: integer; what port to announce

236

248

TXT: list of strings; TXT record for the service

237

249

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

243

255

server: D-Bus Server

244

256

bus: dbus.SystemBus()

245

257

"""

258

246

259

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

247

260

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

248

261

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

261

274

self.server = None

262

275

self.bus = bus

263

276

self.entry_group_state_changed_match = None

277

264

278

def rename(self):

265

279

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

266

280

if self.rename_count >= self.max_renames:

268

282

" after %i retries, exiting.",

269

283

self.rename_count)

270

284

raise AvahiServiceError("Too many renames")

271

self.name = unicode(self.server

272

.GetAlternativeServiceName(self.name))

285

self.name = str(self.server

286

.GetAlternativeServiceName(self.name))

273

287

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

274

288

self.name)

275

289

self.remove()

276

290

try:

277

291

self.add()

278

292

except dbus.exceptions.DBusException as error:

279

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

293

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

280

294

self.cleanup()

281

295

os._exit(1)

282

296

self.rename_count += 1

297

283

298

def remove(self):

284

299

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

285

300

if self.entry_group_state_changed_match is not None:

287

302

self.entry_group_state_changed_match = None

288

303

if self.group is not None:

289

304

self.group.Reset()

305

290

306

def add(self):

291

307

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

292

308

self.remove()

309

325

dbus.UInt16(self.port),

310

326

avahi.string_array_to_txt_array(self.TXT))

311

327

self.group.Commit()

328

312

329

def entry_group_state_changed(self, state, error):

313

330

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

314

331

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

320

337

self.rename()

321

338

elif state == avahi.ENTRY_GROUP_FAILURE:

322

339

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

323

unicode(error))

324

raise AvahiGroupError("State changed: %s"

325

% unicode(error))

340

str(error))

341

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

342

.format(error))

343

326

344

def cleanup(self):

327

345

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

328

346

if self.group is not None:

333

351

pass

334

352

self.group = None

335

353

self.remove()

354

336

355

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

337

356

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

338

357

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

357

376

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

358

377

else:

359

378

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

379

360

380

def activate(self):

361

381

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

362

382

if self.server is None:

369

389

self.server_state_changed)

370

390

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

371

391

392

372

393

class AvahiServiceToSyslog(AvahiService):

373

394

def rename(self):

374

395

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

375

396

ret = AvahiService.rename(self)

376

397

syslogger.setFormatter(logging.Formatter

377

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

378

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

379

% self.name))

398

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

399

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

400

.format(self.name)))

380

401

return ret

381

402

382

def timedelta_to_milliseconds(td):

383

"Convert a datetime.timedelta() to milliseconds"

384

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

385

+ (td.seconds * 1000)

386

+ (td.microseconds // 1000))

387

403

388

404

class Client(object):

389

405

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

390

406

415

431

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

416

432

last_checker_status: integer between 0 and 255 reflecting exit

417

433

status of last checker. -1 reflects crashed

418

checker, or None.

434

checker, -2 means no checker completed yet.

419

435

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

420

436

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

421

437

D-Bus identifiers

426

442

runtime_expansions: Allowed attributes for runtime expansion.

427

443

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

428

444

disabled, or None

445

server_settings: The server_settings dict from main()

429

446

"""

430

447

431

448

runtime_expansions = ("approval_delay", "approval_duration",

432

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

433

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

449

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

450

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

451

"last_approval_request", "last_checked_ok",

434

452

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

435

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

436

"extended_timeout": "15m",

437

"interval": "2m",

453

client_defaults = { "timeout": "PT5M",

454

"extended_timeout": "PT15M",

455

"interval": "PT2M",

438

456

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

439

457

"host": "",

440

"approval_delay": "0s",

441

"approval_duration": "1s",

458

"approval_delay": "PT0S",

459

"approval_duration": "PT1S",

442

460

"approved_by_default": "True",

443

461

"enabled": "True",

444

462

}

445

463

446

def timeout_milliseconds(self):

447

"Return the 'timeout' attribute in milliseconds"

448

return timedelta_to_milliseconds(self.timeout)

449

450

def extended_timeout_milliseconds(self):

451

"Return the 'extended_timeout' attribute in milliseconds"

452

return timedelta_to_milliseconds(self.extended_timeout)

453

454

def interval_milliseconds(self):

455

"Return the 'interval' attribute in milliseconds"

456

return timedelta_to_milliseconds(self.interval)

457

458

def approval_delay_milliseconds(self):

459

return timedelta_to_milliseconds(self.approval_delay)

460

461

464

@staticmethod

462

465

def config_parser(config):

463

466

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

488

491

"rb") as secfile:

489

492

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

490

493

else:

491

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

492

% section)

494

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

495

.format(section))

493

496

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

494

497

client["extended_timeout"] = string_to_delta(

495

498

section["extended_timeout"])

501

504

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

502

505

client["last_approval_request"] = None

503

506

client["last_checked_ok"] = None

504

client["last_checker_status"] = None

507

client["last_checker_status"] = -2

505

508

506

509

return settings

507

508

509

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

510

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

511

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

512

attribute."""

510

511

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

513

512

self.name = name

513

if server_settings is None:

514

server_settings = {}

515

self.server_settings = server_settings

514

516

# adding all client settings

515

for setting, value in settings.iteritems():

517

for setting, value in settings.items():

516

518

setattr(self, setting, value)

517

519

518

520

if self.enabled:

524

526

else:

525

527

self.last_enabled = None

526

528

self.expires = None

527

529

528

530

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

529

531

# Uppercase and remove spaces from fingerprint for later

530

532

# comparison purposes with return value from the fingerprint()

532

534

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

533

535

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

534

536

datetime.datetime.utcnow())

535

537

536

538

# attributes specific for this server instance

537

539

self.checker = None

538

540

self.checker_initiator_tag = None

566

568

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

567

569

# Already enabled

568

570

return

569

self.send_changedstate()

570

571

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

571

572

self.enabled = True

572

573

self.last_enabled = datetime.datetime.utcnow()

573

574

self.init_checker()

575

self.send_changedstate()

574

576

575

577

def disable(self, quiet=True):

576

578

"""Disable this client."""

577

579

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

578

580

return False

579

581

if not quiet:

580

self.send_changedstate()

581

if not quiet:

582

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

583

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

583

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

584

gobject.source_remove(self.disable_initiator_tag)

585

self.disable_initiator_tag = None

586

self.expires = None

587

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

587

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

588

gobject.source_remove(self.checker_initiator_tag)

589

self.checker_initiator_tag = None

590

self.stop_checker()

591

self.enabled = False

592

if not quiet:

593

self.send_changedstate()

592

594

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

593

595

return False

594

596

598

600

def init_checker(self):

599

601

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

600

602

# and every interval from then on.

603

if self.checker_initiator_tag is not None:

604

gobject.source_remove(self.checker_initiator_tag)

601

605

self.checker_initiator_tag = (gobject.timeout_add

602

(self.interval_milliseconds(),

606

(int(self.interval

607

.total_seconds() * 1000),

603

608

self.start_checker))

604

609

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

610

if self.disable_initiator_tag is not None:

611

gobject.source_remove(self.disable_initiator_tag)

605

612

self.disable_initiator_tag = (gobject.timeout_add

606

(self.timeout_milliseconds(),

607

self.disable))

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

608

616

# Also start a new checker *right now*.

609

617

self.start_checker()

610

618

626

634

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

627

635

vars(self))

628

636

629

def checked_ok(self, timeout=None):

630

"""Bump up the timeout for this client.

631

632

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

633

alive and well.

634

"""

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

635

645

if timeout is None:

636

646

timeout = self.timeout

637

self.last_checked_ok = datetime.datetime.utcnow()

638

647

if self.disable_initiator_tag is not None:

639

648

gobject.source_remove(self.disable_initiator_tag)

649

self.disable_initiator_tag = None

640

650

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

641

651

self.disable_initiator_tag = (gobject.timeout_add

642

(timedelta_to_milliseconds

643

(timeout), self.disable))

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

644

654

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

645

655

646

656

def need_approval(self):

652

662

If a checker already exists, leave it running and do

653

663

nothing."""

654

664

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

655

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

656

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

657

# client would inevitably timeout, since no checker would get

658

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

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

659

669

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

660

670

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

661

671

# should be.

663

673

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

664

674

try:

665

675

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

666

except (AttributeError, OSError) as error:

667

if (isinstance(error, OSError)

668

and error.errno != errno.ECHILD):

669

raise error

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

670

681

else:

671

682

if pid:

672

683

logger.warning("Checker was a zombie")

675

686

self.current_checker_command)

676

687

# Start a new checker if needed

677

688

if self.checker is None:

689

# Escape attributes for the shell

690

escaped_attrs = { attr:

691

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

692

for attr in self.runtime_expansions }

678

693

try:

679

# In case checker_command has exactly one % operator

680

command = self.checker_command % self.host

681

except TypeError:

682

# Escape attributes for the shell

683

escaped_attrs = dict(

684

(attr,

685

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

686

errors=

687

'replace')))

688

for attr in

689

self.runtime_expansions)

690

691

try:

692

command = self.checker_command % escaped_attrs

693

except TypeError as error:

694

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

695

' %s', self.checker_command, error)

696

return True # Try again later

694

command = self.checker_command % escaped_attrs

695

except TypeError as error:

696

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

697

self.checker_command, exc_info=error)

698

return True # Try again later

697

699

self.current_checker_command = command

698

700

try:

699

701

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

702

704

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

703

705

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

704

706

# always replaced by /dev/null.)

707

# The exception is when not debugging but nevertheless

708

# running in the foreground; use the previously

709

# created wnull.

710

popen_args = {}

711

if (not self.server_settings["debug"]

712

and self.server_settings["foreground"]):

713

popen_args.update({"stdout": wnull,

714

"stderr": wnull })

705

715

self.checker = subprocess.Popen(command,

706

716

close_fds=True,

707

shell=True, cwd="/")

708

self.checker_callback_tag = (gobject.child_watch_add

709

(self.checker.pid,

710

self.checker_callback,

711

data=command))

712

# The checker may have completed before the gobject

713

# watch was added. Check for this.

717

shell=True, cwd="/",

718

**popen_args)

719

except OSError as error:

720

logger.error("Failed to start subprocess",

721

exc_info=error)

722

return True

723

self.checker_callback_tag = (gobject.child_watch_add

724

(self.checker.pid,

725

self.checker_callback,

726

data=command))

727

# The checker may have completed before the gobject

728

# watch was added. Check for this.

729

try:

714

730

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

715

if pid:

716

gobject.source_remove(self.checker_callback_tag)

717

self.checker_callback(pid, status, command)

718

731

except OSError as error:

719

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

720

error)

732

if error.errno == errno.ECHILD:

733

# This should never happen

734

logger.error("Child process vanished",

735

exc_info=error)

736

return True

737

raise

738

if pid:

739

gobject.source_remove(self.checker_callback_tag)

740

self.checker_callback(pid, status, command)

721

741

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

722

742

return True

723

743

730

750

return

731

751

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

732

752

try:

733

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

753

self.checker.terminate()

734

754

#time.sleep(0.5)

735

755

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

736

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

756

# self.checker.kill()

737

757

except OSError as error:

738

758

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

739

759

raise

756

776

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

757

777

if byte_arrays and signature != "ay":

758

778

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

759

" signature %r" % signature)

779

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

760

780

def decorator(func):

761

781

func._dbus_is_property = True

762

782

func._dbus_interface = dbus_interface

770

790

return decorator

771

791

772

792

793

def dbus_interface_annotations(dbus_interface):

794

"""Decorator for marking functions returning interface annotations

795

796

Usage:

797

798

@dbus_interface_annotations("org.example.Interface")

799

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

800

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

801

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

802

"false"}

803

"""

804

def decorator(func):

805

func._dbus_is_interface = True

806

func._dbus_interface = dbus_interface

807

func._dbus_name = dbus_interface

808

return func

809

return decorator

810

811

812

def dbus_annotations(annotations):

813

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

814

Usage:

815

816

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

817

"org.freedesktop.DBus.Property."

818

"EmitsChangedSignal": "false"})

819

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

820

access="r")

821

def Property_dbus_property(self):

822

return dbus.Boolean(False)

823

"""

824

def decorator(func):

825

func._dbus_annotations = annotations

826

return func

827

return decorator

828

829

773

830

class DBusPropertyException(dbus.exceptions.DBusException):

774

831

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

775

832

"""

776

def __unicode__(self):

777

return unicode(str(self))

778

833

pass

779

834

780

835

class DBusPropertyAccessException(DBusPropertyException):

781

836

"""A property's access permissions disallows an operation.

798

853

"""

799

854

800

855

@staticmethod

801

def _is_dbus_property(obj):

802

return getattr(obj, "_dbus_is_property", False)

856

def _is_dbus_thing(thing):

857

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

858

859

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

860

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

861

"""

862

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

863

False)

803

864

804

def _get_all_dbus_properties(self):

865

def _get_all_dbus_things(self, thing):

805

866

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

806

867

"""

807

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

868

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

869

name),

870

athing.__get__(self))

808

871

for cls in self.__class__.__mro__

809

for name, prop in

810

inspect.getmembers(cls, self._is_dbus_property))

872

for name, athing in

873

inspect.getmembers(cls,

874

self._is_dbus_thing(thing)))

811

875

812

876

def _get_dbus_property(self, interface_name, property_name):

813

877

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

815

879

"""

816

880

for cls in self.__class__.__mro__:

817

881

for name, value in (inspect.getmembers

818

(cls, self._is_dbus_property)):

882

(cls,

883

self._is_dbus_thing("property"))):

819

884

if (value._dbus_name == property_name

820

885

and value._dbus_interface == interface_name):

821

886

return value.__get__(self)

849

914

# The byte_arrays option is not supported yet on

850

915

# signatures other than "ay".

851

916

if prop._dbus_signature != "ay":

852

raise ValueError

917

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

918

"'ay' signature {!r}"

919

.format(prop._dbus_signature))

853

920

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

854

921

for byte in value))

855

922

prop(value)

863

930

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

864

931

"""

865

932

properties = {}

866

for name, prop in self._get_all_dbus_properties():

933

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

867

934

if (interface_name

868

935

and interface_name != prop._dbus_interface):

869

936

# Interface non-empty but did not match

879

946

value.variant_level+1)

880

947

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

881

948

949

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

950

def PropertiesChanged(self, interface_name, changed_properties,

951

invalidated_properties):

952

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

953

standard.

954

"""

955

pass

956

882

957

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

883

958

out_signature="s",

884

959

path_keyword='object_path',

885

960

connection_keyword='connection')

886

961

def Introspect(self, object_path, connection):

887

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

962

"""Overloading of standard D-Bus method.

963

964

Inserts property tags and interface annotation tags.

888

965

"""

889

966

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

890

967

connection)

897

974

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

898

975

return e

899

976

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

977

# Add property tags

900

978

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

901

979

for name, prop

902

in self._get_all_dbus_properties()

980

in self._get_all_dbus_things("property")

903

981

if prop._dbus_interface

904

982

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

905

983

if_tag.appendChild(tag)

984

# Add annotation tags

985

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

986

for tag in if_tag.getElementsByTagName(typ):

987

annots = dict()

988

for name, prop in (self.

989

_get_all_dbus_things(typ)):

990

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

991

and prop._dbus_interface

992

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

993

annots.update(getattr

994

(prop,

995

"_dbus_annotations",

996

{}))

997

for name, value in annots.items():

998

ann_tag = document.createElement(

999

"annotation")

1000

ann_tag.setAttribute("name", name)

1001

ann_tag.setAttribute("value", value)

1002

tag.appendChild(ann_tag)

1003

# Add interface annotation tags

1004

for annotation, value in dict(

1005

itertools.chain.from_iterable(

1006

annotations().items()

1007

for name, annotations in

1008

self._get_all_dbus_things("interface")

1009

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

1010

)).items():

1011

ann_tag = document.createElement("annotation")

1012

ann_tag.setAttribute("name", annotation)

1013

ann_tag.setAttribute("value", value)

1014

if_tag.appendChild(ann_tag)

906

1015

# Add the names to the return values for the

907

1016

# "org.freedesktop.DBus.Properties" methods

908

1017

if (if_tag.getAttribute("name")

923

1032

except (AttributeError, xml.dom.DOMException,

924

1033

xml.parsers.expat.ExpatError) as error:

925

1034

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

926

error)

1035

exc_info=error)

927

1036

return xmlstring

928

1037

929

1038

930

def datetime_to_dbus (dt, variant_level=0):

1039

def datetime_to_dbus(dt, variant_level=0):

931

1040

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

932

1041

if dt is None:

933

1042

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

935

1044

variant_level=variant_level)

936

1045

937

1046

938

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

939

.__metaclass__):

940

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

941

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

1047

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1048

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

1049

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

1050

interface names according to the "alt_interface_names" mapping.

1051

Usage:

1052

1053

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

1054

"net.example.AlternateInterface"})

1055

class SampleDBusObject(dbus.service.Object):

1056

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

1057

def SampleDBusMethod():

1058

pass

1059

1060

The above "SampleDBusMethod" on "SampleDBusObject" will be

1061

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

1062

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

1063

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

1064

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

1065

1066

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

1067

(from DBusObjectWithProperties) and interfaces (from the

1068

dbus_interface_annotations decorator).

942

1069

"""

943

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

944

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

945

# methods, signals, or properties in them

946

for base in (b for b in bases

947

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

948

# Go though all attributes of the base class

949

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

1070

def wrapper(cls):

1071

for orig_interface_name, alt_interface_name in (

1072

alt_interface_names.items()):

1073

attr = {}

1074

interface_names = set()

1075

# Go though all attributes of the class

1076

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

950

1077

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

951

1078

# with the wrong interface name

952

1079

if (not hasattr(attribute, "_dbus_interface")

953

1080

or not attribute._dbus_interface

954

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

1081

.startswith(orig_interface_name)):

955

1082

continue

956

1083

# Create an alternate D-Bus interface name based on

957

1084

# the current name

958

1085

alt_interface = (attribute._dbus_interface

959

.replace("se.recompile.Mandos",

960

"se.bsnet.fukt.Mandos"))

1086

.replace(orig_interface_name,

1087

alt_interface_name))

1088

interface_names.add(alt_interface)

961

1089

# Is this a D-Bus signal?

962

1090

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

963

# Extract the original non-method function by

964

# black magic

1091

# Extract the original non-method undecorated

1092

# function by black magic

965

1093

nonmethod_func = (dict(

966

1094

zip(attribute.func_code.co_freevars,

967

1095

attribute.__closure__))["func"]

978

1106

nonmethod_func.func_name,

979

1107

nonmethod_func.func_defaults,

980

1108

nonmethod_func.func_closure)))

1109

# Copy annotations, if any

1110

try:

1111

new_function._dbus_annotations = (

1112

dict(attribute._dbus_annotations))

1113

except AttributeError:

1114

pass

981

1115

# Define a creator of a function to call both the

982

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

983

# signals gets sent when the function is called

1116

# original and alternate functions, so both the

1117

# original and alternate signals gets sent when

1118

# the function is called

984

1119

def fixscope(func1, func2):

985

1120

"""This function is a scope container to pass

986

1121

func1 and func2 to the "call_both" function

993

1128

return call_both

994

1129

# Create the "call_both" function and add it to

995

1130

# the class

996

attr[attrname] = fixscope(attribute,

997

new_function)

1131

attr[attrname] = fixscope(attribute, new_function)

998

1132

# Is this a D-Bus method?

999

1133

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

1000

1134

# Create a new, but exactly alike, function

1011

1145

attribute.func_name,

1012

1146

attribute.func_defaults,

1013

1147

attribute.func_closure)))

1148

# Copy annotations, if any

1149

try:

1150

attr[attrname]._dbus_annotations = (

1151

dict(attribute._dbus_annotations))

1152

except AttributeError:

1153

pass

1014

1154

# Is this a D-Bus property?

1015

1155

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

1016

1156

# Create a new, but exactly alike, function

1030

1170

attribute.func_name,

1031

1171

attribute.func_defaults,

1032

1172

attribute.func_closure)))

1033

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

1034

1035

1173

# Copy annotations, if any

1174

try:

1175

attr[attrname]._dbus_annotations = (

1176

dict(attribute._dbus_annotations))

1177

except AttributeError:

1178

pass

1179

# Is this a D-Bus interface?

1180

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

1181

# Create a new, but exactly alike, function

1182

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

1183

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

1184

# to the class.

1185

attr[attrname] = (dbus_interface_annotations

1186

(alt_interface)

1187

(types.FunctionType

1188

(attribute.func_code,

1189

attribute.func_globals,

1190

attribute.func_name,

1191

attribute.func_defaults,

1192

attribute.func_closure)))

1193

if deprecate:

1194

# Deprecate all alternate interfaces

1195

iname="_AlternateDBusNames_interface_annotation{}"

1196

for interface_name in interface_names:

1197

@dbus_interface_annotations(interface_name)

1198

def func(self):

1199

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

1200

"true" }

1201

# Find an unused name

1202

for aname in (iname.format(i)

1203

for i in itertools.count()):

1204

if aname not in attr:

1205

attr[aname] = func

1206

break

1207

if interface_names:

1208

# Replace the class with a new subclass of it with

1209

# methods, signals, etc. as created above.

1210

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

1211

(cls,), attr)

1212

return cls

1213

return wrapper

1214

1215

1216

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

1217

"se.bsnet.fukt.Mandos"})

1036

1218

class ClientDBus(Client, DBusObjectWithProperties):

1037

1219

"""A Client class using D-Bus

1038

1220

1044

1226

runtime_expansions = (Client.runtime_expansions

1045

1227

+ ("dbus_object_path",))

1046

1228

1229

_interface = "se.recompile.Mandos.Client"

1230

1047

1231

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

1048

1232

1049

1233

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

1051

1235

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

1052

1236

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

1053

1237

# the D-Bus

1054

client_object_name = unicode(self.name).translate(

1238

client_object_name = str(self.name).translate(

1055

1239

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

1056

1240

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

1057

1241

self.dbus_object_path = (dbus.ObjectPath

1058

1242

("/clients/" + client_object_name))

1059

1243

DBusObjectWithProperties.__init__(self, self.bus,

1060

1244

self.dbus_object_path)

1061

1245

1062

1246

def notifychangeproperty(transform_func,

1063

1247

dbus_name, type_func=lambda x: x,

1064

variant_level=1):

1248

variant_level=1, invalidate_only=False,

1249

_interface=_interface):

1065

1250

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

1066

1251

its changes to DBus.

1067

1252

1072

1257

to the D-Bus. Default: no transform

1073

1258

variant_level: D-Bus variant level. Default: 1

1074

1259

"""

1075

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

1260

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

1076

1261

def setter(self, value):

1077

1262

if hasattr(self, "dbus_object_path"):

1078

1263

if (not hasattr(self, attrname) or

1079

1264

type_func(getattr(self, attrname, None))

1080

1265

!= type_func(value)):

1081

dbus_value = transform_func(type_func(value),

1082

variant_level

1083

=variant_level)

1084

self.PropertyChanged(dbus.String(dbus_name),

1085

dbus_value)

1266

if invalidate_only:

1267

self.PropertiesChanged(_interface,

1268

dbus.Dictionary(),

1269

dbus.Array

1270

((dbus_name,)))

1271

else:

1272

dbus_value = transform_func(type_func(value),

1273

variant_level

1274

=variant_level)

1275

self.PropertyChanged(dbus.String(dbus_name),

1276

dbus_value)

1277

self.PropertiesChanged(_interface,

1278

dbus.Dictionary({

1279

dbus.String(dbus_name):

1280

dbus_value }), dbus.Array())

1086

1281

setattr(self, attrname, value)

1087

1282

1088

1283

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

1089

1284

1090

1091

1285

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1092

1286

approvals_pending = notifychangeproperty(dbus.Boolean,

1093

1287

"ApprovalPending",

1100

1294

checker is not None)

1101

1295

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1102

1296

"LastCheckedOK")

1297

last_checker_status = notifychangeproperty(dbus.Int16,

1298

"LastCheckerStatus")

1103

1299

last_approval_request = notifychangeproperty(

1104

1300

datetime_to_dbus, "LastApprovalRequest")

1105

1301

approved_by_default = notifychangeproperty(dbus.Boolean,

1107

1303

approval_delay = notifychangeproperty(dbus.UInt64,

1108

1304

"ApprovalDelay",

1109

1305

type_func =

1110

timedelta_to_milliseconds)

1306

lambda td: td.total_seconds()

1307

* 1000)

1111

1308

approval_duration = notifychangeproperty(

1112

1309

dbus.UInt64, "ApprovalDuration",

1113

type_func = timedelta_to_milliseconds)

1310

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

1114

1311

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

1115

1312

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

1116

type_func =

1117

timedelta_to_milliseconds)

1313

type_func = lambda td:

1314

td.total_seconds() * 1000)

1118

1315

extended_timeout = notifychangeproperty(

1119

1316

dbus.UInt64, "ExtendedTimeout",

1120

type_func = timedelta_to_milliseconds)

1317

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

1121

1318

interval = notifychangeproperty(dbus.UInt64,

1122

1319

"Interval",

1123

1320

type_func =

1124

timedelta_to_milliseconds)

1321

lambda td: td.total_seconds()

1322

* 1000)

1125

1323

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

1324

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

1325

invalidate_only=True)

1126

1326

1127

1327

del notifychangeproperty

1128

1328

1155

1355

*args, **kwargs)

1156

1356

1157

1357

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

1158

old_checker = self.checker

1159

if self.checker is not None:

1160

old_checker_pid = self.checker.pid

1161

else:

1162

old_checker_pid = None

1358

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

1163

1359

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

1164

1360

# Only if new checker process was started

1165

1361

if (self.checker is not None

1173

1369

return False

1174

1370

1175

1371

def approve(self, value=True):

1176

self.send_changedstate()

1177

1372

self.approved = value

1178

gobject.timeout_add(timedelta_to_milliseconds

1179

(self.approval_duration),

1180

self._reset_approved)

1181

1373

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

1374

* 1000), self._reset_approved)

1375

self.send_changedstate()

1182

1376

1183

1377

## D-Bus methods, signals & properties

1184

_interface = "se.recompile.Mandos.Client"

1378

1379

## Interfaces

1185

1380

1186

1381

## Signals

1187

1382

1198

1393

pass

1199

1394

1200

1395

# PropertyChanged - signal

1396

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

1201

1397

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

1202

1398

def PropertyChanged(self, property, value):

1203

1399

"D-Bus signal"

1279

1475

access="readwrite")

1280

1476

def ApprovalDelay_dbus_property(self, value=None):

1281

1477

if value is None: # get

1282

return dbus.UInt64(self.approval_delay_milliseconds())

1478

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

1479

* 1000)

1283

1480

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

1284

1481

1285

1482

# ApprovalDuration - property

1287

1484

access="readwrite")

1288

1485

def ApprovalDuration_dbus_property(self, value=None):

1289

1486

if value is None: # get

1290

return dbus.UInt64(timedelta_to_milliseconds(

1291

self.approval_duration))

1487

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

1488

* 1000)

1292

1489

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

1293

1490

1294

1491

# Name - property

1307

1504

def Host_dbus_property(self, value=None):

1308

1505

if value is None: # get

1309

1506

return dbus.String(self.host)

1310

self.host = unicode(value)

1507

self.host = str(value)

1311

1508

1312

1509

# Created - property

1313

1510

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

1339

1536

return

1340

1537

return datetime_to_dbus(self.last_checked_ok)

1341

1538

1539

# LastCheckerStatus - property

1540

@dbus_service_property(_interface, signature="n",

1541

access="read")

1542

def LastCheckerStatus_dbus_property(self):

1543

return dbus.Int16(self.last_checker_status)

1544

1342

1545

# Expires - property

1343

1546

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

1344

1547

def Expires_dbus_property(self):

1354

1557

access="readwrite")

1355

1558

def Timeout_dbus_property(self, value=None):

1356

1559

if value is None: # get

1357

return dbus.UInt64(self.timeout_milliseconds())

1560

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

1561

old_timeout = self.timeout

1358

1562

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

1359

# Reschedule timeout

1563

# Reschedule disabling

1360

1564

if self.enabled:

1361

1565

now = datetime.datetime.utcnow()

1362

time_to_die = timedelta_to_milliseconds(

1363

(self.last_checked_ok + self.timeout) - now)

1364

if time_to_die <= 0:

1566

self.expires += self.timeout - old_timeout

1567

if self.expires <= now:

1365

1568

# The timeout has passed

1366

1569

self.disable()

1367

1570

else:

1368

self.expires = (now +

1369

datetime.timedelta(milliseconds =

1370

time_to_die))

1371

1571

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

1372

1572

is None):

1373

1573

return

1374

1574

gobject.source_remove(self.disable_initiator_tag)

1375

self.disable_initiator_tag = (gobject.timeout_add

1376

(time_to_die,

1377

self.disable))

1575

self.disable_initiator_tag = (

1576

gobject.timeout_add(

1577

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

1578

* 1000), self.disable))

1378

1579

1379

1580

# ExtendedTimeout - property

1380

1581

@dbus_service_property(_interface, signature="t",

1381

1582

access="readwrite")

1382

1583

def ExtendedTimeout_dbus_property(self, value=None):

1383

1584

if value is None: # get

1384

return dbus.UInt64(self.extended_timeout_milliseconds())

1585

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

1586

* 1000)

1385

1587

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

1386

1588

1387

1589

# Interval - property

1389

1591

access="readwrite")

1390

1592

def Interval_dbus_property(self, value=None):

1391

1593

if value is None: # get

1392

return dbus.UInt64(self.interval_milliseconds())

1594

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

1393

1595

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

1394

1596

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

1395

1597

return

1406

1608

def Checker_dbus_property(self, value=None):

1407

1609

if value is None: # get

1408

1610

return dbus.String(self.checker_command)

1409

self.checker_command = unicode(value)

1611

self.checker_command = str(value)

1410

1612

1411

1613

# CheckerRunning - property

1412

1614

@dbus_service_property(_interface, signature="b",

1428

1630

@dbus_service_property(_interface, signature="ay",

1429

1631

access="write", byte_arrays=True)

1430

1632

def Secret_dbus_property(self, value):

1431

self.secret = str(value)

1633

self.secret = bytes(value)

1432

1634

1433

1635

del _interface

1434

1636

1459

1661

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

1460

1662

1461

1663

1462

class ClientDBusTransitional(ClientDBus):

1463

__metaclass__ = AlternateDBusNamesMetaclass

1464

1465

1466

1664

class ClientHandler(socketserver.BaseRequestHandler, object):

1467

1665

"""A class to handle client connections.

1468

1666

1472

1670

def handle(self):

1473

1671

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

1474

1672

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

1475

unicode(self.client_address))

1673

str(self.client_address))

1476

1674

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

1477

1675

self.server.child_pipe.fileno())

1478

1676

1504

1702

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

1505

1703

try:

1506

1704

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

1507

raise RuntimeError

1705

raise RuntimeError(line)

1508

1706

except (ValueError, IndexError, RuntimeError) as error:

1509

1707

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

1510

1708

return

1559

1757

if self.server.use_dbus:

1560

1758

# Emit D-Bus signal

1561

1759

client.NeedApproval(

1562

client.approval_delay_milliseconds(),

1563

client.approved_by_default)

1760

client.approval_delay.total_seconds()

1761

* 1000, client.approved_by_default)

1564

1762

else:

1565

1763

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

1566

1764

client.name)

1572

1770

#wait until timeout or approved

1573

1771

time = datetime.datetime.now()

1574

1772

client.changedstate.acquire()

1575

(client.changedstate.wait

1576

(float(client.timedelta_to_milliseconds(delay)

1577

/ 1000)))

1773

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

1578

1774

client.changedstate.release()

1579

1775

time2 = datetime.datetime.now()

1580

1776

if (time2 - time) >= delay:

1596

1792

try:

1597

1793

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

1598

1794

except gnutls.errors.GNUTLSError as error:

1599

logger.warning("gnutls send failed")

1795

logger.warning("gnutls send failed",

1796

exc_info=error)

1600

1797

return

1601

1798

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

1602

1799

sent, len(client.secret)

1605

1802

1606

1803

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

1607

1804

# bump the timeout using extended_timeout

1608

client.checked_ok(client.extended_timeout)

1805

client.bump_timeout(client.extended_timeout)

1609

1806

if self.server.use_dbus:

1610

1807

# Emit D-Bus signal

1611

1808

client.GotSecret()

1616

1813

try:

1617

1814

session.bye()

1618

1815

except gnutls.errors.GNUTLSError as error:

1619

logger.warning("GnuTLS bye failed")

1816

logger.warning("GnuTLS bye failed",

1817

exc_info=error)

1620

1818

1621

1819

@staticmethod

1622

1820

def peer_certificate(session):

1694

1892

def process_request(self, request, address):

1695

1893

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

1696

1894

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

1697

args = (request,

1698

address))

1895

args = (request, address))

1699

1896

proc.start()

1700

1897

return proc

1701

1898

1716

1913

1717

1914

def add_pipe(self, parent_pipe, proc):

1718

1915

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

1719

raise NotImplementedError

1916

raise NotImplementedError()

1720

1917

1721

1918

1722

1919

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1729

1926

use_ipv6: Boolean; to use IPv6 or not

1730

1927

"""

1731

1928

def __init__(self, server_address, RequestHandlerClass,

1732

interface=None, use_ipv6=True):

1929

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

1930

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

1931

creating a new one with socket.socket().

1932

"""

1733

1933

self.interface = interface

1734

1934

if use_ipv6:

1735

1935

self.address_family = socket.AF_INET6

1936

if socketfd is not None:

1937

# Save the file descriptor

1938

self.socketfd = socketfd

1939

# Save the original socket.socket() function

1940

self.socket_socket = socket.socket

1941

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

1942

#

1943

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

1944

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

1945

# patching socket.socket.)

1946

#

1947

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

1948

@functools.wraps(socket.socket)

1949

def socket_wrapper(*args, **kwargs):

1950

# Restore original function so subsequent calls are

1951

# not affected.

1952

socket.socket = self.socket_socket

1953

del self.socket_socket

1954

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

1955

# saved file descriptor.

1956

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

1957

# Replace socket.socket() function with wrapper

1958

socket.socket = socket_wrapper

1959

# The socketserver.TCPServer.__init__ will call

1960

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

1961

# socket_wrapper(), if socketfd was set.

1736

1962

socketserver.TCPServer.__init__(self, server_address,

1737

1963

RequestHandlerClass)

1964

1738

1965

def server_bind(self):

1739

1966

"""This overrides the normal server_bind() function

1740

1967

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

1748

1975

try:

1749

1976

self.socket.setsockopt(socket.SOL_SOCKET,

1750

1977

SO_BINDTODEVICE,

1751

str(self.interface

1752

+ '\0'))

1978

(self.interface + "\0")

1979

.encode("utf-8"))

1753

1980

except socket.error as error:

1754

if error[0] == errno.EPERM:

1755

logger.error("No permission to"

1756

" bind to interface %s",

1757

self.interface)

1758

elif error[0] == errno.ENOPROTOOPT:

1981

if error.errno == errno.EPERM:

1982

logger.error("No permission to bind to"

1983

" interface %s", self.interface)

1984

elif error.errno == errno.ENOPROTOOPT:

1759

1985

logger.error("SO_BINDTODEVICE not available;"

1760

1986

" cannot bind to interface %s",

1761

1987

self.interface)

1988

elif error.errno == errno.ENODEV:

1989

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

1990

" cannot bind", self.interface)

1762

1991

else:

1763

1992

raise

1764

1993

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

1767

1996

if self.address_family == socket.AF_INET6:

1768

1997

any_address = "::" # in6addr_any

1769

1998

else:

1770

any_address = socket.INADDR_ANY

1999

any_address = "0.0.0.0" # INADDR_ANY

1771

2000

self.server_address = (any_address,

1772

2001

self.server_address[1])

1773

2002

elif not self.server_address[1]:

1794

2023

"""

1795

2024

def __init__(self, server_address, RequestHandlerClass,

1796

2025

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

1797

gnutls_priority=None, use_dbus=True):

2026

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

1798

2027

self.enabled = False

1799

2028

self.clients = clients

1800

2029

if self.clients is None:

1804

2033

IPv6_TCPServer.__init__(self, server_address,

1805

2034

RequestHandlerClass,

1806

2035

interface = interface,

1807

use_ipv6 = use_ipv6)

2036

use_ipv6 = use_ipv6,

2037

socketfd = socketfd)

1808

2038

def server_activate(self):

1809

2039

if self.enabled:

1810

2040

return socketserver.TCPServer.server_activate(self)

1823

2053

1824

2054

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

1825

2055

proc = None, client_object=None):

1826

condition_names = {

1827

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

1828

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

1829

# blocking).

1830

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

1831

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

1832

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

1833

# broken, usually for pipes and

1834

# sockets).

1835

}

1836

conditions_string = ' | '.join(name

1837

for cond, name in

1838

condition_names.iteritems()

1839

if cond & condition)

1840

2056

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

1841

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

2057

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

1842

2058

# Wait for other process to exit

1843

2059

proc.join()

1844

2060

return False

1902

2118

return True

1903

2119

1904

2120

2121

def rfc3339_duration_to_delta(duration):

2122

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

2123

2124

>>> rfc3339_duration_to_delta("P7D")

2125

datetime.timedelta(7)

2126

>>> rfc3339_duration_to_delta("PT60S")

2127

datetime.timedelta(0, 60)

2128

>>> rfc3339_duration_to_delta("PT60M")

2129

datetime.timedelta(0, 3600)

2130

>>> rfc3339_duration_to_delta("PT24H")

2131

datetime.timedelta(1)

2132

>>> rfc3339_duration_to_delta("P1W")

2133

datetime.timedelta(7)

2134

>>> rfc3339_duration_to_delta("PT5M30S")

2135

datetime.timedelta(0, 330)

2136

>>> rfc3339_duration_to_delta("P1DT3M20S")

2137

datetime.timedelta(1, 200)

2138

"""

2139

2140

# Parsing an RFC 3339 duration with regular expressions is not

2141

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

2142

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

2143

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

2144

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

2145

# avoid excessive use of external libraries.

2146

2147

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

2148

Token = collections.namedtuple("Token",

2149

("regexp", # To match token; if

2150

# "value" is not None,

2151

# must have a "group"

2152

# containing digits

2153

"value", # datetime.timedelta or

2154

# None

2155

"followers")) # Tokens valid after

2156

# this token

2157

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

2158

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

2159

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

2160

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

2161

datetime.timedelta(seconds=1),

2162

frozenset((token_end,)))

2163

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

2164

datetime.timedelta(minutes=1),

2165

frozenset((token_second, token_end)))

2166

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

2167

datetime.timedelta(hours=1),

2168

frozenset((token_minute, token_end)))

2169

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

2170

None,

2171

frozenset((token_hour, token_minute,

2172

token_second)))

2173

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

2174

datetime.timedelta(days=1),

2175

frozenset((token_time, token_end)))

2176

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

2177

datetime.timedelta(weeks=4),

2178

frozenset((token_day, token_end)))

2179

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

2180

datetime.timedelta(weeks=52),

2181

frozenset((token_month, token_end)))

2182

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

2183

datetime.timedelta(weeks=1),

2184

frozenset((token_end,)))

2185

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

2186

frozenset((token_year, token_month,

2187

token_day, token_time,

2188

token_week)))

2189

# Define starting values

2190

value = datetime.timedelta() # Value so far

2191

found_token = None

2192

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

2193

s = duration # String left to parse

2194

# Loop until end token is found

2195

while found_token is not token_end:

2196

# Search for any currently valid tokens

2197

for token in followers:

2198

match = token.regexp.match(s)

2199

if match is not None:

2200

# Token found

2201

if token.value is not None:

2202

# Value found, parse digits

2203

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

2204

# Add to value so far

2205

value += factor * token.value

2206

# Strip token from string

2207

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

2208

# Go to found token

2209

found_token = token

2210

# Set valid next tokens

2211

followers = found_token.followers

2212

break

2213

else:

2214

# No currently valid tokens were found

2215

raise ValueError("Invalid RFC 3339 duration")

2216

# End token found

2217

return value

2218

2219

1905

2220

def string_to_delta(interval):

1906

2221

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

1907

2222

1918

2233

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

1919

2234

datetime.timedelta(0, 330)

1920

2235

"""

2236

2237

try:

2238

return rfc3339_duration_to_delta(interval)

2239

except ValueError:

2240

pass

2241

1921

2242

timevalue = datetime.timedelta(0)

1922

2243

for s in interval.split():

1923

2244

try:

1924

suffix = unicode(s[-1])

2245

suffix = s[-1]

1925

2246

value = int(s[:-1])

1926

2247

if suffix == "d":

1927

2248

delta = datetime.timedelta(value)

1934

2255

elif suffix == "w":

1935

2256

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

1936

2257

else:

1937

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

1938

except (ValueError, IndexError) as e:

2258

raise ValueError("Unknown suffix {!r}"

2259

.format(suffix))

2260

except IndexError as e:

1939

2261

raise ValueError(*(e.args))

1940

2262

timevalue += delta

1941

2263

return timevalue

1954

2276

sys.exit()

1955

2277

if not noclose:

1956

2278

# Close all standard open file descriptors

1957

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

2279

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

1958

2280

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

1959

raise OSError(errno.ENODEV,

1960

"%s not a character device"

1961

% os.path.devnull)

2281

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

2282

.format(os.devnull))

1962

2283

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

1963

2284

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

1964

2285

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

1973

2294

1974

2295

parser = argparse.ArgumentParser()

1975

2296

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

1976

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

2297

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

1977

2298

help="show version number and exit")

1978

2299

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

1979

2300

help="Bind to interface IF")

1985

2306

help="Run self-test")

1986

2307

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

1987

2308

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

1988

" to terminal")

2309

" to terminal", default=None)

1989

2310

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

1990

2311

help="Debug level for stdout output")

1991

2312

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

1998

2319

" files")

1999

2320

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

2000

2321

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

2001

" system bus interface")

2322

" system bus interface", default=None)

2002

2323

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

2003

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

2324

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

2325

default=None)

2004

2326

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

2005

2327

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

2006

" state")

2328

" state", default=None)

2329

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

2330

help="Specify a file descriptor to a network"

2331

" socket to use instead of creating one")

2007

2332

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

2008

2333

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

2334

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

2335

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

2336

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

2337

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

2338

default=None)

2009

2339

2010

2340

options = parser.parse_args()

2011

2341

2012

2342

if options.check:

2013

2343

import doctest

2014

doctest.testmod()

2015

sys.exit()

2344

fail_count, test_count = doctest.testmod()

2345

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

2016

2346

2017

2347

# Default values for config file for server-global settings

2018

2348

server_defaults = { "interface": "",

2020

2350

"port": "",

2021

2351

"debug": "False",

2022

2352

"priority":

2023

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

2353

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

2024

2354

"servicename": "Mandos",

2025

2355

"use_dbus": "True",

2026

2356

"use_ipv6": "True",

2027

2357

"debuglevel": "",

2028

2358

"restore": "True",

2029

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

2359

"socket": "",

2360

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

2361

"foreground": "False",

2362

"zeroconf": "True",

2030

2363

}

2031

2364

2032

2365

# Parse config file for server-global settings

2037

2370

# Convert the SafeConfigParser object to a dict

2038

2371

server_settings = server_config.defaults()

2039

2372

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

2040

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

2373

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

2041

2374

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

2042

2375

option)

2043

2376

if server_settings["port"]:

2044

2377

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

2045

2378

"port")

2379

if server_settings["socket"]:

2380

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

2381

"socket")

2382

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

2383

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

2384

# happen with a supplied network socket.

2385

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

2386

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

2387

["socket"])

2046

2388

del server_config

2047

2389

2048

2390

# Override the settings from the config file with command line

2050

2392

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

2051

2393

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

2052

2394

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

2053

"statedir"):

2395

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

2054

2396

value = getattr(options, option)

2055

2397

if value is not None:

2056

2398

server_settings[option] = value

2057

2399

del options

2058

2400

# Force all strings to be unicode

2059

2401

for option in server_settings.keys():

2060

if type(server_settings[option]) is str:

2061

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

2402

if isinstance(server_settings[option], bytes):

2403

server_settings[option] = (server_settings[option]

2404

.decode("utf-8"))

2405

# Force all boolean options to be boolean

2406

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

2407

"foreground", "zeroconf"):

2408

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

2409

# Debug implies foreground

2410

if server_settings["debug"]:

2411

server_settings["foreground"] = True

2062

2412

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

2063

2413

2064

2414

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

2065

2415

2416

if (not server_settings["zeroconf"] and

2417

not (server_settings["port"]

2418

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

2419

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

2420

" Zeroconf")

2421

2066

2422

# For convenience

2067

2423

debug = server_settings["debug"]

2068

2424

debuglevel = server_settings["debuglevel"]

2070

2426

use_ipv6 = server_settings["use_ipv6"]

2071

2427

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

2072

2428

stored_state_file)

2429

foreground = server_settings["foreground"]

2430

zeroconf = server_settings["zeroconf"]

2073

2431

2074

2432

if debug:

2075

2433

initlogger(debug, logging.DEBUG)

2082

2440

2083

2441

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

2084

2442

syslogger.setFormatter(logging.Formatter

2085

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

2086

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

2087

% server_settings["servicename"]))

2443

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

2444

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

2445

.format(server_settings

2446

["servicename"])))

2088

2447

2089

2448

# Parse config file with clients

2090

2449

client_config = configparser.SafeConfigParser(Client

2095

2454

global mandos_dbus_service

2096

2455

mandos_dbus_service = None

2097

2456

2457

socketfd = None

2458

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

2459

socketfd = server_settings["socket"]

2098

2460

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

2099

2461

server_settings["port"]),

2100

2462

ClientHandler,

2103

2465

use_ipv6=use_ipv6,

2104

2466

gnutls_priority=

2105

2467

server_settings["priority"],

2106

use_dbus=use_dbus)

2107

if not debug:

2108

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

2468

use_dbus=use_dbus,

2469

socketfd=socketfd)

2470

if not foreground:

2471

pidfilename = "/run/mandos.pid"

2472

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

2473

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

2474

pidfile = None

2109

2475

try:

2110

2476

pidfile = open(pidfilename, "w")

2111

except IOError:

2112

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

2477

except IOError as e:

2478

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

2479

exc_info=e)

2113

2480

2114

try:

2115

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

2116

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

2117

except KeyError:

2481

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

2118

2482

try:

2119

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

2120

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

2483

uid = pwd.getpwnam(name).pw_uid

2484

gid = pwd.getpwnam(name).pw_gid

2485

break

2121

2486

except KeyError:

2122

try:

2123

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

2124

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

2125

except KeyError:

2126

uid = 65534

2127

gid = 65534

2487

continue

2488

else:

2489

uid = 65534

2490

gid = 65534

2128

2491

try:

2129

2492

os.setgid(gid)

2130

2493

os.setuid(uid)

2131

2494

except OSError as error:

2132

if error[0] != errno.EPERM:

2133

raise error

2495

if error.errno != errno.EPERM:

2496

raise

2134

2497

2135

2498

if debug:

2136

2499

# Enable all possible GnuTLS debugging

2147

2510

.gnutls_global_set_log_function(debug_gnutls))

2148

2511

2149

2512

# Redirect stdin so all checkers get /dev/null

2150

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

2513

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

2151

2514

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

2152

2515

if null > 2:

2153

2516

os.close(null)

2154

2517

2155

2518

# Need to fork before connecting to D-Bus

2156

if not debug:

2519

if not foreground:

2157

2520

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

2158

2521

daemon()

2159

2522

2523

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

2524

# need to inform gobject that threads will be used.

2160

2525

gobject.threads_init()

2161

2526

2162

2527

global main_loop

2163

2528

# From the Avahi example code

2164

DBusGMainLoop(set_as_default=True )

2529

DBusGMainLoop(set_as_default=True)

2165

2530

main_loop = gobject.MainLoop()

2166

2531

bus = dbus.SystemBus()

2167

2532

# End of Avahi example code

2173

2538

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

2174

2539

do_not_queue=True))

2175

2540

except dbus.exceptions.NameExistsException as e:

2176

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

2541

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

2177

2542

use_dbus = False

2178

2543

server_settings["use_dbus"] = False

2179

2544

tcp_server.use_dbus = False

2180

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2181

service = AvahiServiceToSyslog(name =

2182

server_settings["servicename"],

2183

servicetype = "_mandos._tcp",

2184

protocol = protocol, bus = bus)

2185

if server_settings["interface"]:

2186

service.interface = (if_nametoindex

2187

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

2545

if zeroconf:

2546

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2547

service = AvahiServiceToSyslog(name =

2548

server_settings["servicename"],

2549

servicetype = "_mandos._tcp",

2550

protocol = protocol, bus = bus)

2551

if server_settings["interface"]:

2552

service.interface = (if_nametoindex

2553

(server_settings["interface"]

2554

.encode("utf-8")))

2188

2555

2189

2556

global multiprocessing_manager

2190

2557

multiprocessing_manager = multiprocessing.Manager()

2191

2558

2192

2559

client_class = Client

2193

2560

if use_dbus:

2194

client_class = functools.partial(ClientDBusTransitional,

2195

bus = bus)

2561

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

2196

2562

2197

2563

client_settings = Client.config_parser(client_config)

2198

2564

old_client_settings = {}

2199

2565

clients_data = {}

2200

2566

2567

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

2568

global wnull

2569

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

2570

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

2571

# mode

2572

if debug or not foreground:

2573

wnull.close()

2574

2201

2575

# Get client data and settings from last running state.

2202

2576

if server_settings["restore"]:

2203

2577

try:

2206

2580

(stored_state))

2207

2581

os.remove(stored_state_path)

2208

2582

except IOError as e:

2209

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

2210

.format(e))

2211

if e.errno != errno.ENOENT:

2583

if e.errno == errno.ENOENT:

2584

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

2585

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

2586

else:

2587

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

2588

exc_info=e)

2212

2589

raise

2213

2590

except EOFError as e:

2214

2591

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

2215

"EOFError: {0}".format(e))

2592

"EOFError:", exc_info=e)

2216

2593

2217

2594

with PGPEngine() as pgp:

2218

for client_name, client in clients_data.iteritems():

2595

for client_name, client in clients_data.items():

2596

# Skip removed clients

2597

if client_name not in client_settings:

2598

continue

2599

2219

2600

# Decide which value to use after restoring saved state.

2220

2601

# We have three different values: Old config file,

2221

2602

# new config file, and saved state.

2242

2623

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

2243

2624

if not client["last_checked_ok"]:

2244

2625

logger.warning(

2245

"disabling client {0} - Client never "

2626

"disabling client {} - Client never "

2246

2627

"performed a successful checker"

2247

2628

.format(client_name))

2248

2629

client["enabled"] = False

2249

2630

elif client["last_checker_status"] != 0:

2250

2631

logger.warning(

2251

"disabling client {0} - Client "

2252

"last checker failed with error code {1}"

2632

"disabling client {} - Client last"

2633

" checker failed with error code {}"

2253

2634

.format(client_name,

2254

2635

client["last_checker_status"]))

2255

2636

client["enabled"] = False

2258

2639

.utcnow()

2259

2640

+ client["timeout"])

2260

2641

logger.debug("Last checker succeeded,"

2261

" keeping {0} enabled"

2642

" keeping {} enabled"

2262

2643

.format(client_name))

2263

2644

try:

2264

2645

client["secret"] = (

2267

2648

["secret"]))

2268

2649

except PGPError:

2269

2650

# If decryption fails, we use secret from new settings

2270

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

2651

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

2271

2652

.format(client_name))

2272

2653

client["secret"] = (

2273

2654

client_settings[client_name]["secret"])

2274

2275

2655

2276

2656

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

2277

2657

for client_name in (set(old_client_settings)

2280

2660

for client_name in (set(client_settings)

2281

2661

- set(old_client_settings)):

2282

2662

clients_data[client_name] = client_settings[client_name]

2283

2663

2284

2664

# Create all client objects

2285

for client_name, client in clients_data.iteritems():

2665

for client_name, client in clients_data.items():

2286

2666

tcp_server.clients[client_name] = client_class(

2287

name = client_name, settings = client)

2667

name = client_name, settings = client,

2668

server_settings = server_settings)

2288

2669

2289

2670

if not tcp_server.clients:

2290

2671

logger.warning("No clients defined")

2291

2292

if not debug:

2293

try:

2294

with pidfile:

2295

pid = os.getpid()

2296

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

2297

del pidfile

2298

except IOError:

2299

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

2300

pidfilename, pid)

2301

except NameError:

2302

# "pidfile" was never created

2303

pass

2672

2673

if not foreground:

2674

if pidfile is not None:

2675

try:

2676

with pidfile:

2677

pid = os.getpid()

2678

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

2679

except IOError:

2680

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

2681

pidfilename, pid)

2682

del pidfile

2304

2683

del pidfilename

2305

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

2306

2684

2307

2685

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

2308

2686

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

2309

2687

2310

2688

if use_dbus:

2311

class MandosDBusService(dbus.service.Object):

2689

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

2690

"se.bsnet.fukt.Mandos"})

2691

class MandosDBusService(DBusObjectWithProperties):

2312

2692

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

2313

2693

def __init__(self):

2314

2694

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

2315

2695

_interface = "se.recompile.Mandos"

2316

2696

2697

@dbus_interface_annotations(_interface)

2698

def _foo(self):

2699

return { "org.freedesktop.DBus.Property"

2700

".EmitsChangedSignal":

2701

"false"}

2702

2317

2703

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

2318

2704

def ClientAdded(self, objpath):

2319

2705

"D-Bus signal"

2341

2727

def GetAllClientsWithProperties(self):

2342

2728

"D-Bus method"

2343

2729

return dbus.Dictionary(

2344

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

2345

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

2730

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

2731

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

2346

2732

signature="oa{sv}")

2347

2733

2348

2734

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

2361

2747

2362

2748

del _interface

2363

2749

2364

class MandosDBusServiceTransitional(MandosDBusService):

2365

__metaclass__ = AlternateDBusNamesMetaclass

2366

mandos_dbus_service = MandosDBusServiceTransitional()

2750

mandos_dbus_service = MandosDBusService()

2367

2751

2368

2752

def cleanup():

2369

2753

"Cleanup function; run on exit"

2370

service.cleanup()

2754

if zeroconf:

2755

service.cleanup()

2371

2756

2372

2757

multiprocessing.active_children()

2758

wnull.close()

2373

2759

if not (tcp_server.clients or client_settings):

2374

2760

return

2375

2761

2386

2772

2387

2773

# A list of attributes that can not be pickled

2388

2774

# + secret.

2389

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

2390

"checker"))

2775

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

2776

"checker", "server_settings" }

2391

2777

for name, typ in (inspect.getmembers

2392

2778

(dbus.service.Object)):

2393

2779

exclude.add(name)

2402

2788

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

2403

2789

2404

2790

try:

2405

tempfd, tempname = tempfile.mkstemp(suffix=".pickle",

2406

prefix="clients-",

2407

dir=os.path.dirname

2408

(stored_state_path))

2409

with os.fdopen(tempfd, "wb") as stored_state:

2791

with (tempfile.NamedTemporaryFile

2792

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

2793

dir=os.path.dirname(stored_state_path),

2794

delete=False)) as stored_state:

2410

2795

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

2796

tempname=stored_state.name

2411

2797

os.rename(tempname, stored_state_path)

2412

2798

except (IOError, OSError) as e:

2413

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

2414

.format(e))

2415

2799

if not debug:

2416

2800

try:

2417

2801

os.remove(tempname)

2418

2802

except NameError:

2419

2803

pass

2420

if e.errno not in set((errno.ENOENT, errno.EACCES,

2421

errno.EEXIST)):

2422

raise e

2804

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

2805

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

2806

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

2807

else:

2808

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

2809

exc_info=e)

2810

raise

2423

2811

2424

2812

# Delete all clients, and settings from config

2425

2813

while tcp_server.clients:

2449

2837

tcp_server.server_activate()

2450

2838

2451

2839

# Find out what port we got

2452

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

2840

if zeroconf:

2841

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

2453

2842

if use_ipv6:

2454

2843

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

2455

" flowinfo %d, scope_id %d"

2456

% tcp_server.socket.getsockname())

2844

" flowinfo %d, scope_id %d",

2845

*tcp_server.socket.getsockname())

2457

2846

else: # IPv4

2458

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

2459

% tcp_server.socket.getsockname())

2847

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

2848

*tcp_server.socket.getsockname())

2460

2849

2461

2850

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

2462

2851

2463

2852

try:

2464

# From the Avahi example code

2465

try:

2466

service.activate()

2467

except dbus.exceptions.DBusException as error:

2468

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

2469

cleanup()

2470

sys.exit(1)

2471

# End of Avahi example code

2853

if zeroconf:

2854

# From the Avahi example code

2855

try:

2856

service.activate()

2857

except dbus.exceptions.DBusException as error:

2858

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

2859

cleanup()

2860

sys.exit(1)

2861

# End of Avahi example code

2472

2862

2473

2863

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

2474

2864

lambda *args, **kwargs:

2478

2868

logger.debug("Starting main loop")

2479

2869

main_loop.run()

2480

2870

except AvahiError as error:

2481

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

2871

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

2482

2872

cleanup()

2483

2873

sys.exit(1)

2484

2874

except KeyboardInterrupt: