/mandos/release : revision 237.7.157

1

#!/usr/bin/python2.7

1

#!/usr/bin/python

2

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

3

#

4

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

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

36

37

from future_builtins import *

38

39

try:

40

import SocketServer as socketserver

41

except ImportError:

42

import socketserver

39

import SocketServer as socketserver

43

40

import socket

44

41

import argparse

45

42

import datetime

50

47

import gnutls.library.functions

51

48

import gnutls.library.constants

52

49

import gnutls.library.types

53

try:

54

import ConfigParser as configparser

55

except ImportError:

56

import configparser

50

import ConfigParser as configparser

57

51

import sys

58

52

import re

59

53

import os

68

62

import struct

69

63

import fcntl

70

64

import functools

71

try:

72

import cPickle as pickle

73

except ImportError:

74

import pickle

65

import cPickle as pickle

75

66

import multiprocessing

76

67

import types

77

68

import binascii

78

69

import tempfile

79

70

import itertools

80

71

import collections

81

import codecs

82

72

83

73

import dbus

84

74

import dbus.service

85

try:

86

import gobject

87

except ImportError:

88

from gi.repository import GObject as gobject

75

import gobject

89

76

import avahi

90

77

from dbus.mainloop.glib import DBusGMainLoop

91

78

import ctypes

92

79

import ctypes.util

93

80

import xml.dom.minidom

94

81

import inspect

82

import GnuPGInterface

95

83

96

84

try:

97

85

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

101

89

except ImportError:

102

90

SO_BINDTODEVICE = None

103

91

104

if sys.version_info.major == 2:

105

str = unicode

106

107

version = "1.6.9"

92

version = "1.6.0"

108

93

stored_state_file = "clients.pickle"

109

94

110

95

logger = logging.getLogger()

111

syslogger = None

96

syslogger = (logging.handlers.SysLogHandler

97

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

98

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

112

99

113

100

try:

114

if_nametoindex = ctypes.cdll.LoadLibrary(

115

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

101

if_nametoindex = (ctypes.cdll.LoadLibrary

102

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

103

.if_nametoindex)

116

104

except (OSError, AttributeError):

117

118

105

def if_nametoindex(interface):

119

106

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

120

107

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

121

108

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

122

109

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

123

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

124

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

110

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

111

interface))

112

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

113

ifreq[16:20])[0]

125

114

return interface_index

126

115

127

116

128

117

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

129

118

"""init logger and add loglevel"""

130

119

131

global syslogger

132

syslogger = (logging.handlers.SysLogHandler(

133

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

134

address = "/dev/log"))

135

120

syslogger.setFormatter(logging.Formatter

136

121

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

137

122

' %(message)s'))

154

139

155

140

class PGPEngine(object):

156

141

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

157

158

142

def __init__(self):

143

self.gnupg = GnuPGInterface.GnuPG()

159

144

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

160

self.gnupgargs = ['--batch',

161

'--home', self.tempdir,

162

'--force-mdc',

163

'--quiet',

164

'--no-use-agent']

145

self.gnupg = GnuPGInterface.GnuPG()

146

self.gnupg.options.meta_interactive = False

147

self.gnupg.options.homedir = self.tempdir

148

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

149

'--quiet',

150

'--no-use-agent'])

165

151

166

152

def __enter__(self):

167

153

return self

189

175

def password_encode(self, password):

190

176

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

191

177

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

192

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

193

if len(encoded) > 2048:

194

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

195

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

196

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

197

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

198

return encoded

178

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

199

179

200

180

def encrypt(self, data, password):

201

passphrase = self.password_encode(password)

202

with tempfile.NamedTemporaryFile(

203

dir=self.tempdir) as passfile:

204

passfile.write(passphrase)

205

passfile.flush()

206

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

207

'--passphrase-file',

208

passfile.name]

209

+ self.gnupgargs,

210

stdin = subprocess.PIPE,

211

stdout = subprocess.PIPE,

212

stderr = subprocess.PIPE)

213

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

214

if proc.returncode != 0:

215

raise PGPError(err)

181

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

182

with open(os.devnull, "w") as devnull:

183

try:

184

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

185

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

186

attach_fhs={'stderr': devnull})

187

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

188

f.write(data)

189

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

190

ciphertext = f.read()

191

proc.wait()

192

except IOError as e:

193

raise PGPError(e)

194

self.gnupg.passphrase = None

216

195

return ciphertext

217

196

218

197

def decrypt(self, data, password):

219

passphrase = self.password_encode(password)

220

with tempfile.NamedTemporaryFile(

221

dir = self.tempdir) as passfile:

222

passfile.write(passphrase)

223

passfile.flush()

224

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

225

'--passphrase-file',

226

passfile.name]

227

+ self.gnupgargs,

228

stdin = subprocess.PIPE,

229

stdout = subprocess.PIPE,

230

stderr = subprocess.PIPE)

231

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

232

if proc.returncode != 0:

233

raise PGPError(err)

198

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

199

with open(os.devnull, "w") as devnull:

200

try:

201

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

202

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

203

attach_fhs={'stderr': devnull})

204

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

205

f.write(data)

206

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

207

decrypted_plaintext = f.read()

208

proc.wait()

209

except IOError as e:

210

raise PGPError(e)

211

self.gnupg.passphrase = None

234

212

return decrypted_plaintext

235

213

236

214

237

215

class AvahiError(Exception):

238

216

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

239

217

self.value = value

240

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

241

**kwargs)

242

218

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

219

def __unicode__(self):

220

return unicode(repr(self.value))

243

221

244

222

class AvahiServiceError(AvahiError):

245

223

pass

246

224

247

248

225

class AvahiGroupError(AvahiError):

249

226

pass

250

227

257

234

Used to optionally bind to the specified interface.

258

235

name: string; Example: 'Mandos'

259

236

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

260

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

237

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

261

238

port: integer; what port to announce

262

239

TXT: list of strings; TXT record for the service

263

240

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

270

247

bus: dbus.SystemBus()

271

248

"""

272

249

273

def __init__(self,

274

interface = avahi.IF_UNSPEC,

275

name = None,

276

servicetype = None,

277

port = None,

278

TXT = None,

279

domain = "",

280

host = "",

281

max_renames = 32768,

282

protocol = avahi.PROTO_UNSPEC,

283

bus = None):

250

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

251

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

252

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

253

protocol = avahi.PROTO_UNSPEC, bus = None):

284

254

self.interface = interface

285

255

self.name = name

286

256

self.type = servicetype

296

266

self.bus = bus

297

267

self.entry_group_state_changed_match = None

298

268

299

def rename(self, remove=True):

269

def rename(self):

300

270

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

301

271

if self.rename_count >= self.max_renames:

302

272

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

303

273

" after %i retries, exiting.",

304

274

self.rename_count)

305

275

raise AvahiServiceError("Too many renames")

306

self.name = str(

307

self.server.GetAlternativeServiceName(self.name))

308

self.rename_count += 1

276

self.name = unicode(self.server

277

.GetAlternativeServiceName(self.name))

309

278

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

310

279

self.name)

311

if remove:

312

self.remove()

280

self.remove()

313

281

try:

314

282

self.add()

315

283

except dbus.exceptions.DBusException as error:

316

if (error.get_dbus_name()

317

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

318

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

319

return self.rename(remove=False)

320

else:

321

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

322

self.cleanup()

323

os._exit(1)

284

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

285

self.cleanup()

286

os._exit(1)

287

self.rename_count += 1

324

288

325

289

def remove(self):

326

290

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

364

328

self.rename()

365

329

elif state == avahi.ENTRY_GROUP_FAILURE:

366

330

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

367

str(error))

368

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

331

unicode(error))

332

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

333

.format(error))

369

334

370

335

def cleanup(self):

371

336

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

381

346

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

382

347

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

383

348

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

384

bad_states = {

385

avahi.SERVER_INVALID: "Zeroconf server invalid",

386

avahi.SERVER_REGISTERING: None,

387

avahi.SERVER_COLLISION: "Zeroconf server name collision",

388

avahi.SERVER_FAILURE: "Zeroconf server failure",

389

}

349

bad_states = { avahi.SERVER_INVALID:

350

"Zeroconf server invalid",

351

avahi.SERVER_REGISTERING: None,

352

avahi.SERVER_COLLISION:

353

"Zeroconf server name collision",

354

avahi.SERVER_FAILURE:

355

"Zeroconf server failure" }

390

356

if state in bad_states:

391

357

if bad_states[state] is not None:

392

358

if error is None:

411

377

follow_name_owner_changes=True),

412

378

avahi.DBUS_INTERFACE_SERVER)

413

379

self.server.connect_to_signal("StateChanged",

414

self.server_state_changed)

380

self.server_state_changed)

415

381

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

416

382

417

383

418

384

class AvahiServiceToSyslog(AvahiService):

419

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

385

def rename(self):

420

386

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

421

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

422

syslogger.setFormatter(logging.Formatter(

423

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

424

.format(self.name)))

387

ret = AvahiService.rename(self)

388

syslogger.setFormatter(logging.Formatter

389

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

390

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

391

.format(self.name)))

425

392

return ret

426

393

427

394

395

def timedelta_to_milliseconds(td):

396

"Convert a datetime.timedelta() to milliseconds"

397

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

398

+ (td.seconds * 1000)

399

+ (td.microseconds // 1000))

400

401

428

402

class Client(object):

429

403

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

430

404

466

440

runtime_expansions: Allowed attributes for runtime expansion.

467

441

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

468

442

disabled, or None

469

server_settings: The server_settings dict from main()

470

443

"""

471

444

472

445

runtime_expansions = ("approval_delay", "approval_duration",

474

447

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

475

448

"last_approval_request", "last_checked_ok",

476

449

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

477

client_defaults = {

478

"timeout": "PT5M",

479

"extended_timeout": "PT15M",

480

"interval": "PT2M",

481

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

482

"host": "",

483

"approval_delay": "PT0S",

484

"approval_duration": "PT1S",

485

"approved_by_default": "True",

486

"enabled": "True",

487

}

450

client_defaults = { "timeout": "PT5M",

451

"extended_timeout": "PT15M",

452

"interval": "PT2M",

453

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

454

"host": "",

455

"approval_delay": "PT0S",

456

"approval_duration": "PT1S",

457

"approved_by_default": "True",

458

"enabled": "True",

459

}

460

461

def timeout_milliseconds(self):

462

"Return the 'timeout' attribute in milliseconds"

463

return timedelta_to_milliseconds(self.timeout)

464

465

def extended_timeout_milliseconds(self):

466

"Return the 'extended_timeout' attribute in milliseconds"

467

return timedelta_to_milliseconds(self.extended_timeout)

468

469

def interval_milliseconds(self):

470

"Return the 'interval' attribute in milliseconds"

471

return timedelta_to_milliseconds(self.interval)

472

473

def approval_delay_milliseconds(self):

474

return timedelta_to_milliseconds(self.approval_delay)

488

475

489

476

@staticmethod

490

477

def config_parser(config):

506

493

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

507

494

"enabled")

508

495

509

# Uppercase and remove spaces from fingerprint for later

510

# comparison purposes with return value from the

511

# fingerprint() function

512

496

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

513

497

.replace(" ", ""))

514

498

if "secret" in section:

519

503

"rb") as secfile:

520

504

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

521

505

else:

522

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

506

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

523

507

.format(section))

524

508

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

525

509

client["extended_timeout"] = string_to_delta(

536

520

537

521

return settings

538

522

539

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

523

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

540

524

self.name = name

541

if server_settings is None:

542

server_settings = {}

543

self.server_settings = server_settings

544

525

# adding all client settings

545

for setting, value in settings.items():

526

for setting, value in settings.iteritems():

546

527

setattr(self, setting, value)

547

528

548

529

if self.enabled:

556

537

self.expires = None

557

538

558

539

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

540

# Uppercase and remove spaces from fingerprint for later

541

# comparison purposes with return value from the fingerprint()

542

# function

559

543

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

560

544

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

561

545

datetime.datetime.utcnow())

568

552

self.current_checker_command = None

569

553

self.approved = None

570

554

self.approvals_pending = 0

571

self.changedstate = multiprocessing_manager.Condition(

572

multiprocessing_manager.Lock())

573

self.client_structure = [attr

574

for attr in self.__dict__.iterkeys()

555

self.changedstate = (multiprocessing_manager

556

.Condition(multiprocessing_manager

557

.Lock()))

558

self.client_structure = [attr for attr in

559

self.__dict__.iterkeys()

575

560

if not attr.startswith("_")]

576

561

self.client_structure.append("client_structure")

577

562

578

for name, t in inspect.getmembers(

579

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

563

for name, t in inspect.getmembers(type(self),

564

lambda obj:

565

isinstance(obj,

566

property)):

580

567

if not name.startswith("_"):

581

568

self.client_structure.append(name)

582

569

624

611

# and every interval from then on.

625

612

if self.checker_initiator_tag is not None:

626

613

gobject.source_remove(self.checker_initiator_tag)

627

self.checker_initiator_tag = gobject.timeout_add(

628

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

629

self.start_checker)

614

self.checker_initiator_tag = (gobject.timeout_add

615

(self.interval_milliseconds(),

616

self.start_checker))

630

617

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

631

618

if self.disable_initiator_tag is not None:

632

619

gobject.source_remove(self.disable_initiator_tag)

633

self.disable_initiator_tag = gobject.timeout_add(

634

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

620

self.disable_initiator_tag = (gobject.timeout_add

621

(self.timeout_milliseconds(),

622

self.disable))

635

623

# Also start a new checker *right now*.

636

624

self.start_checker()

637

625

646

634

vars(self))

647

635

self.checked_ok()

648

636

else:

649

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

637

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

638

vars(self))

650

639

else:

651

640

self.last_checker_status = -1

652

641

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

666

655

gobject.source_remove(self.disable_initiator_tag)

667

656

self.disable_initiator_tag = None

668

657

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

669

self.disable_initiator_tag = gobject.timeout_add(

670

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

658

self.disable_initiator_tag = (gobject.timeout_add

659

(timedelta_to_milliseconds

660

(timeout), self.disable))

671

661

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

672

662

673

663

def need_approval(self):

690

680

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

691

681

try:

692

682

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

693

except AttributeError:

694

pass

695

except OSError as error:

696

if error.errno != errno.ECHILD:

697

raise

683

except (AttributeError, OSError) as error:

684

if (isinstance(error, OSError)

685

and error.errno != errno.ECHILD):

686

raise error

698

687

else:

699

688

if pid:

700

689

logger.warning("Checker was a zombie")

704

693

# Start a new checker if needed

705

694

if self.checker is None:

706

695

# Escape attributes for the shell

707

escaped_attrs = {

708

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

709

for attr in self.runtime_expansions }

696

escaped_attrs = dict(

697

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

698

for attr in

699

self.runtime_expansions)

710

700

try:

711

701

command = self.checker_command % escaped_attrs

712

702

except TypeError as error:

713

703

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

714

self.checker_command,

715

exc_info=error)

716

return True # Try again later

704

self.checker_command, exc_info=error)

705

return True # Try again later

717

706

self.current_checker_command = command

718

707

try:

719

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

720

self.name)

708

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

709

command, self.name)

721

710

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

722

711

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

723

712

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

724

713

# always replaced by /dev/null.)

725

# The exception is when not debugging but nevertheless

726

# running in the foreground; use the previously

727

# created wnull.

728

popen_args = {}

729

if (not self.server_settings["debug"]

730

and self.server_settings["foreground"]):

731

popen_args.update({"stdout": wnull,

732

"stderr": wnull })

733

714

self.checker = subprocess.Popen(command,

734

715

close_fds=True,

735

shell=True,

736

cwd="/",

737

**popen_args)

716

shell=True, cwd="/")

738

717

except OSError as error:

739

718

logger.error("Failed to start subprocess",

740

719

exc_info=error)

741

return True

742

self.checker_callback_tag = gobject.child_watch_add(

743

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

720

self.checker_callback_tag = (gobject.child_watch_add

721

(self.checker.pid,

722

self.checker_callback,

723

data=command))

744

724

# The checker may have completed before the gobject

745

725

# watch was added. Check for this.

746

try:

747

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

748

except OSError as error:

749

if error.errno == errno.ECHILD:

750

# This should never happen

751

logger.error("Child process vanished",

752

exc_info=error)

753

return True

754

raise

726

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

755

727

if pid:

756

728

gobject.source_remove(self.checker_callback_tag)

757

729

self.checker_callback(pid, status, command)

777

749

self.checker = None

778

750

779

751

780

def dbus_service_property(dbus_interface,

781

signature="v",

782

access="readwrite",

783

byte_arrays=False):

752

def dbus_service_property(dbus_interface, signature="v",

753

access="readwrite", byte_arrays=False):

784

754

"""Decorators for marking methods of a DBusObjectWithProperties to

785

755

become properties on the D-Bus.

786

756

795

765

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

796

766

if byte_arrays and signature != "ay":

797

767

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

798

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

799

768

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

800

769

def decorator(func):

801

770

func._dbus_is_property = True

802

771

func._dbus_interface = dbus_interface

807

776

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

808

777

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

809

778

return func

810

811

779

return decorator

812

780

813

781

822

790

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

823

791

"false"}

824

792

"""

825

826

793

def decorator(func):

827

794

func._dbus_is_interface = True

828

795

func._dbus_interface = dbus_interface

829

796

func._dbus_name = dbus_interface

830

797

return func

831

832

798

return decorator

833

799

834

800

836

802

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

837

803

Usage:

838

804

839

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

840

"org.freedesktop.DBus.Property."

841

"EmitsChangedSignal": "false"})

842

805

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

843

806

access="r")

807

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

808

"org.freedesktop.DBus.Property."

809

"EmitsChangedSignal": "false"})

844

810

def Property_dbus_property(self):

845

811

return dbus.Boolean(False)

846

812

"""

847

848

813

def decorator(func):

849

814

func._dbus_annotations = annotations

850

815

return func

851

852

816

return decorator

853

817

854

818

855

819

class DBusPropertyException(dbus.exceptions.DBusException):

856

820

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

857

821

"""

858

pass

822

def __unicode__(self):

823

return unicode(str(self))

859

824

860

825

861

826

class DBusPropertyAccessException(DBusPropertyException):

885

850

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

886

851

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

887

852

"""

888

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

853

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

889

854

False)

890

855

891

856

def _get_all_dbus_things(self, thing):

892

857

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

893

858

"""

894

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

859

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

860

name),

895

861

athing.__get__(self))

896

862

for cls in self.__class__.__mro__

897

863

for name, athing in

898

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

864

inspect.getmembers(cls,

865

self._is_dbus_thing(thing)))

899

866

900

867

def _get_dbus_property(self, interface_name, property_name):

901

868

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

902

869

property with the specified name and interface.

903

870

"""

904

for cls in self.__class__.__mro__:

905

for name, value in inspect.getmembers(

906

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

871

for cls in self.__class__.__mro__:

872

for name, value in (inspect.getmembers

873

(cls,

874

self._is_dbus_thing("property"))):

907

875

if (value._dbus_name == property_name

908

876

and value._dbus_interface == interface_name):

909

877

return value.__get__(self)

910

878

911

879

# No such property

912

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

913

self.dbus_object_path, interface_name, property_name))

880

raise DBusPropertyNotFound(self.dbus_object_path + ":"

881

+ interface_name + "."

882

+ property_name)

914

883

915

@dbus.service.method(dbus.PROPERTIES_IFACE,

916

in_signature="ss",

884

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

917

885

out_signature="v")

918

886

def Get(self, interface_name, property_name):

919

887

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

937

905

# The byte_arrays option is not supported yet on

938

906

# signatures other than "ay".

939

907

if prop._dbus_signature != "ay":

940

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

941

"'ay' signature {!r}"

942

.format(prop._dbus_signature))

908

raise ValueError

943

909

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

944

910

for byte in value))

945

911

prop(value)

946

912

947

@dbus.service.method(dbus.PROPERTIES_IFACE,

948

in_signature="s",

913

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

949

914

out_signature="a{sv}")

950

915

def GetAll(self, interface_name):

951

916

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

966

931

if not hasattr(value, "variant_level"):

967

932

properties[name] = value

968

933

continue

969

properties[name] = type(value)(

970

value, variant_level = value.variant_level + 1)

934

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

935

value.variant_level+1)

971

936

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

972

937

973

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

974

def PropertiesChanged(self, interface_name, changed_properties,

975

invalidated_properties):

976

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

977

standard.

978

"""

979

pass

980

981

938

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

982

939

out_signature="s",

983

940

path_keyword='object_path',

991

948

connection)

992

949

try:

993

950

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

994

995

951

def make_tag(document, name, prop):

996

952

e = document.createElement("property")

997

953

e.setAttribute("name", name)

998

954

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

999

955

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

1000

956

return e

1001

1002

957

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

1003

958

# Add property tags

1004

959

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

1016

971

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

1017

972

and prop._dbus_interface

1018

973

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

1019

annots.update(getattr(

1020

prop, "_dbus_annotations", {}))

1021

for name, value in annots.items():

974

annots.update(getattr

975

(prop,

976

"_dbus_annotations",

977

{}))

978

for name, value in annots.iteritems():

1022

979

ann_tag = document.createElement(

1023

980

"annotation")

1024

981

ann_tag.setAttribute("name", name)

1027

984

# Add interface annotation tags

1028

985

for annotation, value in dict(

1029

986

itertools.chain.from_iterable(

1030

annotations().items()

1031

for name, annotations

1032

in self._get_all_dbus_things("interface")

987

annotations().iteritems()

988

for name, annotations in

989

self._get_all_dbus_things("interface")

1033

990

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

1034

)).items():

991

)).iteritems():

1035

992

ann_tag = document.createElement("annotation")

1036

993

ann_tag.setAttribute("name", annotation)

1037

994

ann_tag.setAttribute("value", value)

1064

1021

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

1065

1022

if dt is None:

1066

1023

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

1067

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

1024

return dbus.String(dt.isoformat(),

1025

variant_level=variant_level)

1068

1026

1069

1027

1070

1028

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1090

1048

(from DBusObjectWithProperties) and interfaces (from the

1091

1049

dbus_interface_annotations decorator).

1092

1050

"""

1093

1094

1051

def wrapper(cls):

1095

1052

for orig_interface_name, alt_interface_name in (

1096

alt_interface_names.items()):

1053

alt_interface_names.iteritems()):

1097

1054

attr = {}

1098

1055

interface_names = set()

1099

1056

# Go though all attributes of the class

1101

1058

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

1102

1059

# with the wrong interface name

1103

1060

if (not hasattr(attribute, "_dbus_interface")

1104

or not attribute._dbus_interface.startswith(

1105

orig_interface_name)):

1061

or not attribute._dbus_interface

1062

.startswith(orig_interface_name)):

1106

1063

continue

1107

1064

# Create an alternate D-Bus interface name based on

1108

1065

# the current name

1109

alt_interface = attribute._dbus_interface.replace(

1110

orig_interface_name, alt_interface_name)

1066

alt_interface = (attribute._dbus_interface

1067

.replace(orig_interface_name,

1068

alt_interface_name))

1111

1069

interface_names.add(alt_interface)

1112

1070

# Is this a D-Bus signal?

1113

1071

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

1114

if sys.version == 2:

1115

# Extract the original non-method undecorated

1116

# function by black magic

1117

nonmethod_func = (dict(

1072

# Extract the original non-method function by

1073

# black magic

1074

nonmethod_func = (dict(

1118

1075

zip(attribute.func_code.co_freevars,

1119

attribute.__closure__))

1120

["func"].cell_contents)

1121

else:

1122

nonmethod_func = attribute

1076

attribute.__closure__))["func"]

1077

.cell_contents)

1123

1078

# Create a new, but exactly alike, function

1124

1079

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

1125

1080

# with the alternate D-Bus interface name

1126

if sys.version == 2:

1127

new_function = types.FunctionType(

1128

nonmethod_func.func_code,

1129

nonmethod_func.func_globals,

1130

nonmethod_func.func_name,

1131

nonmethod_func.func_defaults,

1132

nonmethod_func.func_closure)

1133

else:

1134

new_function = types.FunctionType(

1135

nonmethod_func.__code__,

1136

nonmethod_func.__globals__,

1137

nonmethod_func.__name__,

1138

nonmethod_func.__defaults__,

1139

nonmethod_func.__closure__)

1140

new_function = (dbus.service.signal(

1141

alt_interface,

1142

attribute._dbus_signature)(new_function))

1081

new_function = (dbus.service.signal

1082

(alt_interface,

1083

attribute._dbus_signature)

1084

(types.FunctionType(

1085

nonmethod_func.func_code,

1086

nonmethod_func.func_globals,

1087

nonmethod_func.func_name,

1088

nonmethod_func.func_defaults,

1089

nonmethod_func.func_closure)))

1143

1090

# Copy annotations, if any

1144

1091

try:

1145

new_function._dbus_annotations = dict(

1146

attribute._dbus_annotations)

1092

new_function._dbus_annotations = (

1093

dict(attribute._dbus_annotations))

1147

1094

except AttributeError:

1148

1095

pass

1149

1096

# Define a creator of a function to call both the

1154

1101

"""This function is a scope container to pass

1155

1102

func1 and func2 to the "call_both" function

1156

1103

outside of its arguments"""

1157

1158

1104

def call_both(*args, **kwargs):

1159

1105

"""This function will emit two D-Bus

1160

1106

signals by calling func1 and func2"""

1161

1107

func1(*args, **kwargs)

1162

1108

func2(*args, **kwargs)

1163

1164

1109

return call_both

1165

1110

# Create the "call_both" function and add it to

1166

1111

# the class

1171

1116

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

1172

1117

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

1173

1118

# to the class.

1174

attr[attrname] = (

1175

dbus.service.method(

1176

alt_interface,

1177

attribute._dbus_in_signature,

1178

attribute._dbus_out_signature)

1179

(types.FunctionType(attribute.func_code,

1180

attribute.func_globals,

1181

attribute.func_name,

1182

attribute.func_defaults,

1183

attribute.func_closure)))

1119

attr[attrname] = (dbus.service.method

1120

(alt_interface,

1121

attribute._dbus_in_signature,

1122

attribute._dbus_out_signature)

1123

(types.FunctionType

1124

(attribute.func_code,

1125

attribute.func_globals,

1126

attribute.func_name,

1127

attribute.func_defaults,

1128

attribute.func_closure)))

1184

1129

# Copy annotations, if any

1185

1130

try:

1186

attr[attrname]._dbus_annotations = dict(

1187

attribute._dbus_annotations)

1131

attr[attrname]._dbus_annotations = (

1132

dict(attribute._dbus_annotations))

1188

1133

except AttributeError:

1189

1134

pass

1190

1135

# Is this a D-Bus property?

1193

1138

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

1194

1139

# property with the alternate D-Bus interface

1195

1140

# name. Add it to the class.

1196

attr[attrname] = (dbus_service_property(

1197

alt_interface, attribute._dbus_signature,

1198

attribute._dbus_access,

1199

attribute._dbus_get_args_options

1200

["byte_arrays"])

1201

(types.FunctionType(

1202

attribute.func_code,

1203

attribute.func_globals,

1204

attribute.func_name,

1205

attribute.func_defaults,

1206

attribute.func_closure)))

1141

attr[attrname] = (dbus_service_property

1142

(alt_interface,

1143

attribute._dbus_signature,

1144

attribute._dbus_access,

1145

attribute

1146

._dbus_get_args_options

1147

["byte_arrays"])

1148

(types.FunctionType

1149

(attribute.func_code,

1150

attribute.func_globals,

1151

attribute.func_name,

1152

attribute.func_defaults,

1153

attribute.func_closure)))

1207

1154

# Copy annotations, if any

1208

1155

try:

1209

attr[attrname]._dbus_annotations = dict(

1210

attribute._dbus_annotations)

1156

attr[attrname]._dbus_annotations = (

1157

dict(attribute._dbus_annotations))

1211

1158

except AttributeError:

1212

1159

pass

1213

1160

# Is this a D-Bus interface?

1216

1163

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

1217

1164

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

1218

1165

# to the class.

1219

attr[attrname] = (

1220

dbus_interface_annotations(alt_interface)

1221

(types.FunctionType(attribute.func_code,

1222

attribute.func_globals,

1223

attribute.func_name,

1224

attribute.func_defaults,

1225

attribute.func_closure)))

1166

attr[attrname] = (dbus_interface_annotations

1167

(alt_interface)

1168

(types.FunctionType

1169

(attribute.func_code,

1170

attribute.func_globals,

1171

attribute.func_name,

1172

attribute.func_defaults,

1173

attribute.func_closure)))

1226

1174

if deprecate:

1227

1175

# Deprecate all alternate interfaces

1228

iname="_AlternateDBusNames_interface_annotation{}"

1176

iname="_AlternateDBusNames_interface_annotation{0}"

1229

1177

for interface_name in interface_names:

1230

1231

1178

@dbus_interface_annotations(interface_name)

1232

1179

def func(self):

1233

1180

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

1234

"true" }

1181

"true" }

1235

1182

# Find an unused name

1236

1183

for aname in (iname.format(i)

1237

1184

for i in itertools.count()):

1241

1188

if interface_names:

1242

1189

# Replace the class with a new subclass of it with

1243

1190

# methods, signals, etc. as created above.

1244

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

1245

(cls, ), attr)

1191

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

1192

(cls,), attr)

1246

1193

return cls

1247

1248

1194

return wrapper

1249

1195

1250

1196

1251

1197

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

1252

"se.bsnet.fukt.Mandos"})

1198

"se.bsnet.fukt.Mandos"})

1253

1199

class ClientDBus(Client, DBusObjectWithProperties):

1254

1200

"""A Client class using D-Bus

1255

1201

1259

1205

"""

1260

1206

1261

1207

runtime_expansions = (Client.runtime_expansions

1262

+ ("dbus_object_path", ))

1263

1264

_interface = "se.recompile.Mandos.Client"

1208

+ ("dbus_object_path",))

1265

1209

1266

1210

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

1267

1211

1270

1214

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

1271

1215

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

1272

1216

# the D-Bus

1273

client_object_name = str(self.name).translate(

1217

client_object_name = unicode(self.name).translate(

1274

1218

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

1275

1219

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

1276

self.dbus_object_path = dbus.ObjectPath(

1277

"/clients/" + client_object_name)

1220

self.dbus_object_path = (dbus.ObjectPath

1221

("/clients/" + client_object_name))

1278

1222

DBusObjectWithProperties.__init__(self, self.bus,

1279

1223

self.dbus_object_path)

1280

1224

1281

def notifychangeproperty(transform_func, dbus_name,

1282

type_func=lambda x: x,

1283

variant_level=1,

1284

invalidate_only=False,

1285

_interface=_interface):

1225

def notifychangeproperty(transform_func,

1226

dbus_name, type_func=lambda x: x,

1227

variant_level=1):

1286

1228

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

1287

1229

its changes to DBus.

1288

1230

1293

1235

to the D-Bus. Default: no transform

1294

1236

variant_level: D-Bus variant level. Default: 1

1295

1237

"""

1296

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

1297

1238

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

1298

1239

def setter(self, value):

1299

1240

if hasattr(self, "dbus_object_path"):

1300

1241

if (not hasattr(self, attrname) or

1301

1242

type_func(getattr(self, attrname, None))

1302

1243

!= type_func(value)):

1303

if invalidate_only:

1304

self.PropertiesChanged(

1305

_interface, dbus.Dictionary(),

1306

dbus.Array((dbus_name, )))

1307

else:

1308

dbus_value = transform_func(

1309

type_func(value),

1310

variant_level = variant_level)

1311

self.PropertyChanged(dbus.String(dbus_name),

1312

dbus_value)

1313

self.PropertiesChanged(

1314

_interface,

1315

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

1316

dbus_value }),

1317

dbus.Array())

1244

dbus_value = transform_func(type_func(value),

1245

variant_level

1246

=variant_level)

1247

self.PropertyChanged(dbus.String(dbus_name),

1248

dbus_value)

1318

1249

setattr(self, attrname, value)

1319

1250

1320

1251

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

1326

1257

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

1327

1258

last_enabled = notifychangeproperty(datetime_to_dbus,

1328

1259

"LastEnabled")

1329

checker = notifychangeproperty(

1330

dbus.Boolean, "CheckerRunning",

1331

type_func = lambda checker: checker is not None)

1260

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

1261

type_func = lambda checker:

1262

checker is not None)

1332

1263

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1333

1264

"LastCheckedOK")

1334

1265

last_checker_status = notifychangeproperty(dbus.Int16,

1337

1268

datetime_to_dbus, "LastApprovalRequest")

1338

1269

approved_by_default = notifychangeproperty(dbus.Boolean,

1339

1270

"ApprovedByDefault")

1340

approval_delay = notifychangeproperty(

1341

dbus.UInt64, "ApprovalDelay",

1342

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

1271

approval_delay = notifychangeproperty(dbus.UInt64,

1272

"ApprovalDelay",

1273

type_func =

1274

timedelta_to_milliseconds)

1343

1275

approval_duration = notifychangeproperty(

1344

1276

dbus.UInt64, "ApprovalDuration",

1345

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

1277

type_func = timedelta_to_milliseconds)

1346

1278

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

1347

timeout = notifychangeproperty(

1348

dbus.UInt64, "Timeout",

1349

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

1279

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

1280

type_func =

1281

timedelta_to_milliseconds)

1350

1282

extended_timeout = notifychangeproperty(

1351

1283

dbus.UInt64, "ExtendedTimeout",

1352

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

1353

interval = notifychangeproperty(

1354

dbus.UInt64, "Interval",

1355

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

1284

type_func = timedelta_to_milliseconds)

1285

interval = notifychangeproperty(dbus.UInt64,

1286

"Interval",

1287

type_func =

1288

timedelta_to_milliseconds)

1356

1289

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

1357

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

1358

invalidate_only=True)

1359

1290

1360

1291

del notifychangeproperty

1361

1292

1388

1319

*args, **kwargs)

1389

1320

1390

1321

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

1391

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

1322

old_checker = self.checker

1323

if self.checker is not None:

1324

old_checker_pid = self.checker.pid

1325

else:

1326

old_checker_pid = None

1392

1327

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

1393

1328

# Only if new checker process was started

1394

1329

if (self.checker is not None

1403

1338

1404

1339

def approve(self, value=True):

1405

1340

self.approved = value

1406

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

1407

* 1000), self._reset_approved)

1341

gobject.timeout_add(timedelta_to_milliseconds

1342

(self.approval_duration),

1343

self._reset_approved)

1408

1344

self.send_changedstate()

1409

1345

1410

1346

## D-Bus methods, signals & properties

1347

_interface = "se.recompile.Mandos.Client"

1411

1348

1412

1349

## Interfaces

1413

1350

1351

@dbus_interface_annotations(_interface)

1352

def _foo(self):

1353

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

1354

"false"}

1355

1414

1356

## Signals

1415

1357

1416

1358

# CheckerCompleted - signal

1426

1368

pass

1427

1369

1428

1370

# PropertyChanged - signal

1429

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

1430

1371

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

1431

1372

def PropertyChanged(self, property, value):

1432

1373

"D-Bus signal"

1496

1437

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

1497

1438

1498

1439

# ApprovedByDefault - property

1499

@dbus_service_property(_interface,

1500

signature="b",

1440

@dbus_service_property(_interface, signature="b",

1501

1441

access="readwrite")

1502

1442

def ApprovedByDefault_dbus_property(self, value=None):

1503

1443

if value is None: # get

1505

1445

self.approved_by_default = bool(value)

1506

1446

1507

1447

# ApprovalDelay - property

1508

@dbus_service_property(_interface,

1509

signature="t",

1448

@dbus_service_property(_interface, signature="t",

1510

1449

access="readwrite")

1511

1450

def ApprovalDelay_dbus_property(self, value=None):

1512

1451

if value is None: # get

1513

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

1514

* 1000)

1452

return dbus.UInt64(self.approval_delay_milliseconds())

1515

1453

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

1516

1454

1517

1455

# ApprovalDuration - property

1518

@dbus_service_property(_interface,

1519

signature="t",

1456

@dbus_service_property(_interface, signature="t",

1520

1457

access="readwrite")

1521

1458

def ApprovalDuration_dbus_property(self, value=None):

1522

1459

if value is None: # get

1523

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

1524

* 1000)

1460

return dbus.UInt64(timedelta_to_milliseconds(

1461

self.approval_duration))

1525

1462

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

1526

1463

1527

1464

# Name - property

1535

1472

return dbus.String(self.fingerprint)

1536

1473

1537

1474

# Host - property

1538

@dbus_service_property(_interface,

1539

signature="s",

1475

@dbus_service_property(_interface, signature="s",

1540

1476

access="readwrite")

1541

1477

def Host_dbus_property(self, value=None):

1542

1478

if value is None: # get

1543

1479

return dbus.String(self.host)

1544

self.host = str(value)

1480

self.host = unicode(value)

1545

1481

1546

1482

# Created - property

1547

1483

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

1554

1490

return datetime_to_dbus(self.last_enabled)

1555

1491

1556

1492

# Enabled - property

1557

@dbus_service_property(_interface,

1558

signature="b",

1493

@dbus_service_property(_interface, signature="b",

1559

1494

access="readwrite")

1560

1495

def Enabled_dbus_property(self, value=None):

1561

1496

if value is None: # get

1566

1501

self.disable()

1567

1502

1568

1503

# LastCheckedOK - property

1569

@dbus_service_property(_interface,

1570

signature="s",

1504

@dbus_service_property(_interface, signature="s",

1571

1505

access="readwrite")

1572

1506

def LastCheckedOK_dbus_property(self, value=None):

1573

1507

if value is not None:

1576

1510

return datetime_to_dbus(self.last_checked_ok)

1577

1511

1578

1512

# LastCheckerStatus - property

1579

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

1513

@dbus_service_property(_interface, signature="n",

1514

access="read")

1580

1515

def LastCheckerStatus_dbus_property(self):

1581

1516

return dbus.Int16(self.last_checker_status)

1582

1517

1591

1526

return datetime_to_dbus(self.last_approval_request)

1592

1527

1593

1528

# Timeout - property

1594

@dbus_service_property(_interface,

1595

signature="t",

1529

@dbus_service_property(_interface, signature="t",

1596

1530

access="readwrite")

1597

1531

def Timeout_dbus_property(self, value=None):

1598

1532

if value is None: # get

1599

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

1533

return dbus.UInt64(self.timeout_milliseconds())

1600

1534

old_timeout = self.timeout

1601

1535

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

1602

1536

# Reschedule disabling

1611

1545

is None):

1612

1546

return

1613

1547

gobject.source_remove(self.disable_initiator_tag)

1614

self.disable_initiator_tag = gobject.timeout_add(

1615

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

1616

self.disable)

1548

self.disable_initiator_tag = (

1549

gobject.timeout_add(

1550

timedelta_to_milliseconds(self.expires - now),

1551

self.disable))

1617

1552

1618

1553

# ExtendedTimeout - property

1619

@dbus_service_property(_interface,

1620

signature="t",

1554

@dbus_service_property(_interface, signature="t",

1621

1555

access="readwrite")

1622

1556

def ExtendedTimeout_dbus_property(self, value=None):

1623

1557

if value is None: # get

1624

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

1625

* 1000)

1558

return dbus.UInt64(self.extended_timeout_milliseconds())

1626

1559

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

1627

1560

1628

1561

# Interval - property

1629

@dbus_service_property(_interface,

1630

signature="t",

1562

@dbus_service_property(_interface, signature="t",

1631

1563

access="readwrite")

1632

1564

def Interval_dbus_property(self, value=None):

1633

1565

if value is None: # get

1634

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

1566

return dbus.UInt64(self.interval_milliseconds())

1635

1567

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

1636

1568

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

1637

1569

return

1638

1570

if self.enabled:

1639

1571

# Reschedule checker run

1640

1572

gobject.source_remove(self.checker_initiator_tag)

1641

self.checker_initiator_tag = gobject.timeout_add(

1642

value, self.start_checker)

1643

self.start_checker() # Start one now, too

1573

self.checker_initiator_tag = (gobject.timeout_add

1574

(value, self.start_checker))

1575

self.start_checker() # Start one now, too

1644

1576

1645

1577

# Checker - property

1646

@dbus_service_property(_interface,

1647

signature="s",

1578

@dbus_service_property(_interface, signature="s",

1648

1579

access="readwrite")

1649

1580

def Checker_dbus_property(self, value=None):

1650

1581

if value is None: # get

1651

1582

return dbus.String(self.checker_command)

1652

self.checker_command = str(value)

1583

self.checker_command = unicode(value)

1653

1584

1654

1585

# CheckerRunning - property

1655

@dbus_service_property(_interface,

1656

signature="b",

1586

@dbus_service_property(_interface, signature="b",

1657

1587

access="readwrite")

1658

1588

def CheckerRunning_dbus_property(self, value=None):

1659

1589

if value is None: # get

1669

1599

return self.dbus_object_path # is already a dbus.ObjectPath

1670

1600

1671

1601

# Secret = property

1672

@dbus_service_property(_interface,

1673

signature="ay",

1674

access="write",

1675

byte_arrays=True)

1602

@dbus_service_property(_interface, signature="ay",

1603

access="write", byte_arrays=True)

1676

1604

def Secret_dbus_property(self, value):

1677

self.secret = bytes(value)

1605

self.secret = str(value)

1678

1606

1679

1607

del _interface

1680

1608

1684

1612

self._pipe = child_pipe

1685

1613

self._pipe.send(('init', fpr, address))

1686

1614

if not self._pipe.recv():

1687

raise KeyError(fpr)

1615

raise KeyError()

1688

1616

1689

1617

def __getattribute__(self, name):

1690

1618

if name == '_pipe':

1694

1622

if data[0] == 'data':

1695

1623

return data[1]

1696

1624

if data[0] == 'function':

1697

1698

1625

def func(*args, **kwargs):

1699

1626

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

1700

1627

return self._pipe.recv()[1]

1701

1702

1628

return func

1703

1629

1704

1630

def __setattr__(self, name, value):

1716

1642

def handle(self):

1717

1643

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

1718

1644

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

1719

str(self.client_address))

1645

unicode(self.client_address))

1720

1646

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

1721

1647

self.server.child_pipe.fileno())

1722

1648

1723

session = gnutls.connection.ClientSession(

1724

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

1649

session = (gnutls.connection

1650

.ClientSession(self.request,

1651

gnutls.connection

1652

.X509Credentials()))

1725

1653

1726

1654

# Note: gnutls.connection.X509Credentials is really a

1727

1655

# generic GnuTLS certificate credentials object so long as

1736

1664

priority = self.server.gnutls_priority

1737

1665

if priority is None:

1738

1666

priority = "NORMAL"

1739

gnutls.library.functions.gnutls_priority_set_direct(

1740

session._c_object, priority, None)

1667

(gnutls.library.functions

1668

.gnutls_priority_set_direct(session._c_object,

1669

priority, None))

1741

1670

1742

1671

# Start communication using the Mandos protocol

1743

1672

# Get protocol number

1745

1674

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

1746

1675

try:

1747

1676

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

1748

raise RuntimeError(line)

1677

raise RuntimeError

1749

1678

except (ValueError, IndexError, RuntimeError) as error:

1750

1679

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

1751

1680

return

1763

1692

approval_required = False

1764

1693

try:

1765

1694

try:

1766

fpr = self.fingerprint(

1767

self.peer_certificate(session))

1695

fpr = self.fingerprint(self.peer_certificate

1696

(session))

1768

1697

except (TypeError,

1769

1698

gnutls.errors.GNUTLSError) as error:

1770

1699

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

1785

1714

while True:

1786

1715

if not client.enabled:

1787

1716

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

1788

client.name)

1717

client.name)

1789

1718

if self.server.use_dbus:

1790

1719

# Emit D-Bus signal

1791

1720

client.Rejected("Disabled")

1800

1729

if self.server.use_dbus:

1801

1730

# Emit D-Bus signal

1802

1731

client.NeedApproval(

1803

client.approval_delay.total_seconds()

1804

* 1000, client.approved_by_default)

1732

client.approval_delay_milliseconds(),

1733

client.approved_by_default)

1805

1734

else:

1806

1735

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

1807

1736

client.name)

1813

1742

#wait until timeout or approved

1814

1743

time = datetime.datetime.now()

1815

1744

client.changedstate.acquire()

1816

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

1745

client.changedstate.wait(

1746

float(timedelta_to_milliseconds(delay)

1747

/ 1000))

1817

1748

client.changedstate.release()

1818

1749

time2 = datetime.datetime.now()

1819

1750

if (time2 - time) >= delay:

1838

1769

logger.warning("gnutls send failed",

1839

1770

exc_info=error)

1840

1771

return

1841

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

1842

len(client.secret) - (sent_size

1843

+ sent))

1772

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

1773

sent, len(client.secret)

1774

- (sent_size + sent))

1844

1775

sent_size += sent

1845

1776

1846

1777

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

1863

1794

def peer_certificate(session):

1864

1795

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

1865

1796

# If not an OpenPGP certificate...

1866

if (gnutls.library.functions.gnutls_certificate_type_get(

1867

session._c_object)

1797

if (gnutls.library.functions

1798

.gnutls_certificate_type_get(session._c_object)

1868

1799

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1869

1800

# ...do the normal thing

1870

1801

return session.peer_certificate

1884

1815

def fingerprint(openpgp):

1885

1816

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

1886

1817

# New GnuTLS "datum" with the OpenPGP public key

1887

datum = gnutls.library.types.gnutls_datum_t(

1888

ctypes.cast(ctypes.c_char_p(openpgp),

1889

ctypes.POINTER(ctypes.c_ubyte)),

1890

ctypes.c_uint(len(openpgp)))

1818

datum = (gnutls.library.types

1819

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

1820

ctypes.POINTER

1821

(ctypes.c_ubyte)),

1822

ctypes.c_uint(len(openpgp))))

1891

1823

# New empty GnuTLS certificate

1892

1824

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1893

gnutls.library.functions.gnutls_openpgp_crt_init(

1894

ctypes.byref(crt))

1825

(gnutls.library.functions

1826

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

1895

1827

# Import the OpenPGP public key into the certificate

1896

gnutls.library.functions.gnutls_openpgp_crt_import(

1897

crt, ctypes.byref(datum),

1898

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

1828

(gnutls.library.functions

1829

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

1830

gnutls.library.constants

1831

.GNUTLS_OPENPGP_FMT_RAW))

1899

1832

# Verify the self signature in the key

1900

1833

crtverify = ctypes.c_uint()

1901

gnutls.library.functions.gnutls_openpgp_crt_verify_self(

1902

crt, 0, ctypes.byref(crtverify))

1834

(gnutls.library.functions

1835

.gnutls_openpgp_crt_verify_self(crt, 0,

1836

ctypes.byref(crtverify)))

1903

1837

if crtverify.value != 0:

1904

1838

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1905

raise gnutls.errors.CertificateSecurityError(

1906

"Verify failed")

1839

raise (gnutls.errors.CertificateSecurityError

1840

("Verify failed"))

1907

1841

# New buffer for the fingerprint

1908

1842

buf = ctypes.create_string_buffer(20)

1909

1843

buf_len = ctypes.c_size_t()

1910

1844

# Get the fingerprint from the certificate into the buffer

1911

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(

1912

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

1845

(gnutls.library.functions

1846

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

1847

ctypes.byref(buf_len)))

1913

1848

# Deinit the certificate

1914

1849

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1915

1850

# Convert the buffer to a Python bytestring

1921

1856

1922

1857

class MultiprocessingMixIn(object):

1923

1858

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

1924

1925

1859

def sub_process_main(self, request, address):

1926

1860

try:

1927

1861

self.finish_request(request, address)

1939

1873

1940

1874

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1941

1875

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

1942

1943

1876

def process_request(self, request, client_address):

1944

1877

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

1945

1878

1954

1887

1955

1888

def add_pipe(self, parent_pipe, proc):

1956

1889

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

1957

raise NotImplementedError()

1890

raise NotImplementedError

1958

1891

1959

1892

1960

1893

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1966

1899

interface: None or a network interface name (string)

1967

1900

use_ipv6: Boolean; to use IPv6 or not

1968

1901

"""

1969

1970

1902

def __init__(self, server_address, RequestHandlerClass,

1971

interface=None,

1972

use_ipv6=True,

1973

socketfd=None):

1903

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

1974

1904

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

1975

1905

creating a new one with socket.socket().

1976

1906

"""

2017

1947

self.interface)

2018

1948

else:

2019

1949

try:

2020

self.socket.setsockopt(

2021

socket.SOL_SOCKET, SO_BINDTODEVICE,

2022

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

1950

self.socket.setsockopt(socket.SOL_SOCKET,

1951

SO_BINDTODEVICE,

1952

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

2023

1953

except socket.error as error:

2024

1954

if error.errno == errno.EPERM:

2025

1955

logger.error("No permission to bind to"

2039

1969

if self.address_family == socket.AF_INET6:

2040

1970

any_address = "::" # in6addr_any

2041

1971

else:

2042

any_address = "0.0.0.0" # INADDR_ANY

1972

any_address = socket.INADDR_ANY

2043

1973

self.server_address = (any_address,

2044

1974

self.server_address[1])

2045

1975

elif not self.server_address[1]:

2046

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

1976

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

1977

0)

2047

1978

# if self.interface:

2048

1979

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

2049

1980

# 0, # port

2063

1994

2064

1995

Assumes a gobject.MainLoop event loop.

2065

1996

"""

2066

2067

1997

def __init__(self, server_address, RequestHandlerClass,

2068

interface=None,

2069

use_ipv6=True,

2070

clients=None,

2071

gnutls_priority=None,

2072

use_dbus=True,

2073

socketfd=None):

1998

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

1999

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

2074

2000

self.enabled = False

2075

2001

self.clients = clients

2076

2002

if self.clients is None:

2082

2008

interface = interface,

2083

2009

use_ipv6 = use_ipv6,

2084

2010

socketfd = socketfd)

2085

2086

2011

def server_activate(self):

2087

2012

if self.enabled:

2088

2013

return socketserver.TCPServer.server_activate(self)

2092

2017

2093

2018

def add_pipe(self, parent_pipe, proc):

2094

2019

# Call "handle_ipc" for both data and EOF events

2095

gobject.io_add_watch(

2096

parent_pipe.fileno(),

2097

gobject.IO_IN | gobject.IO_HUP,

2098

functools.partial(self.handle_ipc,

2099

parent_pipe = parent_pipe,

2100

proc = proc))

2020

gobject.io_add_watch(parent_pipe.fileno(),

2021

gobject.IO_IN | gobject.IO_HUP,

2022

functools.partial(self.handle_ipc,

2023

parent_pipe =

2024

parent_pipe,

2025

proc = proc))

2101

2026

2102

def handle_ipc(self, source, condition,

2103

parent_pipe=None,

2104

proc = None,

2105

client_object=None):

2027

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

2028

proc = None, client_object=None):

2106

2029

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

2107

2030

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

2108

2031

# Wait for other process to exit

2131

2054

parent_pipe.send(False)

2132

2055

return False

2133

2056

2134

gobject.io_add_watch(

2135

parent_pipe.fileno(),

2136

gobject.IO_IN | gobject.IO_HUP,

2137

functools.partial(self.handle_ipc,

2138

parent_pipe = parent_pipe,

2139

proc = proc,

2140

client_object = client))

2057

gobject.io_add_watch(parent_pipe.fileno(),

2058

gobject.IO_IN | gobject.IO_HUP,

2059

functools.partial(self.handle_ipc,

2060

parent_pipe =

2061

parent_pipe,

2062

proc = proc,

2063

client_object =

2064

client))

2141

2065

parent_pipe.send(True)

2142

2066

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

2143

2067

# same fileno

2149

2073

2150

2074

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

2151

2075

funcname)(*args,

2152

**kwargs)))

2076

**kwargs)))

2153

2077

2154

2078

if command == 'getattr':

2155

2079

attrname = request[1]

2156

2080

if callable(client_object.__getattribute__(attrname)):

2157

parent_pipe.send(('function', ))

2081

parent_pipe.send(('function',))

2158

2082

else:

2159

parent_pipe.send((

2160

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

2083

parent_pipe.send(('data', client_object

2084

.__getattribute__(attrname)))

2161

2085

2162

2086

if command == 'setattr':

2163

2087

attrname = request[1]

2194

2118

# avoid excessive use of external libraries.

2195

2119

2196

2120

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

2197

Token = collections.namedtuple("Token", (

2198

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

2199

# a "group" containing digits

2200

"value", # datetime.timedelta or None

2201

"followers")) # Tokens valid after this token

2121

Token = collections.namedtuple("Token",

2122

("regexp", # To match token; if

2123

# "value" is not None,

2124

# must have a "group"

2125

# containing digits

2126

"value", # datetime.timedelta or

2127

# None

2128

"followers")) # Tokens valid after

2129

# this token

2202

2130

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

2203

2131

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

2204

2132

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

2205

2133

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

2206

2134

datetime.timedelta(seconds=1),

2207

frozenset((token_end, )))

2135

frozenset((token_end,)))

2208

2136

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

2209

2137

datetime.timedelta(minutes=1),

2210

2138

frozenset((token_second, token_end)))

2226

2154

frozenset((token_month, token_end)))

2227

2155

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

2228

2156

datetime.timedelta(weeks=1),

2229

frozenset((token_end, )))

2157

frozenset((token_end,)))

2230

2158

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

2231

2159

frozenset((token_year, token_month,

2232

2160

token_day, token_time,

2233

token_week)))

2161

token_week))),

2234

2162

# Define starting values

2235

2163

value = datetime.timedelta() # Value so far

2236

2164

found_token = None

2237

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

2165

followers = frozenset(token_duration,) # Following valid tokens

2238

2166

s = duration # String left to parse

2239

2167

# Loop until end token is found

2240

2168

while found_token is not token_end:

2257

2185

break

2258

2186

else:

2259

2187

# No currently valid tokens were found

2260

raise ValueError("Invalid RFC 3339 duration: {!r}"

2261

.format(duration))

2188

raise ValueError("Invalid RFC 3339 duration")

2262

2189

# End token found

2263

2190

return value

2264

2191

2288

2215

timevalue = datetime.timedelta(0)

2289

2216

for s in interval.split():

2290

2217

try:

2291

suffix = s[-1]

2218

suffix = unicode(s[-1])

2292

2219

value = int(s[:-1])

2293

2220

if suffix == "d":

2294

2221

delta = datetime.timedelta(value)

2301

2228

elif suffix == "w":

2302

2229

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

2303

2230

else:

2304

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

2305

except IndexError as e:

2231

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

2232

.format(suffix))

2233

except (ValueError, IndexError) as e:

2306

2234

raise ValueError(*(e.args))

2307

2235

timevalue += delta

2308

2236

return timevalue

2324

2252

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

2325

2253

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

2326

2254

raise OSError(errno.ENODEV,

2327

"{} not a character device"

2255

"{0} not a character device"

2328

2256

.format(os.devnull))

2329

2257

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

2330

2258

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

2340

2268

2341

2269

parser = argparse.ArgumentParser()

2342

2270

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

2343

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

2271

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

2344

2272

help="show version number and exit")

2345

2273

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

2346

2274

help="Bind to interface IF")

2352

2280

help="Run self-test")

2353

2281

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

2354

2282

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

2355

" to terminal", default=None)

2283

" to terminal")

2356

2284

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

2357

2285

help="Debug level for stdout output")

2358

2286

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

2365

2293

" files")

2366

2294

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

2367

2295

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

2368

" system bus interface", default=None)

2296

" system bus interface")

2369

2297

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

2370

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

2371

default=None)

2298

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

2372

2299

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

2373

2300

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

2374

" state", default=None)

2301

" state")

2375

2302

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

2376

2303

help="Specify a file descriptor to a network"

2377

2304

" socket to use instead of creating one")

2378

2305

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

2379

2306

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

2380

2307

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

2381

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

2382

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

2383

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

2384

default=None)

2308

help="Run in foreground")

2385

2309

2386

2310

options = parser.parse_args()

2387

2311

2388

2312

if options.check:

2389

2313

import doctest

2390

fail_count, test_count = doctest.testmod()

2391

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

2314

doctest.testmod()

2315

sys.exit()

2392

2316

2393

2317

# Default values for config file for server-global settings

2394

2318

server_defaults = { "interface": "",

2396

2320

"port": "",

2397

2321

"debug": "False",

2398

2322

"priority":

2399

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

2400

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

2323

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

2401

2324

"servicename": "Mandos",

2402

2325

"use_dbus": "True",

2403

2326

"use_ipv6": "True",

2406

2329

"socket": "",

2407

2330

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

2408

2331

"foreground": "False",

2409

"zeroconf": "True",

2410

}

2332

}

2411

2333

2412

2334

# Parse config file for server-global settings

2413

2335

server_config = configparser.SafeConfigParser(server_defaults)

2414

2336

del server_defaults

2415

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

2337

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

2338

"mandos.conf"))

2416

2339

# Convert the SafeConfigParser object to a dict

2417

2340

server_settings = server_config.defaults()

2418

2341

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

2436

2359

# Override the settings from the config file with command line

2437

2360

# options, if set.

2438

2361

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

2439

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

2440

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

2441

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

2362

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

2363

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

2364

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

2442

2365

value = getattr(options, option)

2443

2366

if value is not None:

2444

2367

server_settings[option] = value

2445

2368

del options

2446

2369

# Force all strings to be unicode

2447

2370

for option in server_settings.keys():

2448

if isinstance(server_settings[option], bytes):

2449

server_settings[option] = (server_settings[option]

2450

.decode("utf-8"))

2451

# Force all boolean options to be boolean

2452

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

2453

"foreground", "zeroconf"):

2454

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

2371

if type(server_settings[option]) is str:

2372

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

2455

2373

# Debug implies foreground

2456

2374

if server_settings["debug"]:

2457

2375

server_settings["foreground"] = True

2459

2377

2460

2378

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

2461

2379

2462

if (not server_settings["zeroconf"]

2463

and not (server_settings["port"]

2464

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

2465

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

2466

2467

2380

# For convenience

2468

2381

debug = server_settings["debug"]

2469

2382

debuglevel = server_settings["debuglevel"]

2472

2385

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

2473

2386

stored_state_file)

2474

2387

foreground = server_settings["foreground"]

2475

zeroconf = server_settings["zeroconf"]

2476

2388

2477

2389

if debug:

2478

2390

initlogger(debug, logging.DEBUG)

2484

2396

initlogger(debug, level)

2485

2397

2486

2398

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

2487

syslogger.setFormatter(

2488

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

2489

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

2490

server_settings["servicename"])))

2399

syslogger.setFormatter(logging.Formatter

2400

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

2401

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

2402

.format(server_settings

2403

["servicename"])))

2491

2404

2492

2405

# Parse config file with clients

2493

2406

client_config = configparser.SafeConfigParser(Client

2498

2411

global mandos_dbus_service

2499

2412

mandos_dbus_service = None

2500

2413

2501

socketfd = None

2502

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

2503

socketfd = server_settings["socket"]

2504

tcp_server = MandosServer(

2505

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

2506

ClientHandler,

2507

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

2508

use_ipv6=use_ipv6,

2509

gnutls_priority=server_settings["priority"],

2510

use_dbus=use_dbus,

2511

socketfd=socketfd)

2414

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

2415

server_settings["port"]),

2416

ClientHandler,

2417

interface=(server_settings["interface"]

2418

or None),

2419

use_ipv6=use_ipv6,

2420

gnutls_priority=

2421

server_settings["priority"],

2422

use_dbus=use_dbus,

2423

socketfd=(server_settings["socket"]

2424

or None))

2512

2425

if not foreground:

2513

pidfilename = "/run/mandos.pid"

2514

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

2515

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

2426

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

2516

2427

pidfile = None

2517

2428

try:

2518

pidfile = codecs.open(pidfilename, "w", encoding="utf-8")

2429

pidfile = open(pidfilename, "w")

2519

2430

except IOError as e:

2520

2431

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

2521

2432

exc_info=e)

2535

2446

os.setuid(uid)

2536

2447

except OSError as error:

2537

2448

if error.errno != errno.EPERM:

2538

raise

2449

raise error

2539

2450

2540

2451

if debug:

2541

2452

# Enable all possible GnuTLS debugging

2548

2459

def debug_gnutls(level, string):

2549

2460

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

2550

2461

2551

gnutls.library.functions.gnutls_global_set_log_function(

2552

debug_gnutls)

2462

(gnutls.library.functions

2463

.gnutls_global_set_log_function(debug_gnutls))

2553

2464

2554

2465

# Redirect stdin so all checkers get /dev/null

2555

2466

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

2575

2486

if use_dbus:

2576

2487

try:

2577

2488

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

2578

bus,

2579

do_not_queue=True)

2580

old_bus_name = dbus.service.BusName(

2581

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

2582

do_not_queue=True)

2583

except dbus.exceptions.DBusException as e:

2489

bus, do_not_queue=True)

2490

old_bus_name = (dbus.service.BusName

2491

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

2492

do_not_queue=True))

2493

except dbus.exceptions.NameExistsException as e:

2584

2494

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

2585

2495

use_dbus = False

2586

2496

server_settings["use_dbus"] = False

2587

2497

tcp_server.use_dbus = False

2588

if zeroconf:

2589

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2590

service = AvahiServiceToSyslog(

2591

name = server_settings["servicename"],

2592

servicetype = "_mandos._tcp",

2593

protocol = protocol,

2594

bus = bus)

2595

if server_settings["interface"]:

2596

service.interface = if_nametoindex(

2597

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

2498

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2499

service = AvahiServiceToSyslog(name =

2500

server_settings["servicename"],

2501

servicetype = "_mandos._tcp",

2502

protocol = protocol, bus = bus)

2503

if server_settings["interface"]:

2504

service.interface = (if_nametoindex

2505

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

2598

2506

2599

2507

global multiprocessing_manager

2600

2508

multiprocessing_manager = multiprocessing.Manager()

2607

2515

old_client_settings = {}

2608

2516

clients_data = {}

2609

2517

2610

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

2611

global wnull

2612

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

2613

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

2614

# mode

2615

if debug or not foreground:

2616

wnull.close()

2617

2618

2518

# Get client data and settings from last running state.

2619

2519

if server_settings["restore"]:

2620

2520

try:

2621

2521

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

2622

clients_data, old_client_settings = pickle.load(

2623

stored_state)

2522

clients_data, old_client_settings = (pickle.load

2523

(stored_state))

2624

2524

os.remove(stored_state_path)

2625

2525

except IOError as e:

2626

2526

if e.errno == errno.ENOENT:

2627

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

2628

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

2527

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

2528

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

2629

2529

else:

2630

2530

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

2631

2531

exc_info=e)

2632

2532

raise

2633

2533

except EOFError as e:

2634

2534

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

2635

"EOFError:",

2636

exc_info=e)

2535

"EOFError:", exc_info=e)

2637

2536

2638

2537

with PGPEngine() as pgp:

2639

for client_name, client in clients_data.items():

2640

# Skip removed clients

2641

if client_name not in client_settings:

2642

continue

2643

2538

for client_name, client in clients_data.iteritems():

2644

2539

# Decide which value to use after restoring saved state.

2645

2540

# We have three different values: Old config file,

2646

2541

# new config file, and saved state.

2651

2546

# For each value in new config, check if it

2652

2547

# differs from the old config value (Except for

2653

2548

# the "secret" attribute)

2654

if (name != "secret"

2655

and (value !=

2656

old_client_settings[client_name][name])):

2549

if (name != "secret" and

2550

value != old_client_settings[client_name]

2551

[name]):

2657

2552

client[name] = value

2658

2553

except KeyError:

2659

2554

pass

2667

2562

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

2668

2563

if not client["last_checked_ok"]:

2669

2564

logger.warning(

2670

"disabling client {} - Client never "

2671

"performed a successful checker".format(

2672

client_name))

2565

"disabling client {0} - Client never "

2566

"performed a successful checker"

2567

.format(client_name))

2673

2568

client["enabled"] = False

2674

2569

elif client["last_checker_status"] != 0:

2675

2570

logger.warning(

2676

"disabling client {} - Client last"

2677

" checker failed with error code"

2678

" {}".format(

2679

client_name,

2680

client["last_checker_status"]))

2571

"disabling client {0} - Client "

2572

"last checker failed with error code {1}"

2573

.format(client_name,

2574

client["last_checker_status"]))

2681

2575

client["enabled"] = False

2682

2576

else:

2683

client["expires"] = (

2684

datetime.datetime.utcnow()

2685

+ client["timeout"])

2577

client["expires"] = (datetime.datetime

2578

.utcnow()

2579

+ client["timeout"])

2686

2580

logger.debug("Last checker succeeded,"

2687

" keeping {} enabled".format(

2688

client_name))

2581

" keeping {0} enabled"

2582

.format(client_name))

2689

2583

try:

2690

client["secret"] = pgp.decrypt(

2691

client["encrypted_secret"],

2692

client_settings[client_name]["secret"])

2584

client["secret"] = (

2585

pgp.decrypt(client["encrypted_secret"],

2586

client_settings[client_name]

2587

["secret"]))

2693

2588

except PGPError:

2694

2589

# If decryption fails, we use secret from new settings

2695

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

2696

client_name))

2697

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

2698

["secret"])

2590

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

2591

.format(client_name))

2592

client["secret"] = (

2593

client_settings[client_name]["secret"])

2699

2594

2700

2595

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

2701

2596

for client_name in (set(old_client_settings)

2706

2601

clients_data[client_name] = client_settings[client_name]

2707

2602

2708

2603

# Create all client objects

2709

for client_name, client in clients_data.items():

2604

for client_name, client in clients_data.iteritems():

2710

2605

tcp_server.clients[client_name] = client_class(

2711

name = client_name,

2712

settings = client,

2713

server_settings = server_settings)

2606

name = client_name, settings = client)

2714

2607

2715

2608

if not tcp_server.clients:

2716

2609

logger.warning("No clients defined")

2717

2610

2718

2611

if not foreground:

2719

2612

if pidfile is not None:

2720

pid = os.getpid()

2721

2613

try:

2722

2614

with pidfile:

2723

print(pid, file=pidfile)

2615

pid = os.getpid()

2616

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

2724

2617

except IOError:

2725

2618

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

2726

2619

pidfilename, pid)

2731

2624

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

2732

2625

2733

2626

if use_dbus:

2734

2735

@alternate_dbus_interfaces(

2736

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

2627

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

2628

"se.bsnet.fukt.Mandos"})

2737

2629

class MandosDBusService(DBusObjectWithProperties):

2738

2630

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

2739

2740

2631

def __init__(self):

2741

2632

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

2742

2743

2633

_interface = "se.recompile.Mandos"

2744

2634

2745

2635

@dbus_interface_annotations(_interface)

2746

2636

def _foo(self):

2747

return {

2748

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

2749

"false" }

2637

return { "org.freedesktop.DBus.Property"

2638

".EmitsChangedSignal":

2639

"false"}

2750

2640

2751

2641

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

2752

2642

def ClientAdded(self, objpath):

2766

2656

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

2767

2657

def GetAllClients(self):

2768

2658

"D-Bus method"

2769

return dbus.Array(c.dbus_object_path for c in

2659

return dbus.Array(c.dbus_object_path

2660

for c in

2770

2661

tcp_server.clients.itervalues())

2771

2662

2772

2663

@dbus.service.method(_interface,

2774

2665

def GetAllClientsWithProperties(self):

2775

2666

"D-Bus method"

2776

2667

return dbus.Dictionary(

2777

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

2778

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

2668

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

2669

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

2779

2670

signature="oa{sv}")

2780

2671

2781

2672

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

2798

2689

2799

2690

def cleanup():

2800

2691

"Cleanup function; run on exit"

2801

if zeroconf:

2802

service.cleanup()

2692

service.cleanup()

2803

2693

2804

2694

multiprocessing.active_children()

2805

wnull.close()

2806

2695

if not (tcp_server.clients or client_settings):

2807

2696

return

2808

2697

2819

2708

2820

2709

# A list of attributes that can not be pickled

2821

2710

# + secret.

2822

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

2823

"checker", "server_settings" }

2824

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

2825

.Object):

2711

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

2712

"checker"))

2713

for name, typ in (inspect.getmembers

2714

(dbus.service.Object)):

2826

2715

exclude.add(name)

2827

2716

2828

2717

client_dict["encrypted_secret"] = (client

2835

2724

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

2836

2725

2837

2726

try:

2838

with tempfile.NamedTemporaryFile(

2839

mode='wb',

2840

suffix=".pickle",

2841

prefix='clients-',

2842

dir=os.path.dirname(stored_state_path),

2843

delete=False) as stored_state:

2727

with (tempfile.NamedTemporaryFile

2728

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

2729

dir=os.path.dirname(stored_state_path),

2730

delete=False)) as stored_state:

2844

2731

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

2845

tempname = stored_state.name

2732

tempname=stored_state.name

2846

2733

os.rename(tempname, stored_state_path)

2847

2734

except (IOError, OSError) as e:

2848

2735

if not debug:

2851

2738

except NameError:

2852

2739

pass

2853

2740

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

2854

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

2741

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

2855

2742

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

2856

2743

else:

2857

2744

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

2858

2745

exc_info=e)

2859

raise

2746

raise e

2860

2747

2861

2748

# Delete all clients, and settings from config

2862

2749

while tcp_server.clients:

2867

2754

client.disable(quiet=True)

2868

2755

if use_dbus:

2869

2756

# Emit D-Bus signal

2870

mandos_dbus_service.ClientRemoved(

2871

client.dbus_object_path, client.name)

2757

mandos_dbus_service.ClientRemoved(client

2758

.dbus_object_path,

2759

client.name)

2872

2760

client_settings.clear()

2873

2761

2874

2762

atexit.register(cleanup)

2885

2773

tcp_server.server_activate()

2886

2774

2887

2775

# Find out what port we got

2888

if zeroconf:

2889

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

2776

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

2890

2777

if use_ipv6:

2891

2778

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

2892

2779

" flowinfo %d, scope_id %d",

2898

2785

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

2899

2786

2900

2787

try:

2901

if zeroconf:

2902

# From the Avahi example code

2903

try:

2904

service.activate()

2905

except dbus.exceptions.DBusException as error:

2906

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

2907

cleanup()

2908

sys.exit(1)

2909

# End of Avahi example code

2788

# From the Avahi example code

2789

try:

2790

service.activate()

2791

except dbus.exceptions.DBusException as error:

2792

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

2793

cleanup()

2794

sys.exit(1)

2795

# End of Avahi example code

2910

2796

2911

2797

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

2912

2798

lambda *args, **kwargs:

2927

2813

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

2928

2814

cleanup()

2929

2815

2930

2931

2816

if __name__ == '__main__':

2932

2817

main()