/mandos/release : revision 237.7.297

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

72

81

73

82

import dbus

74

83

import dbus.service

75

import gobject

84

try:

85

import gobject

86

except ImportError:

87

from gi.repository import GObject as gobject

76

88

import avahi

77

89

from dbus.mainloop.glib import DBusGMainLoop

78

90

import ctypes

88

100

except ImportError:

89

101

SO_BINDTODEVICE = None

90

102

91

version = "1.6.6"

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

110

syslogger = None

96

111

97

112

try:

98

if_nametoindex = (ctypes.cdll.LoadLibrary

99

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

100

.if_nametoindex)

113

if_nametoindex = ctypes.cdll.LoadLibrary(

114

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

101

115

except (OSError, AttributeError):

116

102

117

def if_nametoindex(interface):

103

118

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

104

119

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

105

120

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

106

121

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

107

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

108

interface))

109

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

110

ifreq[16:20])[0]

122

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

123

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

111

124

return interface_index

112

125

113

126

115

128

"""init logger and add loglevel"""

116

129

117

130

global syslogger

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

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

131

syslogger = (logging.handlers.SysLogHandler(

132

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

133

address = "/dev/log"))

122

134

syslogger.setFormatter(logging.Formatter

123

135

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

124

136

' %(message)s'))

141

153

142

154

class PGPEngine(object):

143

155

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

156

144

157

def __init__(self):

145

158

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

146

159

self.gnupgargs = ['--batch',

185

198

186

199

def encrypt(self, data, password):

187

200

passphrase = self.password_encode(password)

188

with tempfile.NamedTemporaryFile(dir=self.tempdir

189

) as passfile:

201

with tempfile.NamedTemporaryFile(

202

dir=self.tempdir) as passfile:

190

203

passfile.write(passphrase)

191

204

passfile.flush()

192

205

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

203

216

204

217

def decrypt(self, data, password):

205

218

passphrase = self.password_encode(password)

206

with tempfile.NamedTemporaryFile(dir = self.tempdir

207

) as passfile:

219

with tempfile.NamedTemporaryFile(

220

dir = self.tempdir) as passfile:

208

221

passfile.write(passphrase)

209

222

passfile.flush()

210

223

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

214

227

stdin = subprocess.PIPE,

215

228

stdout = subprocess.PIPE,

216

229

stderr = subprocess.PIPE)

217

decrypted_plaintext, err = proc.communicate(input

218

= data)

230

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

219

231

if proc.returncode != 0:

220

232

raise PGPError(err)

221

233

return decrypted_plaintext

224

236

class AvahiError(Exception):

225

237

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

226

238

self.value = value

227

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

228

def __unicode__(self):

229

return unicode(repr(self.value))

239

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

240

**kwargs)

241

230

242

231

243

class AvahiServiceError(AvahiError):

232

244

pass

233

245

246

234

247

class AvahiGroupError(AvahiError):

235

248

pass

236

249

256

269

bus: dbus.SystemBus()

257

270

"""

258

271

259

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

260

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

261

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

262

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):

263

283

self.interface = interface

264

284

self.name = name

265

285

self.type = servicetype

275

295

self.bus = bus

276

296

self.entry_group_state_changed_match = None

277

297

278

def rename(self):

298

def rename(self, remove=True):

279

299

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

280

300

if self.rename_count >= self.max_renames:

281

301

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

282

302

" after %i retries, exiting.",

283

303

self.rename_count)

284

304

raise AvahiServiceError("Too many renames")

285

self.name = unicode(self.server

286

.GetAlternativeServiceName(self.name))

305

self.name = str(

306

self.server.GetAlternativeServiceName(self.name))

307

self.rename_count += 1

287

308

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

288

309

self.name)

289

self.remove()

310

if remove:

311

self.remove()

290

312

try:

291

313

self.add()

292

314

except dbus.exceptions.DBusException as error:

293

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

294

self.cleanup()

295

os._exit(1)

296

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)

297

323

298

324

def remove(self):

299

325

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

337

363

self.rename()

338

364

elif state == avahi.ENTRY_GROUP_FAILURE:

339

365

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

340

unicode(error))

341

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

342

.format(error))

366

str(error))

367

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

343

368

344

369

def cleanup(self):

345

370

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

355

380

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

356

381

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

357

382

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

358

bad_states = { avahi.SERVER_INVALID:

359

"Zeroconf server invalid",

360

avahi.SERVER_REGISTERING: None,

361

avahi.SERVER_COLLISION:

362

"Zeroconf server name collision",

363

avahi.SERVER_FAILURE:

364

"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

}

365

389

if state in bad_states:

366

390

if bad_states[state] is not None:

367

391

if error is None:

386

410

follow_name_owner_changes=True),

387

411

avahi.DBUS_INTERFACE_SERVER)

388

412

self.server.connect_to_signal("StateChanged",

389

self.server_state_changed)

413

self.server_state_changed)

390

414

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

391

415

392

416

393

417

class AvahiServiceToSyslog(AvahiService):

394

def rename(self):

418

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

395

419

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

396

ret = AvahiService.rename(self)

397

syslogger.setFormatter(logging.Formatter

398

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

399

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

400

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

401

424

return ret

402

425

403

426

404

def timedelta_to_milliseconds(td):

405

"Convert a datetime.timedelta() to milliseconds"

406

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

407

+ (td.seconds * 1000)

408

+ (td.microseconds // 1000))

409

410

411

427

class Client(object):

412

428

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

413

429

457

473

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

458

474

"last_approval_request", "last_checked_ok",

459

475

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

460

client_defaults = { "timeout": "PT5M",

461

"extended_timeout": "PT15M",

462

"interval": "PT2M",

463

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

464

"host": "",

465

"approval_delay": "PT0S",

466

"approval_duration": "PT1S",

467

"approved_by_default": "True",

468

"enabled": "True",

469

}

470

471

def timeout_milliseconds(self):

472

"Return the 'timeout' attribute in milliseconds"

473

return timedelta_to_milliseconds(self.timeout)

474

475

def extended_timeout_milliseconds(self):

476

"Return the 'extended_timeout' attribute in milliseconds"

477

return timedelta_to_milliseconds(self.extended_timeout)

478

479

def interval_milliseconds(self):

480

"Return the 'interval' attribute in milliseconds"

481

return timedelta_to_milliseconds(self.interval)

482

483

def approval_delay_milliseconds(self):

484

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

}

485

487

486

488

@staticmethod

487

489

def config_parser(config):

503

505

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

504

506

"enabled")

505

507

508

# Uppercase and remove spaces from fingerprint for later

509

# comparison purposes with return value from the

510

# fingerprint() function

506

511

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

507

512

.replace(" ", ""))

508

513

if "secret" in section:

513

518

"rb") as secfile:

514

519

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

515

520

else:

516

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

521

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

517

522

.format(section))

518

523

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

519

524

client["extended_timeout"] = string_to_delta(

536

541

server_settings = {}

537

542

self.server_settings = server_settings

538

543

# adding all client settings

539

for setting, value in settings.iteritems():

544

for setting, value in settings.items():

540

545

setattr(self, setting, value)

541

546

542

547

if self.enabled:

550

555

self.expires = None

551

556

552

557

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

553

# Uppercase and remove spaces from fingerprint for later

554

# comparison purposes with return value from the fingerprint()

555

# function

556

558

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

557

559

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

558

560

datetime.datetime.utcnow())

565

567

self.current_checker_command = None

566

568

self.approved = None

567

569

self.approvals_pending = 0

568

self.changedstate = (multiprocessing_manager

569

.Condition(multiprocessing_manager

570

.Lock()))

571

self.client_structure = [attr for attr in

572

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()

573

574

if not attr.startswith("_")]

574

575

self.client_structure.append("client_structure")

575

576

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

577

lambda obj:

578

isinstance(obj,

579

property)):

577

for name, t in inspect.getmembers(

578

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

580

579

if not name.startswith("_"):

581

580

self.client_structure.append(name)

582

581

624

623

# and every interval from then on.

625

624

if self.checker_initiator_tag is not None:

626

625

gobject.source_remove(self.checker_initiator_tag)

627

self.checker_initiator_tag = (gobject.timeout_add

628

(self.interval_milliseconds(),

629

self.start_checker))

626

self.checker_initiator_tag = gobject.timeout_add(

627

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

628

self.start_checker)

630

629

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

631

630

if self.disable_initiator_tag is not None:

632

631

gobject.source_remove(self.disable_initiator_tag)

633

self.disable_initiator_tag = (gobject.timeout_add

634

(self.timeout_milliseconds(),

635

self.disable))

632

self.disable_initiator_tag = gobject.timeout_add(

633

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

636

634

# Also start a new checker *right now*.

637

635

self.start_checker()

638

636

647

645

vars(self))

648

646

self.checked_ok()

649

647

else:

650

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

651

vars(self))

648

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

652

649

else:

653

650

self.last_checker_status = -1

654

651

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

668

665

gobject.source_remove(self.disable_initiator_tag)

669

666

self.disable_initiator_tag = None

670

667

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

671

self.disable_initiator_tag = (gobject.timeout_add

672

(timedelta_to_milliseconds

673

(timeout), self.disable))

668

self.disable_initiator_tag = gobject.timeout_add(

669

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

674

670

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

675

671

676

672

def need_approval(self):

707

703

# Start a new checker if needed

708

704

if self.checker is None:

709

705

# Escape attributes for the shell

710

escaped_attrs = dict(

711

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

712

for attr in

713

self.runtime_expansions)

706

escaped_attrs = {

707

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

708

for attr in self.runtime_expansions }

714

709

try:

715

710

command = self.checker_command % escaped_attrs

716

711

except TypeError as error:

717

712

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

718

self.checker_command, exc_info=error)

719

return True # Try again later

713

self.checker_command,

714

exc_info=error)

715

return True # Try again later

720

716

self.current_checker_command = command

721

717

try:

722

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

723

command, self.name)

718

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

719

self.name)

724

720

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

725

721

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

726

722

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

735

731

"stderr": wnull })

736

732

self.checker = subprocess.Popen(command,

737

733

close_fds=True,

738

shell=True, cwd="/",

734

shell=True,

735

cwd="/",

739

736

**popen_args)

740

737

except OSError as error:

741

738

logger.error("Failed to start subprocess",

742

739

exc_info=error)

743

740

return True

744

self.checker_callback_tag = (gobject.child_watch_add

745

(self.checker.pid,

746

self.checker_callback,

747

data=command))

741

self.checker_callback_tag = gobject.child_watch_add(

742

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

748

743

# The checker may have completed before the gobject

749

744

# watch was added. Check for this.

750

745

try:

781

776

self.checker = None

782

777

783

778

784

def dbus_service_property(dbus_interface, signature="v",

785

access="readwrite", byte_arrays=False):

779

def dbus_service_property(dbus_interface,

780

signature="v",

781

access="readwrite",

782

byte_arrays=False):

786

783

"""Decorators for marking methods of a DBusObjectWithProperties to

787

784

become properties on the D-Bus.

788

785

797

794

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

798

795

if byte_arrays and signature != "ay":

799

796

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

800

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

797

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

798

801

799

def decorator(func):

802

800

func._dbus_is_property = True

803

801

func._dbus_interface = dbus_interface

808

806

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

809

807

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

810

808

return func

809

811

810

return decorator

812

811

813

812

822

821

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

823

822

"false"}

824

823

"""

824

825

def decorator(func):

826

func._dbus_is_interface = True

827

func._dbus_interface = dbus_interface

828

func._dbus_name = dbus_interface

829

return func

830

831

return decorator

831

832

833

834

835

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

835

836

Usage:

836

837

838

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

839

"org.freedesktop.DBus.Property."

840

"EmitsChangedSignal": "false"})

837

841

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

838

842

access="r")

839

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

840

"org.freedesktop.DBus.Property."

841

"EmitsChangedSignal": "false"})

842

843

def Property_dbus_property(self):

843

844

return dbus.Boolean(False)

844

845

"""

846

845

847

def decorator(func):

846

848

func._dbus_annotations = annotations

847

849

return func

850

848

851

return decorator

849

852

850

853

851

854

class DBusPropertyException(dbus.exceptions.DBusException):

852

855

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

853

856

"""

854

def __unicode__(self):

855

return unicode(str(self))

857

pass

856

858

857

859

858

860

class DBusPropertyAccessException(DBusPropertyException):

882

884

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

883

885

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

884

886

"""

885

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

887

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

886

888

False)

887

889

888

890

def _get_all_dbus_things(self, thing):

889

891

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

890

892

"""

891

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

892

name),

893

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

893

894

athing.__get__(self))

894

895

for cls in self.__class__.__mro__

895

896

for name, athing in

896

inspect.getmembers(cls,

897

self._is_dbus_thing(thing)))

897

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

898

899

def _get_dbus_property(self, interface_name, property_name):

900

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

901

property with the specified name and interface.

902

"""

903

for cls in self.__class__.__mro__:

904

for name, value in (inspect.getmembers

905

(cls,

906

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")):

907

906

if (value._dbus_name == property_name

908

907

and value._dbus_interface == interface_name):

909

908

return value.__get__(self)

910

909

911

910

# No such property

912

raise DBusPropertyNotFound(self.dbus_object_path + ":"

913

+ interface_name + "."

914

+ property_name)

911

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

912

self.dbus_object_path, interface_name, property_name))

915

913

916

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

914

@dbus.service.method(dbus.PROPERTIES_IFACE,

915

in_signature="ss",

917

916

out_signature="v")

918

917

def Get(self, interface_name, property_name):

919

918

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

938

937

# signatures other than "ay".

939

938

if prop._dbus_signature != "ay":

940

939

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

941

"'ay' signature {0!r}"

940

"'ay' signature {!r}"

942

941

.format(prop._dbus_signature))

943

942

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

944

943

for byte in value))

945

944

prop(value)

946

945

947

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

946

@dbus.service.method(dbus.PROPERTIES_IFACE,

947

in_signature="s",

948

out_signature="a{sv}")

949

def GetAll(self, interface_name):

950

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

965

if not hasattr(value, "variant_level"):

966

properties[name] = value

967

continue

968

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

969

value.variant_level+1)

968

properties[name] = type(value)(

969

value, variant_level = value.variant_level + 1)

970

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

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

972

980

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

973

981

out_signature="s",

974

982

path_keyword='object_path',

982

990

connection)

983

991

try:

984

992

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

993

985

994

def make_tag(document, name, prop):

986

995

e = document.createElement("property")

987

996

e.setAttribute("name", name)

988

997

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

989

998

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

990

999

return e

1000

991

1001

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

992

1002

# Add property tags

993

1003

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

1005

1015

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

1006

1016

and prop._dbus_interface

1007

1017

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

1008

annots.update(getattr

1009

(prop,

1010

"_dbus_annotations",

1011

{}))

1012

for name, value in annots.iteritems():

1018

annots.update(getattr(

1019

prop, "_dbus_annotations", {}))

1020

for name, value in annots.items():

1013

1021

ann_tag = document.createElement(

1014

1022

"annotation")

1015

1023

ann_tag.setAttribute("name", name)

1018

1026

# Add interface annotation tags

1019

1027

for annotation, value in dict(

1020

1028

itertools.chain.from_iterable(

1021

annotations().iteritems()

1022

for name, annotations in

1023

self._get_all_dbus_things("interface")

1029

annotations().items()

1030

for name, annotations

1031

in self._get_all_dbus_things("interface")

1024

1032

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

1025

)).iteritems():

1033

)).items():

1026

1034

ann_tag = document.createElement("annotation")

1027

1035

ann_tag.setAttribute("name", annotation)

1028

1036

ann_tag.setAttribute("value", value)

1055

1063

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

1056

1064

if dt is None:

1057

1065

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

1058

return dbus.String(dt.isoformat(),

1059

variant_level=variant_level)

1066

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

1060

1067

1061

1068

1062

1069

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1082

1089

(from DBusObjectWithProperties) and interfaces (from the

1083

1090

dbus_interface_annotations decorator).

1084

1091

"""

1092

1085

1093

def wrapper(cls):

1086

1094

for orig_interface_name, alt_interface_name in (

1087

alt_interface_names.iteritems()):

1095

alt_interface_names.items()):

1088

1096

attr = {}

1089

1097

interface_names = set()

1090

1098

# Go though all attributes of the class

1092

1100

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

1093

1101

# with the wrong interface name

1094

1102

if (not hasattr(attribute, "_dbus_interface")

1095

or not attribute._dbus_interface

1096

.startswith(orig_interface_name)):

1103

or not attribute._dbus_interface.startswith(

1104

orig_interface_name)):

1097

1105

continue

1098

1106

# Create an alternate D-Bus interface name based on

1099

1107

# the current name

1100

alt_interface = (attribute._dbus_interface

1101

.replace(orig_interface_name,

1102

alt_interface_name))

1108

alt_interface = attribute._dbus_interface.replace(

1109

orig_interface_name, alt_interface_name)

1103

1110

interface_names.add(alt_interface)

1104

1111

# Is this a D-Bus signal?

1105

1112

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

1106

1113

# Extract the original non-method undecorated

1107

1114

# function by black magic

1108

1115

nonmethod_func = (dict(

1109

zip(attribute.func_code.co_freevars,

1110

attribute.__closure__))["func"]

1111

.cell_contents)

1116

zip(attribute.func_code.co_freevars,

1117

attribute.__closure__))

1118

["func"].cell_contents)

1112

1119

# Create a new, but exactly alike, function

1113

1120

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

1114

1121

# with the alternate D-Bus interface name

1115

new_function = (dbus.service.signal

1116

(alt_interface,

1117

attribute._dbus_signature)

1122

new_function = (dbus.service.signal(

1123

alt_interface, attribute._dbus_signature)

1118

1124

(types.FunctionType(

1119

nonmethod_func.func_code,

1120

nonmethod_func.func_globals,

1121

nonmethod_func.func_name,

1122

nonmethod_func.func_defaults,

1123

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)))

1124

1130

# Copy annotations, if any

1125

1131

try:

1126

new_function._dbus_annotations = (

1127

dict(attribute._dbus_annotations))

1132

new_function._dbus_annotations = dict(

1133

attribute._dbus_annotations)

1128

1134

except AttributeError:

1129

1135

pass

1130

1136

# Define a creator of a function to call both the

1135

1141

"""This function is a scope container to pass

1136

1142

func1 and func2 to the "call_both" function

1137

1143

outside of its arguments"""

1144

1138

1145

def call_both(*args, **kwargs):

1139

1146

"""This function will emit two D-Bus

1140

1147

signals by calling func1 and func2"""

1141

1148

func1(*args, **kwargs)

1142

1149

func2(*args, **kwargs)

1150

1143

1151

return call_both

1144

1152

# Create the "call_both" function and add it to

1145

1153

# the class

1150

1158

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

1151

1159

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

1152

1160

# to the class.

1153

attr[attrname] = (dbus.service.method

1154

(alt_interface,

1155

attribute._dbus_in_signature,

1156

attribute._dbus_out_signature)

1157

(types.FunctionType

1158

(attribute.func_code,

1159

attribute.func_globals,

1160

attribute.func_name,

1161

attribute.func_defaults,

1162

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)))

1163

1171

# Copy annotations, if any

1164

1172

try:

1165

attr[attrname]._dbus_annotations = (

1166

dict(attribute._dbus_annotations))

1173

attr[attrname]._dbus_annotations = dict(

1174

attribute._dbus_annotations)

1167

1175

except AttributeError:

1168

1176

pass

1169

1177

# Is this a D-Bus property?

1172

1180

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

1173

1181

# property with the alternate D-Bus interface

1174

1182

# name. Add it to the class.

1175

attr[attrname] = (dbus_service_property

1176

(alt_interface,

1177

attribute._dbus_signature,

1178

attribute._dbus_access,

1179

attribute

1180

._dbus_get_args_options

1181

["byte_arrays"])

1182

(types.FunctionType

1183

(attribute.func_code,

1184

attribute.func_globals,

1185

attribute.func_name,

1186

attribute.func_defaults,

1187

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)))

1188

1194

# Copy annotations, if any

1189

1195

try:

1190

attr[attrname]._dbus_annotations = (

1191

dict(attribute._dbus_annotations))

1196

attr[attrname]._dbus_annotations = dict(

1197

attribute._dbus_annotations)

1192

1198

except AttributeError:

1193

1199

pass

1194

1200

# Is this a D-Bus interface?

1197

1203

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

1198

1204

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

1199

1205

# to the class.

1200

attr[attrname] = (dbus_interface_annotations

1201

(alt_interface)

1202

(types.FunctionType

1203

(attribute.func_code,

1204

attribute.func_globals,

1205

attribute.func_name,

1206

attribute.func_defaults,

1207

attribute.func_closure)))

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)))

1208

1213

if deprecate:

1209

1214

# Deprecate all alternate interfaces

1210

iname="_AlternateDBusNames_interface_annotation{0}"

1215

iname="_AlternateDBusNames_interface_annotation{}"

1211

1216

for interface_name in interface_names:

1217

1212

1218

@dbus_interface_annotations(interface_name)

1213

1219

def func(self):

1214

1220

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

1215

"true" }

1221

"true" }

1216

1222

# Find an unused name

1217

1223

for aname in (iname.format(i)

1218

1224

for i in itertools.count()):

1222

1228

if interface_names:

1223

1229

# Replace the class with a new subclass of it with

1224

1230

# methods, signals, etc. as created above.

1225

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

1226

(cls,), attr)

1231

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

1232

(cls, ), attr)

1227

1233

return cls

1234

1228

1235

return wrapper

1229

1236

1230

1237

1231

1238

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

1232

"se.bsnet.fukt.Mandos"})

1239

"se.bsnet.fukt.Mandos"})

1233

1240

class ClientDBus(Client, DBusObjectWithProperties):

1234

1241

"""A Client class using D-Bus

1235

1242

1239

1246

"""

1240

1247

1241

1248

runtime_expansions = (Client.runtime_expansions

1242

+ ("dbus_object_path",))

1249

+ ("dbus_object_path", ))

1250

1251

_interface = "se.recompile.Mandos.Client"

1243

1252

1244

1253

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

1245

1254

1248

1257

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

1249

1258

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

1250

1259

# the D-Bus

1251

client_object_name = unicode(self.name).translate(

1260

client_object_name = str(self.name).translate(

1252

1261

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

1253

1262

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

1254

self.dbus_object_path = (dbus.ObjectPath

1255

("/clients/" + client_object_name))

1263

self.dbus_object_path = dbus.ObjectPath(

1264

"/clients/" + client_object_name)

1256

1265

DBusObjectWithProperties.__init__(self, self.bus,

1257

1266

self.dbus_object_path)

1258

1267

1259

def notifychangeproperty(transform_func,

1260

dbus_name, type_func=lambda x: x,

1261

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):

1262

1273

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

1263

1274

its changes to DBus.

1264

1275

1269

1280

to the D-Bus. Default: no transform

1270

1281

variant_level: D-Bus variant level. Default: 1

1271

1282

"""

1272

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

1283

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

1284

1273

1285

def setter(self, value):

1274

1286

if hasattr(self, "dbus_object_path"):

1275

1287

if (not hasattr(self, attrname) or

1276

1288

type_func(getattr(self, attrname, None))

1277

1289

!= type_func(value)):

1278

dbus_value = transform_func(type_func(value),

1279

variant_level

1280

=variant_level)

1281

self.PropertyChanged(dbus.String(dbus_name),

1282

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())

1283

1305

setattr(self, attrname, value)

1284

1306

1285

1307

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

1291

1313

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

1292

1314

last_enabled = notifychangeproperty(datetime_to_dbus,

1293

1315

"LastEnabled")

1294

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

1295

type_func = lambda checker:

1296

checker is not None)

1316

checker = notifychangeproperty(

1317

dbus.Boolean, "CheckerRunning",

1318

type_func = lambda checker: checker is not None)

1297

1319

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1298

1320

"LastCheckedOK")

1299

1321

last_checker_status = notifychangeproperty(dbus.Int16,

1302

1324

datetime_to_dbus, "LastApprovalRequest")

1303

1325

approved_by_default = notifychangeproperty(dbus.Boolean,

1304

1326

"ApprovedByDefault")

1305

approval_delay = notifychangeproperty(dbus.UInt64,

1306

"ApprovalDelay",

1307

type_func =

1308

timedelta_to_milliseconds)

1327

approval_delay = notifychangeproperty(

1328

dbus.UInt64, "ApprovalDelay",

1329

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

1309

1330

approval_duration = notifychangeproperty(

1310

1331

dbus.UInt64, "ApprovalDuration",

1311

type_func = timedelta_to_milliseconds)

1332

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

1312

1333

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

1313

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

1314

type_func =

1315

timedelta_to_milliseconds)

1334

timeout = notifychangeproperty(

1335

dbus.UInt64, "Timeout",

1336

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

1316

1337

extended_timeout = notifychangeproperty(

1317

1338

dbus.UInt64, "ExtendedTimeout",

1318

type_func = timedelta_to_milliseconds)

1319

interval = notifychangeproperty(dbus.UInt64,

1320

"Interval",

1321

type_func =

1322

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)

1323

1343

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

1344

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

1345

invalidate_only=True)

1324

1346

1325

1347

del notifychangeproperty

1326

1348

1368

1390

1369

1391

def approve(self, value=True):

1370

1392

self.approved = value

1371

gobject.timeout_add(timedelta_to_milliseconds

1372

(self.approval_duration),

1373

self._reset_approved)

1393

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

1394

* 1000), self._reset_approved)

1374

1395

self.send_changedstate()

1375

1396

1376

1397

## D-Bus methods, signals & properties

1377

_interface = "se.recompile.Mandos.Client"

1378

1398

1379

1399

## Interfaces

1380

1400

1381

@dbus_interface_annotations(_interface)

1382

def _foo(self):

1383

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

1384

"false"}

1385

1386

1401

## Signals

1387

1402

1388

1403

# CheckerCompleted - signal

1398

1413

pass

1399

1414

1400

1415

# PropertyChanged - signal

1416

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

1401

1417

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

1402

1418

def PropertyChanged(self, property, value):

1403

1419

"D-Bus signal"

1467

1483

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

1468

1484

1469

1485

# ApprovedByDefault - property

1470

@dbus_service_property(_interface, signature="b",

1486

@dbus_service_property(_interface,

1487

signature="b",

1471

1488

access="readwrite")

1472

1489

def ApprovedByDefault_dbus_property(self, value=None):

1473

1490

if value is None: # get

1475

1492

self.approved_by_default = bool(value)

1476

1493

1477

1494

# ApprovalDelay - property

1478

@dbus_service_property(_interface, signature="t",

1495

@dbus_service_property(_interface,

1496

signature="t",

1479

1497

access="readwrite")

1480

1498

def ApprovalDelay_dbus_property(self, value=None):

1481

1499

if value is None: # get

1482

return dbus.UInt64(self.approval_delay_milliseconds())

1500

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

1501

* 1000)

1483

1502

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

1484

1503

1485

1504

# ApprovalDuration - property

1486

@dbus_service_property(_interface, signature="t",

1505

@dbus_service_property(_interface,

1506

signature="t",

1487

1507

access="readwrite")

1488

1508

def ApprovalDuration_dbus_property(self, value=None):

1489

1509

if value is None: # get

1490

return dbus.UInt64(timedelta_to_milliseconds(

1491

self.approval_duration))

1510

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

1511

* 1000)

1492

1512

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

1493

1513

1494

1514

# Name - property

1502

1522

return dbus.String(self.fingerprint)

1503

1523

1504

1524

# Host - property

1505

@dbus_service_property(_interface, signature="s",

1525

@dbus_service_property(_interface,

1526

signature="s",

1506

1527

access="readwrite")

1507

1528

def Host_dbus_property(self, value=None):

1508

1529

if value is None: # get

1509

1530

return dbus.String(self.host)

1510

self.host = unicode(value)

1531

self.host = str(value)

1511

1532

1512

1533

# Created - property

1513

1534

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

1520

1541

return datetime_to_dbus(self.last_enabled)

1521

1542

1522

1543

# Enabled - property

1523

@dbus_service_property(_interface, signature="b",

1544

@dbus_service_property(_interface,

1545

signature="b",

1524

1546

access="readwrite")

1525

1547

def Enabled_dbus_property(self, value=None):

1526

1548

if value is None: # get

1531

1553

self.disable()

1532

1554

1533

1555

# LastCheckedOK - property

1534

@dbus_service_property(_interface, signature="s",

1556

@dbus_service_property(_interface,

1557

signature="s",

1535

1558

access="readwrite")

1536

1559

def LastCheckedOK_dbus_property(self, value=None):

1537

1560

if value is not None:

1540

1563

return datetime_to_dbus(self.last_checked_ok)

1541

1564

1542

1565

# LastCheckerStatus - property

1543

@dbus_service_property(_interface, signature="n",

1544

access="read")

1566

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

1545

1567

def LastCheckerStatus_dbus_property(self):

1546

1568

return dbus.Int16(self.last_checker_status)

1547

1569

1556

1578

return datetime_to_dbus(self.last_approval_request)

1557

1579

1558

1580

# Timeout - property

1559

@dbus_service_property(_interface, signature="t",

1581

@dbus_service_property(_interface,

1582

signature="t",

1560

1583

access="readwrite")

1561

1584

def Timeout_dbus_property(self, value=None):

1562

1585

if value is None: # get

1563

return dbus.UInt64(self.timeout_milliseconds())

1586

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

1564

1587

old_timeout = self.timeout

1565

1588

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

1566

1589

# Reschedule disabling

1575

1598

is None):

1576

1599

return

1577

1600

gobject.source_remove(self.disable_initiator_tag)

1578

self.disable_initiator_tag = (

1579

gobject.timeout_add(

1580

timedelta_to_milliseconds(self.expires - now),

1581

self.disable))

1601

self.disable_initiator_tag = gobject.timeout_add(

1602

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

1603

self.disable)

1582

1604

1583

1605

# ExtendedTimeout - property

1584

@dbus_service_property(_interface, signature="t",

1606

@dbus_service_property(_interface,

1607

signature="t",

1585

1608

access="readwrite")

1586

1609

def ExtendedTimeout_dbus_property(self, value=None):

1587

1610

if value is None: # get

1588

return dbus.UInt64(self.extended_timeout_milliseconds())

1611

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

1612

* 1000)

1589

1613

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

1590

1614

1591

1615

# Interval - property

1592

@dbus_service_property(_interface, signature="t",

1616

@dbus_service_property(_interface,

1617

signature="t",

1593

1618

access="readwrite")

1594

1619

def Interval_dbus_property(self, value=None):

1595

1620

if value is None: # get

1596

return dbus.UInt64(self.interval_milliseconds())

1621

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

1597

1622

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

1598

1623

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

1599

1624

return

1600

1625

if self.enabled:

1601

1626

# Reschedule checker run

1602

1627

gobject.source_remove(self.checker_initiator_tag)

1603

self.checker_initiator_tag = (gobject.timeout_add

1604

(value, self.start_checker))

1605

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

1606

1631

1607

1632

# Checker - property

1608

@dbus_service_property(_interface, signature="s",

1633

@dbus_service_property(_interface,

1634

signature="s",

1609

1635

access="readwrite")

1610

1636

def Checker_dbus_property(self, value=None):

1611

1637

if value is None: # get

1612

1638

return dbus.String(self.checker_command)

1613

self.checker_command = unicode(value)

1639

self.checker_command = str(value)

1614

1640

1615

1641

# CheckerRunning - property

1616

@dbus_service_property(_interface, signature="b",

1642

@dbus_service_property(_interface,

1643

signature="b",

1617

1644

access="readwrite")

1618

1645

def CheckerRunning_dbus_property(self, value=None):

1619

1646

if value is None: # get

1629

1656

return self.dbus_object_path # is already a dbus.ObjectPath

1630

1657

1631

1658

# Secret = property

1632

@dbus_service_property(_interface, signature="ay",

1633

access="write", byte_arrays=True)

1659

@dbus_service_property(_interface,

1660

signature="ay",

1661

access="write",

1662

byte_arrays=True)

1634

1663

def Secret_dbus_property(self, value):

1635

self.secret = str(value)

1664

self.secret = bytes(value)

1636

1665

1637

1666

del _interface

1638

1667

1652

1681

if data[0] == 'data':

1653

1682

return data[1]

1654

1683

if data[0] == 'function':

1684

1655

1685

def func(*args, **kwargs):

1656

1686

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

1657

1687

return self._pipe.recv()[1]

1688

1658

1689

return func

1659

1690

1660

1691

def __setattr__(self, name, value):

1672

1703

def handle(self):

1673

1704

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

1674

1705

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

1675

unicode(self.client_address))

1706

str(self.client_address))

1676

1707

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

1677

1708

self.server.child_pipe.fileno())

1678

1709

1679

session = (gnutls.connection

1680

.ClientSession(self.request,

1681

gnutls.connection

1682

.X509Credentials()))

1710

session = gnutls.connection.ClientSession(

1711

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

1683

1712

1684

1713

# Note: gnutls.connection.X509Credentials is really a

1685

1714

# generic GnuTLS certificate credentials object so long as

1694

1723

priority = self.server.gnutls_priority

1695

1724

if priority is None:

1696

1725

priority = "NORMAL"

1697

(gnutls.library.functions

1698

.gnutls_priority_set_direct(session._c_object,

1699

priority, None))

1726

gnutls.library.functions.gnutls_priority_set_direct(

1727

session._c_object, priority, None)

1700

1728

1701

1729

# Start communication using the Mandos protocol

1702

1730

# Get protocol number

1722

1750

approval_required = False

1723

1751

try:

1724

1752

try:

1725

fpr = self.fingerprint(self.peer_certificate

1726

(session))

1753

fpr = self.fingerprint(

1754

self.peer_certificate(session))

1727

1755

except (TypeError,

1728

1756

gnutls.errors.GNUTLSError) as error:

1729

1757

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

1744

1772

while True:

1745

1773

if not client.enabled:

1746

1774

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

1747

client.name)

1775

client.name)

1748

1776

if self.server.use_dbus:

1749

1777

# Emit D-Bus signal

1750

1778

client.Rejected("Disabled")

1759

1787

if self.server.use_dbus:

1760

1788

# Emit D-Bus signal

1761

1789

client.NeedApproval(

1762

client.approval_delay_milliseconds(),

1763

client.approved_by_default)

1790

client.approval_delay.total_seconds()

1791

* 1000, client.approved_by_default)

1764

1792

else:

1765

1793

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

1766

1794

client.name)

1772

1800

#wait until timeout or approved

1773

1801

time = datetime.datetime.now()

1774

1802

client.changedstate.acquire()

1775

client.changedstate.wait(

1776

float(timedelta_to_milliseconds(delay)

1777

/ 1000))

1803

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

1778

1804

client.changedstate.release()

1779

1805

time2 = datetime.datetime.now()

1780

1806

if (time2 - time) >= delay:

1799

1825

logger.warning("gnutls send failed",

1800

1826

exc_info=error)

1801

1827

return

1802

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

1803

sent, len(client.secret)

1804

- (sent_size + sent))

1828

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

1829

len(client.secret) - (sent_size

1830

+ sent))

1805

1831

sent_size += sent

1806

1832

1807

1833

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

1824

1850

def peer_certificate(session):

1825

1851

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

1826

1852

# If not an OpenPGP certificate...

1827

if (gnutls.library.functions

1828

.gnutls_certificate_type_get(session._c_object)

1853

if (gnutls.library.functions.gnutls_certificate_type_get(

1854

session._c_object)

1829

1855

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1830

1856

# ...do the normal thing

1831

1857

return session.peer_certificate

1845

1871

def fingerprint(openpgp):

1846

1872

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

1847

1873

# New GnuTLS "datum" with the OpenPGP public key

1848

datum = (gnutls.library.types

1849

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

1850

ctypes.POINTER

1851

(ctypes.c_ubyte)),

1852

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)))

1853

1878

# New empty GnuTLS certificate

1854

1879

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1855

(gnutls.library.functions

1856

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

1880

gnutls.library.functions.gnutls_openpgp_crt_init(

1881

ctypes.byref(crt))

1857

1882

# Import the OpenPGP public key into the certificate

1858

(gnutls.library.functions

1859

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

1860

gnutls.library.constants

1861

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

1862

1886

# Verify the self signature in the key

1863

1887

crtverify = ctypes.c_uint()

1864

(gnutls.library.functions

1865

.gnutls_openpgp_crt_verify_self(crt, 0,

1866

ctypes.byref(crtverify)))

1888

gnutls.library.functions.gnutls_openpgp_crt_verify_self(

1889

crt, 0, ctypes.byref(crtverify))

1867

1890

if crtverify.value != 0:

1868

1891

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1869

raise (gnutls.errors.CertificateSecurityError

1870

("Verify failed"))

1892

raise gnutls.errors.CertificateSecurityError(

1893

"Verify failed")

1871

1894

# New buffer for the fingerprint

1872

1895

buf = ctypes.create_string_buffer(20)

1873

1896

buf_len = ctypes.c_size_t()

1874

1897

# Get the fingerprint from the certificate into the buffer

1875

(gnutls.library.functions

1876

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

1877

ctypes.byref(buf_len)))

1898

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(

1899

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

1878

1900

# Deinit the certificate

1879

1901

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1880

1902

# Convert the buffer to a Python bytestring

1886

1908

1887

1909

class MultiprocessingMixIn(object):

1888

1910

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

1911

1889

1912

def sub_process_main(self, request, address):

1890

1913

try:

1891

1914

self.finish_request(request, address)

1903

1926

1904

1927

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1905

1928

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

1929

1906

1930

def process_request(self, request, client_address):

1907

1931

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

1908

1932

1929

1953

interface: None or a network interface name (string)

1930

1954

use_ipv6: Boolean; to use IPv6 or not

1931

1955

"""

1956

1932

1957

def __init__(self, server_address, RequestHandlerClass,

1933

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

1958

interface=None,

1959

use_ipv6=True,

1960

socketfd=None):

1934

1961

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

1935

1962

creating a new one with socket.socket().

1936

1963

"""

1977

2004

self.interface)

1978

2005

else:

1979

2006

try:

1980

self.socket.setsockopt(socket.SOL_SOCKET,

1981

SO_BINDTODEVICE,

1982

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

2007

self.socket.setsockopt(

2008

socket.SOL_SOCKET, SO_BINDTODEVICE,

2009

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

1983

2010

except socket.error as error:

1984

2011

if error.errno == errno.EPERM:

1985

2012

logger.error("No permission to bind to"

2003

2030

self.server_address = (any_address,

2004

2031

self.server_address[1])

2005

2032

elif not self.server_address[1]:

2006

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

2007

0)

2033

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

2008

2034

# if self.interface:

2009

2035

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

2010

2036

# 0, # port

2024

2050

2025

2051

Assumes a gobject.MainLoop event loop.

2026

2052

"""

2053

2027

2054

def __init__(self, server_address, RequestHandlerClass,

2028

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

2029

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):

2030

2061

self.enabled = False

2031

2062

self.clients = clients

2032

2063

if self.clients is None:

2038

2069

interface = interface,

2039

2070

use_ipv6 = use_ipv6,

2040

2071

socketfd = socketfd)

2072

2041

2073

def server_activate(self):

2042

2074

if self.enabled:

2043

2075

return socketserver.TCPServer.server_activate(self)

2047

2079

2048

2080

def add_pipe(self, parent_pipe, proc):

2049

2081

# Call "handle_ipc" for both data and EOF events

2050

gobject.io_add_watch(parent_pipe.fileno(),

2051

gobject.IO_IN | gobject.IO_HUP,

2052

functools.partial(self.handle_ipc,

2053

parent_pipe =

2054

parent_pipe,

2055

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))

2056

2088

2057

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

2058

proc = None, client_object=None):

2089

def handle_ipc(self, source, condition,

2090

parent_pipe=None,

2091

proc = None,

2092

client_object=None):

2059

2093

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

2060

2094

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

2061

2095

# Wait for other process to exit

2084

2118

parent_pipe.send(False)

2085

2119

return False

2086

2120

2087

gobject.io_add_watch(parent_pipe.fileno(),

2088

gobject.IO_IN | gobject.IO_HUP,

2089

functools.partial(self.handle_ipc,

2090

parent_pipe =

2091

parent_pipe,

2092

proc = proc,

2093

client_object =

2094

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))

2095

2128

parent_pipe.send(True)

2096

2129

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

2097

2130

# same fileno

2103

2136

2104

2137

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

2105

2138

funcname)(*args,

2106

**kwargs)))

2139

**kwargs)))

2107

2140

2108

2141

if command == 'getattr':

2109

2142

attrname = request[1]

2110

2143

if callable(client_object.__getattribute__(attrname)):

2111

parent_pipe.send(('function',))

2144

parent_pipe.send(('function', ))

2112

2145

else:

2113

parent_pipe.send(('data', client_object

2114

.__getattribute__(attrname)))

2146

parent_pipe.send((

2147

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

2115

2148

2116

2149

if command == 'setattr':

2117

2150

attrname = request[1]

2157

2190

# None

2158

2191

"followers")) # Tokens valid after

2159

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

2160

2198

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

2161

2199

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

2162

2200

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

2163

2201

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

2164

2202

datetime.timedelta(seconds=1),

2165

frozenset((token_end,)))

2203

frozenset((token_end, )))

2166

2204

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

2167

2205

datetime.timedelta(minutes=1),

2168

2206

frozenset((token_second, token_end)))

2184

2222

frozenset((token_month, token_end)))

2185

2223

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

2186

2224

datetime.timedelta(weeks=1),

2187

frozenset((token_end,)))

2225

frozenset((token_end, )))

2188

2226

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

2189

2227

frozenset((token_year, token_month,

2190

2228

token_day, token_time,

2191

token_week))),

2229

token_week)))

2192

2230

# Define starting values

2193

2231

value = datetime.timedelta() # Value so far

2194

2232

found_token = None

2195

followers = frozenset(token_duration,) # Following valid tokens

2233

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

2196

2234

s = duration # String left to parse

2197

2235

# Loop until end token is found

2198

2236

while found_token is not token_end:

2245

2283

timevalue = datetime.timedelta(0)

2246

2284

for s in interval.split():

2247

2285

try:

2248

suffix = unicode(s[-1])

2286

suffix = s[-1]

2249

2287

value = int(s[:-1])

2250

2288

if suffix == "d":

2251

2289

delta = datetime.timedelta(value)

2258

2296

elif suffix == "w":

2259

2297

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

2260

2298

else:

2261

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

2262

.format(suffix))

2299

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

2263

2300

except IndexError as e:

2264

2301

raise ValueError(*(e.args))

2265

2302

timevalue += delta

2282

2319

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

2283

2320

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

2284

2321

raise OSError(errno.ENODEV,

2285

"{0} not a character device"

2322

"{} not a character device"

2286

2323

.format(os.devnull))

2287

2324

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

2288

2325

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

2298

2335

2299

2336

parser = argparse.ArgumentParser()

2300

2337

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

2301

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

2338

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

2302

2339

help="show version number and exit")

2303

2340

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

2304

2341

help="Bind to interface IF")

2354

2391

"port": "",

2355

2392

"debug": "False",

2356

2393

"priority":

2357

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

2394

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

2395

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

2358

2396

"servicename": "Mandos",

2359

2397

"use_dbus": "True",

2360

2398

"use_ipv6": "True",

2364

2402

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

2365

2403

"foreground": "False",

2366

2404

"zeroconf": "True",

2367

}

2405

}

2368

2406

2369

2407

# Parse config file for server-global settings

2370

2408

server_config = configparser.SafeConfigParser(server_defaults)

2371

2409

del server_defaults

2372

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

2373

"mandos.conf"))

2410

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

2374

2411

# Convert the SafeConfigParser object to a dict

2375

2412

server_settings = server_config.defaults()

2376

2413

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

2394

2431

# Override the settings from the config file with command line

2395

2432

# options, if set.

2396

2433

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

2397

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

2398

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

2399

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

2434

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

2435

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

2436

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

2400

2437

value = getattr(options, option)

2401

2438

if value is not None:

2402

2439

server_settings[option] = value

2403

2440

del options

2404

2441

# Force all strings to be unicode

2405

2442

for option in server_settings.keys():

2406

if type(server_settings[option]) is str:

2407

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

2408

2446

# Force all boolean options to be boolean

2409

2447

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

2410

2448

"foreground", "zeroconf"):

2416

2454

2417

2455

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

2418

2456

2419

if (not server_settings["zeroconf"] and

2420

not (server_settings["port"]

2421

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

2422

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

2423

" Zeroconf")

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

2424

2461

2425

2462

# For convenience

2426

2463

debug = server_settings["debug"]

2442

2479

initlogger(debug, level)

2443

2480

2444

2481

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

2445

syslogger.setFormatter(logging.Formatter

2446

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

2447

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

2448

.format(server_settings

2449

["servicename"])))

2482

syslogger.setFormatter(

2483

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

2484

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

2485

server_settings["servicename"])))

2450

2486

2451

2487

# Parse config file with clients

2452

2488

client_config = configparser.SafeConfigParser(Client

2460

2496

socketfd = None

2461

2497

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

2462

2498

socketfd = server_settings["socket"]

2463

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

2464

server_settings["port"]),

2465

ClientHandler,

2466

interface=(server_settings["interface"]

2467

or None),

2468

use_ipv6=use_ipv6,

2469

gnutls_priority=

2470

server_settings["priority"],

2471

use_dbus=use_dbus,

2472

socketfd=socketfd)

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)

2473

2507

if not foreground:

2474

2508

pidfilename = "/run/mandos.pid"

2475

2509

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

2509

2543

def debug_gnutls(level, string):

2510

2544

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

2511

2545

2512

(gnutls.library.functions

2513

.gnutls_global_set_log_function(debug_gnutls))

2546

gnutls.library.functions.gnutls_global_set_log_function(

2547

debug_gnutls)

2514

2548

2515

2549

# Redirect stdin so all checkers get /dev/null

2516

2550

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

2536

2570

if use_dbus:

2537

2571

try:

2538

2572

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

2539

bus, do_not_queue=True)

2540

old_bus_name = (dbus.service.BusName

2541

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

2542

do_not_queue=True))

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)

2543

2578

except dbus.exceptions.NameExistsException as e:

2544

2579

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

2545

2580

use_dbus = False

2547

2582

tcp_server.use_dbus = False

2548

2583

if zeroconf:

2549

2584

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2550

service = AvahiServiceToSyslog(name =

2551

server_settings["servicename"],

2552

servicetype = "_mandos._tcp",

2553

protocol = protocol, bus = bus)

2585

service = AvahiServiceToSyslog(

2586

name = server_settings["servicename"],

2587

servicetype = "_mandos._tcp",

2588

protocol = protocol,

2589

bus = bus)

2554

2590

if server_settings["interface"]:

2555

service.interface = (if_nametoindex

2556

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

2591

service.interface = if_nametoindex(

2592

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

2557

2593

2558

2594

global multiprocessing_manager

2559

2595

multiprocessing_manager = multiprocessing.Manager()

2578

2614

if server_settings["restore"]:

2579

2615

try:

2580

2616

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

2581

clients_data, old_client_settings = (pickle.load

2582

(stored_state))

2617

clients_data, old_client_settings = pickle.load(

2618

stored_state)

2583

2619

os.remove(stored_state_path)

2584

2620

except IOError as e:

2585

2621

if e.errno == errno.ENOENT:

2586

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

2587

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

2622

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

2623

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

2588

2624

else:

2589

2625

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

2590

2626

exc_info=e)

2591

2627

raise

2592

2628

except EOFError as e:

2593

2629

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

2594

"EOFError:", exc_info=e)

2630

"EOFError:",

2631

exc_info=e)

2595

2632

2596

2633

with PGPEngine() as pgp:

2597

for client_name, client in clients_data.iteritems():

2634

for client_name, client in clients_data.items():

2598

2635

# Skip removed clients

2599

2636

if client_name not in client_settings:

2600

2637

continue

2609

2646

# For each value in new config, check if it

2610

2647

# differs from the old config value (Except for

2611

2648

# the "secret" attribute)

2612

if (name != "secret" and

2613

value != old_client_settings[client_name]

2614

[name]):

2649

if (name != "secret"

2650

and (value !=

2651

old_client_settings[client_name][name])):

2615

2652

client[name] = value

2616

2653

except KeyError:

2617

2654

pass

2625

2662

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

2626

2663

if not client["last_checked_ok"]:

2627

2664

logger.warning(

2628

"disabling client {0} - Client never "

2629

"performed a successful checker"

2630

.format(client_name))

2665

"disabling client {} - Client never "

2666

"performed a successful checker".format(

2667

client_name))

2631

2668

client["enabled"] = False

2632

2669

elif client["last_checker_status"] != 0:

2633

2670

logger.warning(

2634

"disabling client {0} - Client "

2635

"last checker failed with error code {1}"

2636

.format(client_name,

2637

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"]))

2638

2676

client["enabled"] = False

2639

2677

else:

2640

client["expires"] = (datetime.datetime

2641

.utcnow()

2642

+ client["timeout"])

2678

client["expires"] = (

2679

datetime.datetime.utcnow()

2680

+ client["timeout"])

2643

2681

logger.debug("Last checker succeeded,"

2644

" keeping {0} enabled"

2645

.format(client_name))

2682

" keeping {} enabled".format(

2683

client_name))

2646

2684

try:

2647

client["secret"] = (

2648

pgp.decrypt(client["encrypted_secret"],

2649

client_settings[client_name]

2650

["secret"]))

2685

client["secret"] = pgp.decrypt(

2686

client["encrypted_secret"],

2687

client_settings[client_name]["secret"])

2651

2688

except PGPError:

2652

2689

# If decryption fails, we use secret from new settings

2653

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

2654

.format(client_name))

2655

client["secret"] = (

2656

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"])

2657

2694

2658

2695

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

2659

2696

for client_name in (set(old_client_settings)

2664

2701

clients_data[client_name] = client_settings[client_name]

2665

2702

2666

2703

# Create all client objects

2667

for client_name, client in clients_data.iteritems():

2704

for client_name, client in clients_data.items():

2668

2705

tcp_server.clients[client_name] = client_class(

2669

name = client_name, settings = client,

2706

name = client_name,

2707

settings = client,

2670

2708

server_settings = server_settings)

2671

2709

2672

2710

if not tcp_server.clients:

2677

2715

try:

2678

2716

with pidfile:

2679

2717

pid = os.getpid()

2680

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

2718

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

2681

2719

except IOError:

2682

2720

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

2683

2721

pidfilename, pid)

2688

2726

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

2689

2727

2690

2728

if use_dbus:

2691

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

2692

"se.bsnet.fukt.Mandos"})

2729

2730

@alternate_dbus_interfaces(

2731

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

2693

2732

class MandosDBusService(DBusObjectWithProperties):

2694

2733

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

2734

2695

2735

def __init__(self):

2696

2736

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

2737

2697

2738

_interface = "se.recompile.Mandos"

2698

2739

2699

2740

@dbus_interface_annotations(_interface)

2700

2741

def _foo(self):

2701

return { "org.freedesktop.DBus.Property"

2702

".EmitsChangedSignal":

2703

"false"}

2742

return {

2743

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

2744

"false" }

2704

2745

2705

2746

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

2706

2747

def ClientAdded(self, objpath):

2720

2761

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

2721

2762

def GetAllClients(self):

2722

2763

"D-Bus method"

2723

return dbus.Array(c.dbus_object_path

2724

for c in

2764

return dbus.Array(c.dbus_object_path for c in

2725

2765

tcp_server.clients.itervalues())

2726

2766

2727

2767

@dbus.service.method(_interface,

2729

2769

def GetAllClientsWithProperties(self):

2730

2770

"D-Bus method"

2731

2771

return dbus.Dictionary(

2732

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

2733

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

2772

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

2773

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

2734

2774

signature="oa{sv}")

2735

2775

2736

2776

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

2774

2814

2775

2815

# A list of attributes that can not be pickled

2776

2816

# + secret.

2777

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

2778

"checker", "server_settings"))

2779

for name, typ in (inspect.getmembers

2780

(dbus.service.Object)):

2817

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

2818

"checker", "server_settings" }

2819

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

2820

.Object):

2781

2821

exclude.add(name)

2782

2822

2783

2823

client_dict["encrypted_secret"] = (client

2790

2830

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

2791

2831

2792

2832

try:

2793

with (tempfile.NamedTemporaryFile

2794

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

2795

dir=os.path.dirname(stored_state_path),

2796

delete=False)) as stored_state:

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:

2797

2839

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

2798

tempname=stored_state.name

2840

tempname = stored_state.name

2799

2841

os.rename(tempname, stored_state_path)

2800

2842

except (IOError, OSError) as e:

2801

2843

if not debug:

2804

2846

except NameError:

2805

2847

pass

2806

2848

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

2807

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

2849

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

2808

2850

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

2809

2851

else:

2810

2852

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

2820

2862

client.disable(quiet=True)

2821

2863

if use_dbus:

2822

2864

# Emit D-Bus signal

2823

mandos_dbus_service.ClientRemoved(client

2824

.dbus_object_path,

2825

client.name)

2865

mandos_dbus_service.ClientRemoved(

2866

client.dbus_object_path, client.name)

2826

2867

client_settings.clear()

2827

2868

2828

2869

atexit.register(cleanup)

2881

2922

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

2882

2923

cleanup()

2883

2924

2925

2884

2926

if __name__ == '__main__':

2885

2927

main()