/mandos/trunk : revision 750

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

36

37

from future_builtins import *

38

39

import SocketServer as socketserver

39

try:

40

import SocketServer as socketserver

41

except ImportError:

42

import socketserver

40

43

import socket

41

44

import argparse

42

45

import datetime

47

50

import gnutls.library.functions

48

51

import gnutls.library.constants

49

52

import gnutls.library.types

50

import ConfigParser as configparser

53

try:

54

import ConfigParser as configparser

55

except ImportError:

56

import configparser

51

57

import sys

52

58

import re

53

59

import os

62

68

import struct

63

69

import fcntl

64

70

import functools

65

import cPickle as pickle

71

try:

72

import cPickle as pickle

73

except ImportError:

74

import pickle

66

75

import multiprocessing

67

76

import types

68

77

import binascii

69

78

import tempfile

70

79

import itertools

80

import collections

71

81

72

82

import dbus

73

83

import dbus.service

74

import gobject

84

try:

85

import gobject

86

except ImportError:

87

from gi.repository import GObject as gobject

75

88

import avahi

76

89

from dbus.mainloop.glib import DBusGMainLoop

77

90

import ctypes

78

91

import ctypes.util

79

92

import xml.dom.minidom

80

93

import inspect

81

import GnuPGInterface

82

94

83

95

try:

84

96

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

88

100

except ImportError:

89

101

SO_BINDTODEVICE = None

90

102

91

version = "1.5.5"

103

if sys.version_info.major == 2:

104

str = unicode

105

106

version = "1.6.9"

92

107

stored_state_file = "clients.pickle"

93

108

94

109

logger = logging.getLogger()

95

syslogger = (logging.handlers.SysLogHandler

96

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

97

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

110

syslogger = None

98

111

99

112

try:

100

if_nametoindex = (ctypes.cdll.LoadLibrary

101

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

102

.if_nametoindex)

113

if_nametoindex = ctypes.cdll.LoadLibrary(

114

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

103

115

except (OSError, AttributeError):

116

104

117

def if_nametoindex(interface):

105

118

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

106

119

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

107

120

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

108

121

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

109

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

110

interface))

111

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

112

ifreq[16:20])[0]

122

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

123

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

113

124

return interface_index

114

125

115

126

116

127

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

117

128

"""init logger and add loglevel"""

118

129

130

global syslogger

131

syslogger = (logging.handlers.SysLogHandler(

132

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

133

address = "/dev/log"))

119

134

syslogger.setFormatter(logging.Formatter

120

135

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

121

136

' %(message)s'))

138

153

139

154

class PGPEngine(object):

140

155

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

156

141

157

def __init__(self):

142

self.gnupg = GnuPGInterface.GnuPG()

143

158

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

144

self.gnupg = GnuPGInterface.GnuPG()

145

self.gnupg.options.meta_interactive = False

146

self.gnupg.options.homedir = self.tempdir

147

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

148

'--quiet',

149

'--no-use-agent'])

159

self.gnupgargs = ['--batch',

160

'--home', self.tempdir,

161

'--force-mdc',

162

'--quiet',

163

'--no-use-agent']

150

164

151

165

def __enter__(self):

152

166

return self

174

188

def password_encode(self, password):

175

189

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

176

190

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

177

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

191

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

192

if len(encoded) > 2048:

193

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

194

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

195

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

196

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

197

return encoded

178

198

179

199

def encrypt(self, data, password):

180

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

181

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

182

try:

183

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

184

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

185

attach_fhs={'stderr': devnull})

186

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

187

f.write(data)

188

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

189

ciphertext = f.read()

190

proc.wait()

191

except IOError as e:

192

raise PGPError(e)

193

self.gnupg.passphrase = None

200

passphrase = self.password_encode(password)

201

with tempfile.NamedTemporaryFile(

202

dir=self.tempdir) as passfile:

203

passfile.write(passphrase)

204

passfile.flush()

205

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

206

'--passphrase-file',

207

passfile.name]

208

+ self.gnupgargs,

209

stdin = subprocess.PIPE,

210

stdout = subprocess.PIPE,

211

stderr = subprocess.PIPE)

212

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

213

if proc.returncode != 0:

214

raise PGPError(err)

194

215

return ciphertext

195

216

196

217

def decrypt(self, data, password):

197

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

198

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

199

try:

200

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

201

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

202

attach_fhs={'stderr': devnull})

203

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

204

f.write(data)

205

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

206

decrypted_plaintext = f.read()

207

proc.wait()

208

except IOError as e:

209

raise PGPError(e)

210

self.gnupg.passphrase = None

218

passphrase = self.password_encode(password)

219

with tempfile.NamedTemporaryFile(

220

dir = self.tempdir) as passfile:

221

passfile.write(passphrase)

222

passfile.flush()

223

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

224

'--passphrase-file',

225

passfile.name]

226

+ self.gnupgargs,

227

stdin = subprocess.PIPE,

228

stdout = subprocess.PIPE,

229

stderr = subprocess.PIPE)

230

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

231

if proc.returncode != 0:

232

raise PGPError(err)

211

233

return decrypted_plaintext

212

234

213

235

214

236

class AvahiError(Exception):

215

237

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

216

238

self.value = value

217

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

218

def __unicode__(self):

219

return unicode(repr(self.value))

239

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

240

**kwargs)

241

220

242

221

243

class AvahiServiceError(AvahiError):

222

244

pass

223

245

246

224

247

class AvahiGroupError(AvahiError):

225

248

pass

226

249

233

256

Used to optionally bind to the specified interface.

234

257

name: string; Example: 'Mandos'

235

258

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

236

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

259

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

237

260

port: integer; what port to announce

238

261

TXT: list of strings; TXT record for the service

239

262

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

246

269

bus: dbus.SystemBus()

247

270

"""

248

271

249

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

250

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

251

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

252

protocol = avahi.PROTO_UNSPEC, bus = None):

272

def __init__(self,

273

interface = avahi.IF_UNSPEC,

274

name = None,

275

servicetype = None,

276

port = None,

277

TXT = None,

278

domain = "",

279

host = "",

280

max_renames = 32768,

281

protocol = avahi.PROTO_UNSPEC,

282

bus = None):

253

283

self.interface = interface

254

284

self.name = name

255

285

self.type = servicetype

265

295

self.bus = bus

266

296

self.entry_group_state_changed_match = None

267

297

268

def rename(self):

298

def rename(self, remove=True):

269

299

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

270

300

if self.rename_count >= self.max_renames:

271

301

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

272

302

" after %i retries, exiting.",

273

303

self.rename_count)

274

304

raise AvahiServiceError("Too many renames")

275

self.name = unicode(self.server

276

.GetAlternativeServiceName(self.name))

305

self.name = str(

306

self.server.GetAlternativeServiceName(self.name))

307

self.rename_count += 1

277

308

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

278

309

self.name)

279

self.remove()

310

if remove:

311

self.remove()

280

312

try:

281

313

self.add()

282

314

except dbus.exceptions.DBusException as error:

283

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

284

self.cleanup()

285

os._exit(1)

286

self.rename_count += 1

315

if (error.get_dbus_name()

316

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

317

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

318

return self.rename(remove=False)

319

else:

320

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

321

self.cleanup()

322

os._exit(1)

287

323

288

324

def remove(self):

289

325

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

327

363

self.rename()

328

364

elif state == avahi.ENTRY_GROUP_FAILURE:

329

365

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

330

unicode(error))

331

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

332

.format(error))

366

str(error))

367

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

333

368

334

369

def cleanup(self):

335

370

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

345

380

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

346

381

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

347

382

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

348

bad_states = { avahi.SERVER_INVALID:

349

"Zeroconf server invalid",

350

avahi.SERVER_REGISTERING: None,

351

avahi.SERVER_COLLISION:

352

"Zeroconf server name collision",

353

avahi.SERVER_FAILURE:

354

"Zeroconf server failure" }

383

bad_states = {

384

avahi.SERVER_INVALID: "Zeroconf server invalid",

385

avahi.SERVER_REGISTERING: None,

386

avahi.SERVER_COLLISION: "Zeroconf server name collision",

387

avahi.SERVER_FAILURE: "Zeroconf server failure",

388

}

355

389

if state in bad_states:

356

390

if bad_states[state] is not None:

357

391

if error is None:

376

410

follow_name_owner_changes=True),

377

411

avahi.DBUS_INTERFACE_SERVER)

378

412

self.server.connect_to_signal("StateChanged",

379

self.server_state_changed)

413

self.server_state_changed)

380

414

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

381

415

382

416

383

417

class AvahiServiceToSyslog(AvahiService):

384

def rename(self):

418

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

385

419

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

386

ret = AvahiService.rename(self)

387

syslogger.setFormatter(logging.Formatter

388

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

389

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

390

.format(self.name)))

420

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

421

syslogger.setFormatter(logging.Formatter(

422

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

423

.format(self.name)))

391

424

return ret

392

425

393

426

394

def timedelta_to_milliseconds(td):

395

"Convert a datetime.timedelta() to milliseconds"

396

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

397

+ (td.seconds * 1000)

398

+ (td.microseconds // 1000))

399

400

401

427

class Client(object):

402

428

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

403

429

439

465

runtime_expansions: Allowed attributes for runtime expansion.

440

466

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

441

467

disabled, or None

468

server_settings: The server_settings dict from main()

442

469

"""

443

470

444

471

runtime_expansions = ("approval_delay", "approval_duration",

446

473

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

447

474

"last_approval_request", "last_checked_ok",

448

475

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

449

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

450

"extended_timeout": "15m",

451

"interval": "2m",

452

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

453

"host": "",

454

"approval_delay": "0s",

455

"approval_duration": "1s",

456

"approved_by_default": "True",

457

"enabled": "True",

458

}

459

460

def timeout_milliseconds(self):

461

"Return the 'timeout' attribute in milliseconds"

462

return timedelta_to_milliseconds(self.timeout)

463

464

def extended_timeout_milliseconds(self):

465

"Return the 'extended_timeout' attribute in milliseconds"

466

return timedelta_to_milliseconds(self.extended_timeout)

467

468

def interval_milliseconds(self):

469

"Return the 'interval' attribute in milliseconds"

470

return timedelta_to_milliseconds(self.interval)

471

472

def approval_delay_milliseconds(self):

473

return timedelta_to_milliseconds(self.approval_delay)

476

client_defaults = {

477

"timeout": "PT5M",

478

"extended_timeout": "PT15M",

479

"interval": "PT2M",

480

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

481

"host": "",

482

"approval_delay": "PT0S",

483

"approval_duration": "PT1S",

484

"approved_by_default": "True",

485

"enabled": "True",

486

}

474

487

475

488

@staticmethod

476

489

def config_parser(config):

492

505

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

493

506

"enabled")

494

507

508

# Uppercase and remove spaces from fingerprint for later

509

# comparison purposes with return value from the

510

# fingerprint() function

495

511

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

496

512

.replace(" ", ""))

497

513

if "secret" in section:

502

518

"rb") as secfile:

503

519

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

504

520

else:

505

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

521

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

506

522

.format(section))

507

523

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

508

524

client["extended_timeout"] = string_to_delta(

519

535

520

536

return settings

521

537

522

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

538

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

523

539

self.name = name

540

if server_settings is None:

541

server_settings = {}

542

self.server_settings = server_settings

524

543

# adding all client settings

525

for setting, value in settings.iteritems():

544

for setting, value in settings.items():

526

545

setattr(self, setting, value)

527

546

528

547

if self.enabled:

536

555

self.expires = None

537

556

538

557

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

539

# Uppercase and remove spaces from fingerprint for later

540

# comparison purposes with return value from the fingerprint()

541

# function

542

558

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

543

559

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

544

560

datetime.datetime.utcnow())

551

567

self.current_checker_command = None

552

568

self.approved = None

553

569

self.approvals_pending = 0

554

self.changedstate = (multiprocessing_manager

555

.Condition(multiprocessing_manager

556

.Lock()))

557

self.client_structure = [attr for attr in

558

self.__dict__.iterkeys()

570

self.changedstate = multiprocessing_manager.Condition(

571

multiprocessing_manager.Lock())

572

self.client_structure = [attr

573

for attr in self.__dict__.iterkeys()

559

574

if not attr.startswith("_")]

560

575

self.client_structure.append("client_structure")

561

576

562

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

563

lambda obj:

564

isinstance(obj,

565

property)):

577

for name, t in inspect.getmembers(

578

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

566

579

if not name.startswith("_"):

567

580

self.client_structure.append(name)

568

581

610

623

# and every interval from then on.

611

624

if self.checker_initiator_tag is not None:

612

625

gobject.source_remove(self.checker_initiator_tag)

613

self.checker_initiator_tag = (gobject.timeout_add

614

(self.interval_milliseconds(),

615

self.start_checker))

626

self.checker_initiator_tag = gobject.timeout_add(

627

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

628

self.start_checker)

616

629

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

617

630

if self.disable_initiator_tag is not None:

618

631

gobject.source_remove(self.disable_initiator_tag)

619

self.disable_initiator_tag = (gobject.timeout_add

620

(self.timeout_milliseconds(),

621

self.disable))

632

self.disable_initiator_tag = gobject.timeout_add(

633

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

622

634

# Also start a new checker *right now*.

623

635

self.start_checker()

624

636

633

645

vars(self))

634

646

self.checked_ok()

635

647

else:

636

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

637

vars(self))

648

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

638

649

else:

639

650

self.last_checker_status = -1

640

651

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

654

665

gobject.source_remove(self.disable_initiator_tag)

655

666

self.disable_initiator_tag = None

656

667

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

657

self.disable_initiator_tag = (gobject.timeout_add

658

(timedelta_to_milliseconds

659

(timeout), self.disable))

668

self.disable_initiator_tag = gobject.timeout_add(

669

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

660

670

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

661

671

662

672

def need_approval(self):

679

689

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

680

690

try:

681

691

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

682

except (AttributeError, OSError) as error:

683

if (isinstance(error, OSError)

684

and error.errno != errno.ECHILD):

685

raise error

692

except AttributeError:

693

pass

694

except OSError as error:

695

if error.errno != errno.ECHILD:

696

raise

686

697

else:

687

698

if pid:

688

699

logger.warning("Checker was a zombie")

692

703

# Start a new checker if needed

693

704

if self.checker is None:

694

705

# Escape attributes for the shell

695

escaped_attrs = dict(

696

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

697

for attr in

698

self.runtime_expansions)

706

escaped_attrs = {

707

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

708

for attr in self.runtime_expansions }

699

709

try:

700

710

command = self.checker_command % escaped_attrs

701

711

except TypeError as error:

702

712

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

703

self.checker_command, exc_info=error)

704

return True # Try again later

713

self.checker_command,

714

exc_info=error)

715

return True # Try again later

705

716

self.current_checker_command = command

706

717

try:

707

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

708

command, self.name)

718

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

719

self.name)

709

720

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

710

721

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

711

722

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

712

723

# always replaced by /dev/null.)

724

# The exception is when not debugging but nevertheless

725

# running in the foreground; use the previously

726

# created wnull.

727

popen_args = {}

728

if (not self.server_settings["debug"]

729

and self.server_settings["foreground"]):

730

popen_args.update({"stdout": wnull,

731

"stderr": wnull })

713

732

self.checker = subprocess.Popen(command,

714

733

close_fds=True,

715

shell=True, cwd="/")

734

shell=True,

735

cwd="/",

736

**popen_args)

716

737

except OSError as error:

717

738

logger.error("Failed to start subprocess",

718

739

exc_info=error)

719

self.checker_callback_tag = (gobject.child_watch_add

720

(self.checker.pid,

721

self.checker_callback,

722

data=command))

740

return True

741

self.checker_callback_tag = gobject.child_watch_add(

742

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

723

743

# The checker may have completed before the gobject

724

744

# watch was added. Check for this.

725

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

745

try:

746

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

747

except OSError as error:

748

if error.errno == errno.ECHILD:

749

# This should never happen

750

logger.error("Child process vanished",

751

exc_info=error)

752

return True

753

raise

726

754

if pid:

727

755

gobject.source_remove(self.checker_callback_tag)

728

756

self.checker_callback(pid, status, command)

748

776

self.checker = None

749

777

750

778

751

def dbus_service_property(dbus_interface, signature="v",

752

access="readwrite", byte_arrays=False):

779

def dbus_service_property(dbus_interface,

780

signature="v",

781

access="readwrite",

782

byte_arrays=False):

753

783

"""Decorators for marking methods of a DBusObjectWithProperties to

754

784

become properties on the D-Bus.

755

785

764

794

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

765

795

if byte_arrays and signature != "ay":

766

796

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

767

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

797

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

798

768

799

def decorator(func):

769

800

func._dbus_is_property = True

770

801

func._dbus_interface = dbus_interface

775

806

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

776

807

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

777

808

return func

809

778

810

return decorator

779

811

780

812

789

821

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

790

822

"false"}

791

823

"""

824

792

825

def decorator(func):

793

826

func._dbus_is_interface = True

794

827

func._dbus_interface = dbus_interface

795

828

func._dbus_name = dbus_interface

796

829

return func

830

797

831

return decorator

798

832

799

833

801

835

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

802

836

Usage:

803

837

838

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

839

"org.freedesktop.DBus.Property."

840

"EmitsChangedSignal": "false"})

804

841

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

805

842

access="r")

806

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

807

"org.freedesktop.DBus.Property."

808

"EmitsChangedSignal": "false"})

809

843

def Property_dbus_property(self):

810

844

return dbus.Boolean(False)

811

845

"""

846

812

847

def decorator(func):

813

848

func._dbus_annotations = annotations

814

849

return func

850

815

851

return decorator

816

852

817

853

818

854

class DBusPropertyException(dbus.exceptions.DBusException):

819

855

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

820

856

"""

821

def __unicode__(self):

822

return unicode(str(self))

857

pass

823

858

824

859

825

860

class DBusPropertyAccessException(DBusPropertyException):

849

884

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

850

885

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

851

886

"""

852

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

887

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

853

888

False)

854

889

855

890

def _get_all_dbus_things(self, thing):

856

891

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

857

892

"""

858

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

859

name),

893

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

860

894

athing.__get__(self))

861

895

for cls in self.__class__.__mro__

862

896

for name, athing in

863

inspect.getmembers(cls,

864

self._is_dbus_thing(thing)))

897

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

865

898

866

899

def _get_dbus_property(self, interface_name, property_name):

867

900

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

868

901

property with the specified name and interface.

869

902

"""

870

for cls in self.__class__.__mro__:

871

for name, value in (inspect.getmembers

872

(cls,

873

self._is_dbus_thing("property"))):

903

for cls in self.__class__.__mro__:

904

for name, value in inspect.getmembers(

905

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

874

906

if (value._dbus_name == property_name

875

907

and value._dbus_interface == interface_name):

876

908

return value.__get__(self)

877

909

878

910

# No such property

879

raise DBusPropertyNotFound(self.dbus_object_path + ":"

880

+ interface_name + "."

881

+ property_name)

911

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

912

self.dbus_object_path, interface_name, property_name))

882

913

883

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

914

@dbus.service.method(dbus.PROPERTIES_IFACE,

915

in_signature="ss",

884

916

out_signature="v")

885

917

def Get(self, interface_name, property_name):

886

918

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

904

936

# The byte_arrays option is not supported yet on

905

937

# signatures other than "ay".

906

938

if prop._dbus_signature != "ay":

907

raise ValueError

939

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

940

"'ay' signature {!r}"

941

.format(prop._dbus_signature))

908

942

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

909

943

for byte in value))

910

944

prop(value)

911

945

912

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

946

@dbus.service.method(dbus.PROPERTIES_IFACE,

947

in_signature="s",

913

948

out_signature="a{sv}")

914

949

def GetAll(self, interface_name):

915

950

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

930

965

if not hasattr(value, "variant_level"):

931

966

properties[name] = value

932

967

continue

933

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

934

value.variant_level+1)

968

properties[name] = type(value)(

969

value, variant_level = value.variant_level + 1)

935

970

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

936

971

972

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

973

def PropertiesChanged(self, interface_name, changed_properties,

974

invalidated_properties):

975

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

976

standard.

977

"""

978

pass

979

937

980

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

938

981

out_signature="s",

939

982

path_keyword='object_path',

947

990

connection)

948

991

try:

949

992

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

993

950

994

def make_tag(document, name, prop):

951

995

e = document.createElement("property")

952

996

e.setAttribute("name", name)

953

997

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

954

998

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

955

999

return e

1000

956

1001

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

957

1002

# Add property tags

958

1003

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

970

1015

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

971

1016

and prop._dbus_interface

972

1017

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

973

annots.update(getattr

974

(prop,

975

"_dbus_annotations",

976

{}))

977

for name, value in annots.iteritems():

1018

annots.update(getattr(

1019

prop, "_dbus_annotations", {}))

1020

for name, value in annots.items():

978

1021

ann_tag = document.createElement(

979

1022

"annotation")

980

1023

ann_tag.setAttribute("name", name)

983

1026

# Add interface annotation tags

984

1027

for annotation, value in dict(

985

1028

itertools.chain.from_iterable(

986

annotations().iteritems()

987

for name, annotations in

988

self._get_all_dbus_things("interface")

1029

annotations().items()

1030

for name, annotations

1031

in self._get_all_dbus_things("interface")

989

1032

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

990

)).iteritems():

1033

)).items():

991

1034

ann_tag = document.createElement("annotation")

992

1035

ann_tag.setAttribute("name", annotation)

993

1036

ann_tag.setAttribute("value", value)

1020

1063

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

1021

1064

if dt is None:

1022

1065

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

1023

return dbus.String(dt.isoformat(),

1024

variant_level=variant_level)

1066

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

1025

1067

1026

1068

1027

1069

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1047

1089

(from DBusObjectWithProperties) and interfaces (from the

1048

1090

dbus_interface_annotations decorator).

1049

1091

"""

1092

1050

1093

def wrapper(cls):

1051

1094

for orig_interface_name, alt_interface_name in (

1052

alt_interface_names.iteritems()):

1095

alt_interface_names.items()):

1053

1096

attr = {}

1054

1097

interface_names = set()

1055

1098

# Go though all attributes of the class

1057

1100

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

1058

1101

# with the wrong interface name

1059

1102

if (not hasattr(attribute, "_dbus_interface")

1060

or not attribute._dbus_interface

1061

.startswith(orig_interface_name)):

1103

or not attribute._dbus_interface.startswith(

1104

orig_interface_name)):

1062

1105

continue

1063

1106

# Create an alternate D-Bus interface name based on

1064

1107

# the current name

1065

alt_interface = (attribute._dbus_interface

1066

.replace(orig_interface_name,

1067

alt_interface_name))

1108

alt_interface = attribute._dbus_interface.replace(

1109

orig_interface_name, alt_interface_name)

1068

1110

interface_names.add(alt_interface)

1069

1111

# Is this a D-Bus signal?

1070

1112

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

1071

# Extract the original non-method function by

1072

# black magic

1113

# Extract the original non-method undecorated

1114

# function by black magic

1073

1115

nonmethod_func = (dict(

1074

zip(attribute.func_code.co_freevars,

1075

attribute.__closure__))["func"]

1076

.cell_contents)

1116

zip(attribute.func_code.co_freevars,

1117

attribute.__closure__))

1118

["func"].cell_contents)

1077

1119

# Create a new, but exactly alike, function

1078

1120

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

1079

1121

# with the alternate D-Bus interface name

1080

new_function = (dbus.service.signal

1081

(alt_interface,

1082

attribute._dbus_signature)

1122

new_function = (dbus.service.signal(

1123

alt_interface, attribute._dbus_signature)

1083

1124

(types.FunctionType(

1084

nonmethod_func.func_code,

1085

nonmethod_func.func_globals,

1086

nonmethod_func.func_name,

1087

nonmethod_func.func_defaults,

1088

nonmethod_func.func_closure)))

1125

nonmethod_func.func_code,

1126

nonmethod_func.func_globals,

1127

nonmethod_func.func_name,

1128

nonmethod_func.func_defaults,

1129

nonmethod_func.func_closure)))

1089

1130

# Copy annotations, if any

1090

1131

try:

1091

new_function._dbus_annotations = (

1092

dict(attribute._dbus_annotations))

1132

new_function._dbus_annotations = dict(

1133

attribute._dbus_annotations)

1093

1134

except AttributeError:

1094

1135

pass

1095

1136

# Define a creator of a function to call both the

1100

1141

"""This function is a scope container to pass

1101

1142

func1 and func2 to the "call_both" function

1102

1143

outside of its arguments"""

1144

1103

1145

def call_both(*args, **kwargs):

1104

1146

"""This function will emit two D-Bus

1105

1147

signals by calling func1 and func2"""

1106

1148

func1(*args, **kwargs)

1107

1149

func2(*args, **kwargs)

1150

1108

1151

return call_both

1109

1152

# Create the "call_both" function and add it to

1110

1153

# the class

1115

1158

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

1116

1159

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

1117

1160

# to the class.

1118

attr[attrname] = (dbus.service.method

1119

(alt_interface,

1120

attribute._dbus_in_signature,

1121

attribute._dbus_out_signature)

1122

(types.FunctionType

1123

(attribute.func_code,

1124

attribute.func_globals,

1125

attribute.func_name,

1126

attribute.func_defaults,

1127

attribute.func_closure)))

1161

attr[attrname] = (

1162

dbus.service.method(

1163

alt_interface,

1164

attribute._dbus_in_signature,

1165

attribute._dbus_out_signature)

1166

(types.FunctionType(attribute.func_code,

1167

attribute.func_globals,

1168

attribute.func_name,

1169

attribute.func_defaults,

1170

attribute.func_closure)))

1128

1171

# Copy annotations, if any

1129

1172

try:

1130

attr[attrname]._dbus_annotations = (

1131

dict(attribute._dbus_annotations))

1173

attr[attrname]._dbus_annotations = dict(

1174

attribute._dbus_annotations)

1132

1175

except AttributeError:

1133

1176

pass

1134

1177

# Is this a D-Bus property?

1137

1180

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

1138

1181

# property with the alternate D-Bus interface

1139

1182

# name. Add it to the class.

1140

attr[attrname] = (dbus_service_property

1141

(alt_interface,

1142

attribute._dbus_signature,

1143

attribute._dbus_access,

1144

attribute

1145

._dbus_get_args_options

1146

["byte_arrays"])

1147

(types.FunctionType

1148

(attribute.func_code,

1149

attribute.func_globals,

1150

attribute.func_name,

1151

attribute.func_defaults,

1152

attribute.func_closure)))

1183

attr[attrname] = (dbus_service_property(

1184

alt_interface, attribute._dbus_signature,

1185

attribute._dbus_access,

1186

attribute._dbus_get_args_options

1187

["byte_arrays"])

1188

(types.FunctionType(

1189

attribute.func_code,

1190

attribute.func_globals,

1191

attribute.func_name,

1192

attribute.func_defaults,

1193

attribute.func_closure)))

1153

1194

# Copy annotations, if any

1154

1195

try:

1155

attr[attrname]._dbus_annotations = (

1156

dict(attribute._dbus_annotations))

1196

attr[attrname]._dbus_annotations = dict(

1197

attribute._dbus_annotations)

1157

1198

except AttributeError:

1158

1199

pass

1159

1200

# Is this a D-Bus interface?

1162

1203

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

1163

1204

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

1164

1205

# to the class.

1165

attr[attrname] = (dbus_interface_annotations

1166

(alt_interface)

1167

(types.FunctionType

1168

(attribute.func_code,

1169

attribute.func_globals,

1170

attribute.func_name,

1171

attribute.func_defaults,

1172

attribute.func_closure)))

1206

attr[attrname] = (

1207

dbus_interface_annotations(alt_interface)

1208

(types.FunctionType(attribute.func_code,

1209

attribute.func_globals,

1210

attribute.func_name,

1211

attribute.func_defaults,

1212

attribute.func_closure)))

1173

1213

if deprecate:

1174

1214

# Deprecate all alternate interfaces

1175

iname="_AlternateDBusNames_interface_annotation{0}"

1215

iname="_AlternateDBusNames_interface_annotation{}"

1176

1216

for interface_name in interface_names:

1217

1177

1218

@dbus_interface_annotations(interface_name)

1178

1219

def func(self):

1179

1220

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

1180

"true" }

1221

"true" }

1181

1222

# Find an unused name

1182

1223

for aname in (iname.format(i)

1183

1224

for i in itertools.count()):

1187

1228

if interface_names:

1188

1229

# Replace the class with a new subclass of it with

1189

1230

# methods, signals, etc. as created above.

1190

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

1191

(cls,), attr)

1231

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

1232

(cls, ), attr)

1192

1233

return cls

1234

1193

1235

return wrapper

1194

1236

1195

1237

1196

1238

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

1197

"se.bsnet.fukt.Mandos"})

1239

"se.bsnet.fukt.Mandos"})

1198

1240

class ClientDBus(Client, DBusObjectWithProperties):

1199

1241

"""A Client class using D-Bus

1200

1242

1204

1246

"""

1205

1247

1206

1248

runtime_expansions = (Client.runtime_expansions

1207

+ ("dbus_object_path",))

1249

+ ("dbus_object_path", ))

1250

1251

_interface = "se.recompile.Mandos.Client"

1208

1252

1209

1253

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

1210

1254

1213

1257

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

1214

1258

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

1215

1259

# the D-Bus

1216

client_object_name = unicode(self.name).translate(

1260

client_object_name = str(self.name).translate(

1217

1261

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

1218

1262

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

1219

self.dbus_object_path = (dbus.ObjectPath

1220

("/clients/" + client_object_name))

1263

self.dbus_object_path = dbus.ObjectPath(

1264

"/clients/" + client_object_name)

1221

1265

DBusObjectWithProperties.__init__(self, self.bus,

1222

1266

self.dbus_object_path)

1223

1267

1224

def notifychangeproperty(transform_func,

1225

dbus_name, type_func=lambda x: x,

1226

variant_level=1):

1268

def notifychangeproperty(transform_func, dbus_name,

1269

type_func=lambda x: x,

1270

variant_level=1,

1271

invalidate_only=False,

1272

_interface=_interface):

1227

1273

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

1228

1274

its changes to DBus.

1229

1275

1234

1280

to the D-Bus. Default: no transform

1235

1281

variant_level: D-Bus variant level. Default: 1

1236

1282

"""

1237

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

1283

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

1284

1238

1285

def setter(self, value):

1239

1286

if hasattr(self, "dbus_object_path"):

1240

1287

if (not hasattr(self, attrname) or

1241

1288

type_func(getattr(self, attrname, None))

1242

1289

!= type_func(value)):

1243

dbus_value = transform_func(type_func(value),

1244

variant_level

1245

=variant_level)

1246

self.PropertyChanged(dbus.String(dbus_name),

1247

dbus_value)

1290

if invalidate_only:

1291

self.PropertiesChanged(

1292

_interface, dbus.Dictionary(),

1293

dbus.Array((dbus_name, )))

1294

else:

1295

dbus_value = transform_func(

1296

type_func(value),

1297

variant_level = variant_level)

1298

self.PropertyChanged(dbus.String(dbus_name),

1299

dbus_value)

1300

self.PropertiesChanged(

1301

_interface,

1302

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

1303

dbus_value }),

1304

dbus.Array())

1248

1305

setattr(self, attrname, value)

1249

1306

1250

1307

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

1256

1313

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

1257

1314

last_enabled = notifychangeproperty(datetime_to_dbus,

1258

1315

"LastEnabled")

1259

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

1260

type_func = lambda checker:

1261

checker is not None)

1316

checker = notifychangeproperty(

1317

dbus.Boolean, "CheckerRunning",

1318

type_func = lambda checker: checker is not None)

1262

1319

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1263

1320

"LastCheckedOK")

1264

1321

last_checker_status = notifychangeproperty(dbus.Int16,

1267

1324

datetime_to_dbus, "LastApprovalRequest")

1268

1325

approved_by_default = notifychangeproperty(dbus.Boolean,

1269

1326

"ApprovedByDefault")

1270

approval_delay = notifychangeproperty(dbus.UInt64,

1271

"ApprovalDelay",

1272

type_func =

1273

timedelta_to_milliseconds)

1327

approval_delay = notifychangeproperty(

1328

dbus.UInt64, "ApprovalDelay",

1329

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

1274

1330

approval_duration = notifychangeproperty(

1275

1331

dbus.UInt64, "ApprovalDuration",

1276

type_func = timedelta_to_milliseconds)

1332

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

1277

1333

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

1278

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

1279

type_func =

1280

timedelta_to_milliseconds)

1334

timeout = notifychangeproperty(

1335

dbus.UInt64, "Timeout",

1336

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

1281

1337

extended_timeout = notifychangeproperty(

1282

1338

dbus.UInt64, "ExtendedTimeout",

1283

type_func = timedelta_to_milliseconds)

1284

interval = notifychangeproperty(dbus.UInt64,

1285

"Interval",

1286

type_func =

1287

timedelta_to_milliseconds)

1339

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

1340

interval = notifychangeproperty(

1341

dbus.UInt64, "Interval",

1342

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

1288

1343

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

1344

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

1345

invalidate_only=True)

1289

1346

1290

1347

del notifychangeproperty

1291

1348

1318

1375

*args, **kwargs)

1319

1376

1320

1377

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

1321

old_checker = self.checker

1322

if self.checker is not None:

1323

old_checker_pid = self.checker.pid

1324

else:

1325

old_checker_pid = None

1378

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

1326

1379

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

1327

1380

# Only if new checker process was started

1328

1381

if (self.checker is not None

1337

1390

1338

1391

def approve(self, value=True):

1339

1392

self.approved = value

1340

gobject.timeout_add(timedelta_to_milliseconds

1341

(self.approval_duration),

1342

self._reset_approved)

1393

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

1394

* 1000), self._reset_approved)

1343

1395

self.send_changedstate()

1344

1396

1345

1397

## D-Bus methods, signals & properties

1346

_interface = "se.recompile.Mandos.Client"

1347

1398

1348

1399

## Interfaces

1349

1400

1350

@dbus_interface_annotations(_interface)

1351

def _foo(self):

1352

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

1353

"false"}

1354

1355

1401

## Signals

1356

1402

1357

1403

# CheckerCompleted - signal

1367

1413

pass

1368

1414

1369

1415

# PropertyChanged - signal

1416

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

1370

1417

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

1371

1418

def PropertyChanged(self, property, value):

1372

1419

"D-Bus signal"

1436

1483

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

1437

1484

1438

1485

# ApprovedByDefault - property

1439

@dbus_service_property(_interface, signature="b",

1486

@dbus_service_property(_interface,

1487

signature="b",

1440

1488

access="readwrite")

1441

1489

def ApprovedByDefault_dbus_property(self, value=None):

1442

1490

if value is None: # get

1444

1492

self.approved_by_default = bool(value)

1445

1493

1446

1494

# ApprovalDelay - property

1447

@dbus_service_property(_interface, signature="t",

1495

@dbus_service_property(_interface,

1496

signature="t",

1448

1497

access="readwrite")

1449

1498

def ApprovalDelay_dbus_property(self, value=None):

1450

1499

if value is None: # get

1451

return dbus.UInt64(self.approval_delay_milliseconds())

1500

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

1501

* 1000)

1452

1502

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

1453

1503

1454

1504

# ApprovalDuration - property

1455

@dbus_service_property(_interface, signature="t",

1505

@dbus_service_property(_interface,

1506

signature="t",

1456

1507

access="readwrite")

1457

1508

def ApprovalDuration_dbus_property(self, value=None):

1458

1509

if value is None: # get

1459

return dbus.UInt64(timedelta_to_milliseconds(

1460

self.approval_duration))

1510

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

1511

* 1000)

1461

1512

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

1462

1513

1463

1514

# Name - property

1471

1522

return dbus.String(self.fingerprint)

1472

1523

1473

1524

# Host - property

1474

@dbus_service_property(_interface, signature="s",

1525

@dbus_service_property(_interface,

1526

signature="s",

1475

1527

access="readwrite")

1476

1528

def Host_dbus_property(self, value=None):

1477

1529

if value is None: # get

1478

1530

return dbus.String(self.host)

1479

self.host = unicode(value)

1531

self.host = str(value)

1480

1532

1481

1533

# Created - property

1482

1534

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

1489

1541

return datetime_to_dbus(self.last_enabled)

1490

1542

1491

1543

# Enabled - property

1492

@dbus_service_property(_interface, signature="b",

1544

@dbus_service_property(_interface,

1545

signature="b",

1493

1546

access="readwrite")

1494

1547

def Enabled_dbus_property(self, value=None):

1495

1548

if value is None: # get

1500

1553

self.disable()

1501

1554

1502

1555

# LastCheckedOK - property

1503

@dbus_service_property(_interface, signature="s",

1556

@dbus_service_property(_interface,

1557

signature="s",

1504

1558

access="readwrite")

1505

1559

def LastCheckedOK_dbus_property(self, value=None):

1506

1560

if value is not None:

1509

1563

return datetime_to_dbus(self.last_checked_ok)

1510

1564

1511

1565

# LastCheckerStatus - property

1512

@dbus_service_property(_interface, signature="n",

1513

access="read")

1566

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

1514

1567

def LastCheckerStatus_dbus_property(self):

1515

1568

return dbus.Int16(self.last_checker_status)

1516

1569

1525

1578

return datetime_to_dbus(self.last_approval_request)

1526

1579

1527

1580

# Timeout - property

1528

@dbus_service_property(_interface, signature="t",

1581

@dbus_service_property(_interface,

1582

signature="t",

1529

1583

access="readwrite")

1530

1584

def Timeout_dbus_property(self, value=None):

1531

1585

if value is None: # get

1532

return dbus.UInt64(self.timeout_milliseconds())

1586

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

1533

1587

old_timeout = self.timeout

1534

1588

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

1535

1589

# Reschedule disabling

1544

1598

is None):

1545

1599

return

1546

1600

gobject.source_remove(self.disable_initiator_tag)

1547

self.disable_initiator_tag = (

1548

gobject.timeout_add(

1549

timedelta_to_milliseconds(self.expires - now),

1550

self.disable))

1601

self.disable_initiator_tag = gobject.timeout_add(

1602

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

1603

self.disable)

1551

1604

1552

1605

# ExtendedTimeout - property

1553

@dbus_service_property(_interface, signature="t",

1606

@dbus_service_property(_interface,

1607

signature="t",

1554

1608

access="readwrite")

1555

1609

def ExtendedTimeout_dbus_property(self, value=None):

1556

1610

if value is None: # get

1557

return dbus.UInt64(self.extended_timeout_milliseconds())

1611

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

1612

* 1000)

1558

1613

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

1559

1614

1560

1615

# Interval - property

1561

@dbus_service_property(_interface, signature="t",

1616

@dbus_service_property(_interface,

1617

signature="t",

1562

1618

access="readwrite")

1563

1619

def Interval_dbus_property(self, value=None):

1564

1620

if value is None: # get

1565

return dbus.UInt64(self.interval_milliseconds())

1621

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

1566

1622

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

1567

1623

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

1568

1624

return

1569

1625

if self.enabled:

1570

1626

# Reschedule checker run

1571

1627

gobject.source_remove(self.checker_initiator_tag)

1572

self.checker_initiator_tag = (gobject.timeout_add

1573

(value, self.start_checker))

1574

self.start_checker() # Start one now, too

1628

self.checker_initiator_tag = gobject.timeout_add(

1629

value, self.start_checker)

1630

self.start_checker() # Start one now, too

1575

1631

1576

1632

# Checker - property

1577

@dbus_service_property(_interface, signature="s",

1633

@dbus_service_property(_interface,

1634

signature="s",

1578

1635

access="readwrite")

1579

1636

def Checker_dbus_property(self, value=None):

1580

1637

if value is None: # get

1581

1638

return dbus.String(self.checker_command)

1582

self.checker_command = unicode(value)

1639

self.checker_command = str(value)

1583

1640

1584

1641

# CheckerRunning - property

1585

@dbus_service_property(_interface, signature="b",

1642

@dbus_service_property(_interface,

1643

signature="b",

1586

1644

access="readwrite")

1587

1645

def CheckerRunning_dbus_property(self, value=None):

1588

1646

if value is None: # get

1598

1656

return self.dbus_object_path # is already a dbus.ObjectPath

1599

1657

1600

1658

# Secret = property

1601

@dbus_service_property(_interface, signature="ay",

1602

access="write", byte_arrays=True)

1659

@dbus_service_property(_interface,

1660

signature="ay",

1661

access="write",

1662

byte_arrays=True)

1603

1663

def Secret_dbus_property(self, value):

1604

self.secret = str(value)

1664

self.secret = bytes(value)

1605

1665

1606

1666

del _interface

1607

1667

1621

1681

if data[0] == 'data':

1622

1682

return data[1]

1623

1683

if data[0] == 'function':

1684

1624

1685

def func(*args, **kwargs):

1625

1686

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

1626

1687

return self._pipe.recv()[1]

1688

1627

1689

return func

1628

1690

1629

1691

def __setattr__(self, name, value):

1641

1703

def handle(self):

1642

1704

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

1643

1705

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

1644

unicode(self.client_address))

1706

str(self.client_address))

1645

1707

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

1646

1708

self.server.child_pipe.fileno())

1647

1709

1648

session = (gnutls.connection

1649

.ClientSession(self.request,

1650

gnutls.connection

1651

.X509Credentials()))

1710

session = gnutls.connection.ClientSession(

1711

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

1652

1712

1653

1713

# Note: gnutls.connection.X509Credentials is really a

1654

1714

# generic GnuTLS certificate credentials object so long as

1663

1723

priority = self.server.gnutls_priority

1664

1724

if priority is None:

1665

1725

priority = "NORMAL"

1666

(gnutls.library.functions

1667

.gnutls_priority_set_direct(session._c_object,

1668

priority, None))

1726

gnutls.library.functions.gnutls_priority_set_direct(

1727

session._c_object, priority, None)

1669

1728

1670

1729

# Start communication using the Mandos protocol

1671

1730

# Get protocol number

1673

1732

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

1674

1733

try:

1675

1734

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

1676

raise RuntimeError

1735

raise RuntimeError(line)

1677

1736

except (ValueError, IndexError, RuntimeError) as error:

1678

1737

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

1679

1738

return

1691

1750

approval_required = False

1692

1751

try:

1693

1752

try:

1694

fpr = self.fingerprint(self.peer_certificate

1695

(session))

1753

fpr = self.fingerprint(

1754

self.peer_certificate(session))

1696

1755

except (TypeError,

1697

1756

gnutls.errors.GNUTLSError) as error:

1698

1757

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

1713

1772

while True:

1714

1773

if not client.enabled:

1715

1774

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

1716

client.name)

1775

client.name)

1717

1776

if self.server.use_dbus:

1718

1777

# Emit D-Bus signal

1719

1778

client.Rejected("Disabled")

1728

1787

if self.server.use_dbus:

1729

1788

# Emit D-Bus signal

1730

1789

client.NeedApproval(

1731

client.approval_delay_milliseconds(),

1732

client.approved_by_default)

1790

client.approval_delay.total_seconds()

1791

* 1000, client.approved_by_default)

1733

1792

else:

1734

1793

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

1735

1794

client.name)

1741

1800

#wait until timeout or approved

1742

1801

time = datetime.datetime.now()

1743

1802

client.changedstate.acquire()

1744

client.changedstate.wait(

1745

float(timedelta_to_milliseconds(delay)

1746

/ 1000))

1803

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

1747

1804

client.changedstate.release()

1748

1805

time2 = datetime.datetime.now()

1749

1806

if (time2 - time) >= delay:

1768

1825

logger.warning("gnutls send failed",

1769

1826

exc_info=error)

1770

1827

return

1771

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

1772

sent, len(client.secret)

1773

- (sent_size + sent))

1828

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

1829

len(client.secret) - (sent_size

1830

+ sent))

1774

1831

sent_size += sent

1775

1832

1776

1833

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

1793

1850

def peer_certificate(session):

1794

1851

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

1795

1852

# If not an OpenPGP certificate...

1796

if (gnutls.library.functions

1797

.gnutls_certificate_type_get(session._c_object)

1853

if (gnutls.library.functions.gnutls_certificate_type_get(

1854

session._c_object)

1798

1855

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1799

1856

# ...do the normal thing

1800

1857

return session.peer_certificate

1814

1871

def fingerprint(openpgp):

1815

1872

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

1816

1873

# New GnuTLS "datum" with the OpenPGP public key

1817

datum = (gnutls.library.types

1818

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

1819

ctypes.POINTER

1820

(ctypes.c_ubyte)),

1821

ctypes.c_uint(len(openpgp))))

1874

datum = gnutls.library.types.gnutls_datum_t(

1875

ctypes.cast(ctypes.c_char_p(openpgp),

1876

ctypes.POINTER(ctypes.c_ubyte)),

1877

ctypes.c_uint(len(openpgp)))

1822

1878

# New empty GnuTLS certificate

1823

1879

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1824

(gnutls.library.functions

1825

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

1880

gnutls.library.functions.gnutls_openpgp_crt_init(

1881

ctypes.byref(crt))

1826

1882

# Import the OpenPGP public key into the certificate

1827

(gnutls.library.functions

1828

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

1829

gnutls.library.constants

1830

.GNUTLS_OPENPGP_FMT_RAW))

1883

gnutls.library.functions.gnutls_openpgp_crt_import(

1884

crt, ctypes.byref(datum),

1885

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

1831

1886

# Verify the self signature in the key

1832

1887

crtverify = ctypes.c_uint()

1833

(gnutls.library.functions

1834

.gnutls_openpgp_crt_verify_self(crt, 0,

1835

ctypes.byref(crtverify)))

1888

gnutls.library.functions.gnutls_openpgp_crt_verify_self(

1889

crt, 0, ctypes.byref(crtverify))

1836

1890

if crtverify.value != 0:

1837

1891

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1838

raise (gnutls.errors.CertificateSecurityError

1839

("Verify failed"))

1892

raise gnutls.errors.CertificateSecurityError(

1893

"Verify failed")

1840

1894

# New buffer for the fingerprint

1841

1895

buf = ctypes.create_string_buffer(20)

1842

1896

buf_len = ctypes.c_size_t()

1843

1897

# Get the fingerprint from the certificate into the buffer

1844

(gnutls.library.functions

1845

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

1846

ctypes.byref(buf_len)))

1898

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(

1899

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

1847

1900

# Deinit the certificate

1848

1901

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1849

1902

# Convert the buffer to a Python bytestring

1855

1908

1856

1909

class MultiprocessingMixIn(object):

1857

1910

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

1911

1858

1912

def sub_process_main(self, request, address):

1859

1913

try:

1860

1914

self.finish_request(request, address)

1872

1926

1873

1927

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1874

1928

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

1929

1875

1930

def process_request(self, request, client_address):

1876

1931

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

1877

1932

1886

1941

1887

1942

def add_pipe(self, parent_pipe, proc):

1888

1943

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

1889

raise NotImplementedError

1944

raise NotImplementedError()

1890

1945

1891

1946

1892

1947

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1898

1953

interface: None or a network interface name (string)

1899

1954

use_ipv6: Boolean; to use IPv6 or not

1900

1955

"""

1956

1901

1957

def __init__(self, server_address, RequestHandlerClass,

1902

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

1958

interface=None,

1959

use_ipv6=True,

1960

socketfd=None):

1903

1961

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

1904

1962

creating a new one with socket.socket().

1905

1963

"""

1946

2004

self.interface)

1947

2005

else:

1948

2006

try:

1949

self.socket.setsockopt(socket.SOL_SOCKET,

1950

SO_BINDTODEVICE,

1951

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

2007

self.socket.setsockopt(

2008

socket.SOL_SOCKET, SO_BINDTODEVICE,

2009

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

1952

2010

except socket.error as error:

1953

2011

if error.errno == errno.EPERM:

1954

2012

logger.error("No permission to bind to"

1968

2026

if self.address_family == socket.AF_INET6:

1969

2027

any_address = "::" # in6addr_any

1970

2028

else:

1971

any_address = socket.INADDR_ANY

2029

any_address = "0.0.0.0" # INADDR_ANY

1972

2030

self.server_address = (any_address,

1973

2031

self.server_address[1])

1974

2032

elif not self.server_address[1]:

1975

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

1976

0)

2033

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

1977

2034

# if self.interface:

1978

2035

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

1979

2036

# 0, # port

1993

2050

1994

2051

Assumes a gobject.MainLoop event loop.

1995

2052

"""

2053

1996

2054

def __init__(self, server_address, RequestHandlerClass,

1997

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

1998

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

2055

interface=None,

2056

use_ipv6=True,

2057

clients=None,

2058

gnutls_priority=None,

2059

use_dbus=True,

2060

socketfd=None):

1999

2061

self.enabled = False

2000

2062

self.clients = clients

2001

2063

if self.clients is None:

2007

2069

interface = interface,

2008

2070

use_ipv6 = use_ipv6,

2009

2071

socketfd = socketfd)

2072

2010

2073

def server_activate(self):

2011

2074

if self.enabled:

2012

2075

return socketserver.TCPServer.server_activate(self)

2016

2079

2017

2080

def add_pipe(self, parent_pipe, proc):

2018

2081

# Call "handle_ipc" for both data and EOF events

2019

gobject.io_add_watch(parent_pipe.fileno(),

2020

gobject.IO_IN | gobject.IO_HUP,

2021

functools.partial(self.handle_ipc,

2022

parent_pipe =

2023

parent_pipe,

2024

proc = proc))

2082

gobject.io_add_watch(

2083

parent_pipe.fileno(),

2084

gobject.IO_IN | gobject.IO_HUP,

2085

functools.partial(self.handle_ipc,

2086

parent_pipe = parent_pipe,

2087

proc = proc))

2025

2088

2026

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

2027

proc = None, client_object=None):

2089

def handle_ipc(self, source, condition,

2090

parent_pipe=None,

2091

proc = None,

2092

client_object=None):

2028

2093

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

2029

2094

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

2030

2095

# Wait for other process to exit

2053

2118

parent_pipe.send(False)

2054

2119

return False

2055

2120

2056

gobject.io_add_watch(parent_pipe.fileno(),

2057

gobject.IO_IN | gobject.IO_HUP,

2058

functools.partial(self.handle_ipc,

2059

parent_pipe =

2060

parent_pipe,

2061

proc = proc,

2062

client_object =

2063

client))

2121

gobject.io_add_watch(

2122

parent_pipe.fileno(),

2123

gobject.IO_IN | gobject.IO_HUP,

2124

functools.partial(self.handle_ipc,

2125

parent_pipe = parent_pipe,

2126

proc = proc,

2127

client_object = client))

2064

2128

parent_pipe.send(True)

2065

2129

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

2066

2130

# same fileno

2072

2136

2073

2137

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

2074

2138

funcname)(*args,

2075

**kwargs)))

2139

**kwargs)))

2076

2140

2077

2141

if command == 'getattr':

2078

2142

attrname = request[1]

2079

2143

if callable(client_object.__getattribute__(attrname)):

2080

parent_pipe.send(('function',))

2144

parent_pipe.send(('function', ))

2081

2145

else:

2082

parent_pipe.send(('data', client_object

2083

.__getattribute__(attrname)))

2146

parent_pipe.send((

2147

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

2084

2148

2085

2149

if command == 'setattr':

2086

2150

attrname = request[1]

2090

2154

return True

2091

2155

2092

2156

2157

def rfc3339_duration_to_delta(duration):

2158

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

2159

2160

>>> rfc3339_duration_to_delta("P7D")

2161

datetime.timedelta(7)

2162

>>> rfc3339_duration_to_delta("PT60S")

2163

datetime.timedelta(0, 60)

2164

>>> rfc3339_duration_to_delta("PT60M")

2165

datetime.timedelta(0, 3600)

2166

>>> rfc3339_duration_to_delta("PT24H")

2167

datetime.timedelta(1)

2168

>>> rfc3339_duration_to_delta("P1W")

2169

datetime.timedelta(7)

2170

>>> rfc3339_duration_to_delta("PT5M30S")

2171

datetime.timedelta(0, 330)

2172

>>> rfc3339_duration_to_delta("P1DT3M20S")

2173

datetime.timedelta(1, 200)

2174

"""

2175

2176

# Parsing an RFC 3339 duration with regular expressions is not

2177

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

2178

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

2179

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

2180

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

2181

# avoid excessive use of external libraries.

2182

2183

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

2184

Token = collections.namedtuple("Token",

2185

("regexp", # To match token; if

2186

# "value" is not None,

2187

# must have a "group"

2188

# containing digits

2189

"value", # datetime.timedelta or

2190

# None

2191

"followers")) # Tokens valid after

2192

# this token

2193

Token = collections.namedtuple("Token", (

2194

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

2195

# a "group" containing digits

2196

"value", # datetime.timedelta or None

2197

"followers")) # Tokens valid after this token

2198

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

2199

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

2200

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

2201

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

2202

datetime.timedelta(seconds=1),

2203

frozenset((token_end, )))

2204

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

2205

datetime.timedelta(minutes=1),

2206

frozenset((token_second, token_end)))

2207

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

2208

datetime.timedelta(hours=1),

2209

frozenset((token_minute, token_end)))

2210

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

2211

None,

2212

frozenset((token_hour, token_minute,

2213

token_second)))

2214

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

2215

datetime.timedelta(days=1),

2216

frozenset((token_time, token_end)))

2217

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

2218

datetime.timedelta(weeks=4),

2219

frozenset((token_day, token_end)))

2220

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

2221

datetime.timedelta(weeks=52),

2222

frozenset((token_month, token_end)))

2223

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

2224

datetime.timedelta(weeks=1),

2225

frozenset((token_end, )))

2226

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

2227

frozenset((token_year, token_month,

2228

token_day, token_time,

2229

token_week)))

2230

# Define starting values

2231

value = datetime.timedelta() # Value so far

2232

found_token = None

2233

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

2234

s = duration # String left to parse

2235

# Loop until end token is found

2236

while found_token is not token_end:

2237

# Search for any currently valid tokens

2238

for token in followers:

2239

match = token.regexp.match(s)

2240

if match is not None:

2241

# Token found

2242

if token.value is not None:

2243

# Value found, parse digits

2244

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

2245

# Add to value so far

2246

value += factor * token.value

2247

# Strip token from string

2248

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

2249

# Go to found token

2250

found_token = token

2251

# Set valid next tokens

2252

followers = found_token.followers

2253

break

2254

else:

2255

# No currently valid tokens were found

2256

raise ValueError("Invalid RFC 3339 duration")

2257

# End token found

2258

return value

2259

2260

2093

2261

def string_to_delta(interval):

2094

2262

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

2095

2263

2106

2274

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

2107

2275

datetime.timedelta(0, 330)

2108

2276

"""

2277

2278

try:

2279

return rfc3339_duration_to_delta(interval)

2280

except ValueError:

2281

pass

2282

2109

2283

timevalue = datetime.timedelta(0)

2110

2284

for s in interval.split():

2111

2285

try:

2112

suffix = unicode(s[-1])

2286

suffix = s[-1]

2113

2287

value = int(s[:-1])

2114

2288

if suffix == "d":

2115

2289

delta = datetime.timedelta(value)

2122

2296

elif suffix == "w":

2123

2297

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

2124

2298

else:

2125

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

2126

.format(suffix))

2127

except (ValueError, IndexError) as e:

2299

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

2300

except IndexError as e:

2128

2301

raise ValueError(*(e.args))

2129

2302

timevalue += delta

2130

2303

return timevalue

2146

2319

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

2147

2320

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

2148

2321

raise OSError(errno.ENODEV,

2149

"{0} not a character device"

2322

"{} not a character device"

2150

2323

.format(os.devnull))

2151

2324

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

2152

2325

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

2162

2335

2163

2336

parser = argparse.ArgumentParser()

2164

2337

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

2165

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

2338

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

2166

2339

help="show version number and exit")

2167

2340

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

2168

2341

help="Bind to interface IF")

2174

2347

help="Run self-test")

2175

2348

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

2176

2349

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

2177

" to terminal")

2350

" to terminal", default=None)

2178

2351

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

2179

2352

help="Debug level for stdout output")

2180

2353

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

2187

2360

" files")

2188

2361

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

2189

2362

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

2190

" system bus interface")

2363

" system bus interface", default=None)

2191

2364

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

2192

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

2365

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

2366

default=None)

2193

2367

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

2194

2368

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

2195

" state")

2369

" state", default=None)

2196

2370

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

2197

2371

help="Specify a file descriptor to a network"

2198

2372

" socket to use instead of creating one")

2199

2373

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

2200

2374

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

2201

2375

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

2202

help="Run in foreground")

2376

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

2377

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

2378

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

2379

default=None)

2203

2380

2204

2381

options = parser.parse_args()

2205

2382

2206

2383

if options.check:

2207

2384

import doctest

2208

doctest.testmod()

2209

sys.exit()

2385

fail_count, test_count = doctest.testmod()

2386

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

2210

2387

2211

2388

# Default values for config file for server-global settings

2212

2389

server_defaults = { "interface": "",

2214

2391

"port": "",

2215

2392

"debug": "False",

2216

2393

"priority":

2217

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

2394

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

2395

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

2218

2396

"servicename": "Mandos",

2219

2397

"use_dbus": "True",

2220

2398

"use_ipv6": "True",

2223

2401

"socket": "",

2224

2402

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

2225

2403

"foreground": "False",

2226

}

2404

"zeroconf": "True",

2405

}

2227

2406

2228

2407

# Parse config file for server-global settings

2229

2408

server_config = configparser.SafeConfigParser(server_defaults)

2230

2409

del server_defaults

2231

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

2232

"mandos.conf"))

2410

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

2233

2411

# Convert the SafeConfigParser object to a dict

2234

2412

server_settings = server_config.defaults()

2235

2413

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

2253

2431

# Override the settings from the config file with command line

2254

2432

# options, if set.

2255

2433

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

2256

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

2257

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

2258

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

2434

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

2435

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

2436

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

2259

2437

value = getattr(options, option)

2260

2438

if value is not None:

2261

2439

server_settings[option] = value

2262

2440

del options

2263

2441

# Force all strings to be unicode

2264

2442

for option in server_settings.keys():

2265

if type(server_settings[option]) is str:

2266

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

2443

if isinstance(server_settings[option], bytes):

2444

server_settings[option] = (server_settings[option]

2445

.decode("utf-8"))

2446

# Force all boolean options to be boolean

2447

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

2448

"foreground", "zeroconf"):

2449

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

2267

2450

# Debug implies foreground

2268

2451

if server_settings["debug"]:

2269

2452

server_settings["foreground"] = True

2271

2454

2272

2455

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

2273

2456

2457

if (not server_settings["zeroconf"]

2458

and not (server_settings["port"]

2459

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

2460

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

2461

2274

2462

# For convenience

2275

2463

debug = server_settings["debug"]

2276

2464

debuglevel = server_settings["debuglevel"]

2279

2467

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

2280

2468

stored_state_file)

2281

2469

foreground = server_settings["foreground"]

2470

zeroconf = server_settings["zeroconf"]

2282

2471

2283

2472

if debug:

2284

2473

initlogger(debug, logging.DEBUG)

2290

2479

initlogger(debug, level)

2291

2480

2292

2481

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

2293

syslogger.setFormatter(logging.Formatter

2294

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

2295

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

2296

.format(server_settings

2297

["servicename"])))

2482

syslogger.setFormatter(

2483

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

2484

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

2485

server_settings["servicename"])))

2298

2486

2299

2487

# Parse config file with clients

2300

2488

client_config = configparser.SafeConfigParser(Client

2305

2493

global mandos_dbus_service

2306

2494

mandos_dbus_service = None

2307

2495

2308

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

2309

server_settings["port"]),

2310

ClientHandler,

2311

interface=(server_settings["interface"]

2312

or None),

2313

use_ipv6=use_ipv6,

2314

gnutls_priority=

2315

server_settings["priority"],

2316

use_dbus=use_dbus,

2317

socketfd=(server_settings["socket"]

2318

or None))

2496

socketfd = None

2497

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

2498

socketfd = server_settings["socket"]

2499

tcp_server = MandosServer(

2500

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

2501

ClientHandler,

2502

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

2503

use_ipv6=use_ipv6,

2504

gnutls_priority=server_settings["priority"],

2505

use_dbus=use_dbus,

2506

socketfd=socketfd)

2319

2507

if not foreground:

2320

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

2508

pidfilename = "/run/mandos.pid"

2509

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

2510

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

2321

2511

pidfile = None

2322

2512

try:

2323

2513

pidfile = open(pidfilename, "w")

2340

2530

os.setuid(uid)

2341

2531

except OSError as error:

2342

2532

if error.errno != errno.EPERM:

2343

raise error

2533

raise

2344

2534

2345

2535

if debug:

2346

2536

# Enable all possible GnuTLS debugging

2353

2543

def debug_gnutls(level, string):

2354

2544

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

2355

2545

2356

(gnutls.library.functions

2357

.gnutls_global_set_log_function(debug_gnutls))

2546

gnutls.library.functions.gnutls_global_set_log_function(

2547

debug_gnutls)

2358

2548

2359

2549

# Redirect stdin so all checkers get /dev/null

2360

2550

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

2380

2570

if use_dbus:

2381

2571

try:

2382

2572

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

2383

bus, do_not_queue=True)

2384

old_bus_name = (dbus.service.BusName

2385

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

2386

do_not_queue=True))

2387

except dbus.exceptions.NameExistsException as e:

2573

bus,

2574

do_not_queue=True)

2575

old_bus_name = dbus.service.BusName(

2576

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

2577

do_not_queue=True)

2578

except dbus.exceptions.DBusException as e:

2388

2579

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

2389

2580

use_dbus = False

2390

2581

server_settings["use_dbus"] = False

2391

2582

tcp_server.use_dbus = False

2392

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2393

service = AvahiServiceToSyslog(name =

2394

server_settings["servicename"],

2395

servicetype = "_mandos._tcp",

2396

protocol = protocol, bus = bus)

2397

if server_settings["interface"]:

2398

service.interface = (if_nametoindex

2399

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

2583

if zeroconf:

2584

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2585

service = AvahiServiceToSyslog(

2586

name = server_settings["servicename"],

2587

servicetype = "_mandos._tcp",

2588

protocol = protocol,

2589

bus = bus)

2590

if server_settings["interface"]:

2591

service.interface = if_nametoindex(

2592

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

2400

2593

2401

2594

global multiprocessing_manager

2402

2595

multiprocessing_manager = multiprocessing.Manager()

2409

2602

old_client_settings = {}

2410

2603

clients_data = {}

2411

2604

2605

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

2606

global wnull

2607

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

2608

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

2609

# mode

2610

if debug or not foreground:

2611

wnull.close()

2612

2412

2613

# Get client data and settings from last running state.

2413

2614

if server_settings["restore"]:

2414

2615

try:

2415

2616

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

2416

clients_data, old_client_settings = (pickle.load

2417

(stored_state))

2617

clients_data, old_client_settings = pickle.load(

2618

stored_state)

2418

2619

os.remove(stored_state_path)

2419

2620

except IOError as e:

2420

2621

if e.errno == errno.ENOENT:

2421

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

2422

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

2622

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

2623

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

2423

2624

else:

2424

2625

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

2425

2626

exc_info=e)

2426

2627

raise

2427

2628

except EOFError as e:

2428

2629

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

2429

"EOFError:", exc_info=e)

2630

"EOFError:",

2631

exc_info=e)

2430

2632

2431

2633

with PGPEngine() as pgp:

2432

for client_name, client in clients_data.iteritems():

2634

for client_name, client in clients_data.items():

2635

# Skip removed clients

2636

if client_name not in client_settings:

2637

continue

2638

2433

2639

# Decide which value to use after restoring saved state.

2434

2640

# We have three different values: Old config file,

2435

2641

# new config file, and saved state.

2440

2646

# For each value in new config, check if it

2441

2647

# differs from the old config value (Except for

2442

2648

# the "secret" attribute)

2443

if (name != "secret" and

2444

value != old_client_settings[client_name]

2445

[name]):

2649

if (name != "secret"

2650

and (value !=

2651

old_client_settings[client_name][name])):

2446

2652

client[name] = value

2447

2653

except KeyError:

2448

2654

pass

2456

2662

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

2457

2663

if not client["last_checked_ok"]:

2458

2664

logger.warning(

2459

"disabling client {0} - Client never "

2460

"performed a successful checker"

2461

.format(client_name))

2665

"disabling client {} - Client never "

2666

"performed a successful checker".format(

2667

client_name))

2462

2668

client["enabled"] = False

2463

2669

elif client["last_checker_status"] != 0:

2464

2670

logger.warning(

2465

"disabling client {0} - Client "

2466

"last checker failed with error code {1}"

2467

.format(client_name,

2468

client["last_checker_status"]))

2671

"disabling client {} - Client last"

2672

" checker failed with error code"

2673

" {}".format(

2674

client_name,

2675

client["last_checker_status"]))

2469

2676

client["enabled"] = False

2470

2677

else:

2471

client["expires"] = (datetime.datetime

2472

.utcnow()

2473

+ client["timeout"])

2678

client["expires"] = (

2679

datetime.datetime.utcnow()

2680

+ client["timeout"])

2474

2681

logger.debug("Last checker succeeded,"

2475

" keeping {0} enabled"

2476

.format(client_name))

2682

" keeping {} enabled".format(

2683

client_name))

2477

2684

try:

2478

client["secret"] = (

2479

pgp.decrypt(client["encrypted_secret"],

2480

client_settings[client_name]

2481

["secret"]))

2685

client["secret"] = pgp.decrypt(

2686

client["encrypted_secret"],

2687

client_settings[client_name]["secret"])

2482

2688

except PGPError:

2483

2689

# If decryption fails, we use secret from new settings

2484

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

2485

.format(client_name))

2486

client["secret"] = (

2487

client_settings[client_name]["secret"])

2690

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

2691

client_name))

2692

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

2693

["secret"])

2488

2694

2489

2695

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

2490

2696

for client_name in (set(old_client_settings)

2495

2701

clients_data[client_name] = client_settings[client_name]

2496

2702

2497

2703

# Create all client objects

2498

for client_name, client in clients_data.iteritems():

2704

for client_name, client in clients_data.items():

2499

2705

tcp_server.clients[client_name] = client_class(

2500

name = client_name, settings = client)

2706

name = client_name,

2707

settings = client,

2708

server_settings = server_settings)

2501

2709

2502

2710

if not tcp_server.clients:

2503

2711

logger.warning("No clients defined")

2507

2715

try:

2508

2716

with pidfile:

2509

2717

pid = os.getpid()

2510

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

2718

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

2511

2719

except IOError:

2512

2720

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

2513

2721

pidfilename, pid)

2518

2726

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

2519

2727

2520

2728

if use_dbus:

2521

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

2522

"se.bsnet.fukt.Mandos"})

2729

2730

@alternate_dbus_interfaces(

2731

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

2523

2732

class MandosDBusService(DBusObjectWithProperties):

2524

2733

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

2734

2525

2735

def __init__(self):

2526

2736

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

2737

2527

2738

_interface = "se.recompile.Mandos"

2528

2739

2529

2740

@dbus_interface_annotations(_interface)

2530

2741

def _foo(self):

2531

return { "org.freedesktop.DBus.Property"

2532

".EmitsChangedSignal":

2533

"false"}

2742

return {

2743

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

2744

"false" }

2534

2745

2535

2746

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

2536

2747

def ClientAdded(self, objpath):

2550

2761

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

2551

2762

def GetAllClients(self):

2552

2763

"D-Bus method"

2553

return dbus.Array(c.dbus_object_path

2554

for c in

2764

return dbus.Array(c.dbus_object_path for c in

2555

2765

tcp_server.clients.itervalues())

2556

2766

2557

2767

@dbus.service.method(_interface,

2559

2769

def GetAllClientsWithProperties(self):

2560

2770

"D-Bus method"

2561

2771

return dbus.Dictionary(

2562

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

2563

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

2772

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

2773

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

2564

2774

signature="oa{sv}")

2565

2775

2566

2776

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

2583

2793

2584

2794

def cleanup():

2585

2795

"Cleanup function; run on exit"

2586

service.cleanup()

2796

if zeroconf:

2797

service.cleanup()

2587

2798

2588

2799

multiprocessing.active_children()

2800

wnull.close()

2589

2801

if not (tcp_server.clients or client_settings):

2590

2802

return

2591

2803

2602

2814

2603

2815

# A list of attributes that can not be pickled

2604

2816

# + secret.

2605

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

2606

"checker"))

2607

for name, typ in (inspect.getmembers

2608

(dbus.service.Object)):

2817

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

2818

"checker", "server_settings" }

2819

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

2820

.Object):

2609

2821

exclude.add(name)

2610

2822

2611

2823

client_dict["encrypted_secret"] = (client

2618

2830

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

2619

2831

2620

2832

try:

2621

with (tempfile.NamedTemporaryFile

2622

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

2623

dir=os.path.dirname(stored_state_path),

2624

delete=False)) as stored_state:

2833

with tempfile.NamedTemporaryFile(

2834

mode='wb',

2835

suffix=".pickle",

2836

prefix='clients-',

2837

dir=os.path.dirname(stored_state_path),

2838

delete=False) as stored_state:

2625

2839

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

2626

tempname=stored_state.name

2840

tempname = stored_state.name

2627

2841

os.rename(tempname, stored_state_path)

2628

2842

except (IOError, OSError) as e:

2629

2843

if not debug:

2632

2846

except NameError:

2633

2847

pass

2634

2848

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

2635

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

2849

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

2636

2850

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

2637

2851

else:

2638

2852

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

2639

2853

exc_info=e)

2640

raise e

2854

raise

2641

2855

2642

2856

# Delete all clients, and settings from config

2643

2857

while tcp_server.clients:

2648

2862

client.disable(quiet=True)

2649

2863

if use_dbus:

2650

2864

# Emit D-Bus signal

2651

mandos_dbus_service.ClientRemoved(client

2652

.dbus_object_path,

2653

client.name)

2865

mandos_dbus_service.ClientRemoved(

2866

client.dbus_object_path, client.name)

2654

2867

client_settings.clear()

2655

2868

2656

2869

atexit.register(cleanup)

2667

2880

tcp_server.server_activate()

2668

2881

2669

2882

# Find out what port we got

2670

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

2883

if zeroconf:

2884

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

2671

2885

if use_ipv6:

2672

2886

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

2673

2887

" flowinfo %d, scope_id %d",

2679

2893

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

2680

2894

2681

2895

try:

2682

# From the Avahi example code

2683

try:

2684

service.activate()

2685

except dbus.exceptions.DBusException as error:

2686

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

2687

cleanup()

2688

sys.exit(1)

2689

# End of Avahi example code

2896

if zeroconf:

2897

# From the Avahi example code

2898

try:

2899

service.activate()

2900

except dbus.exceptions.DBusException as error:

2901

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

2902

cleanup()

2903

sys.exit(1)

2904

# End of Avahi example code

2690

2905

2691

2906

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

2692

2907

lambda *args, **kwargs:

2707

2922

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

2708

2923

cleanup()

2709

2924

2925

2710

2926

if __name__ == '__main__':

2711

2927

main()