/mandos/trunk : revision 539

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

65

import types

66

import binascii

67

import tempfile

68

import itertools

69

68

70

69

import dbus

71

70

import dbus.service

86

85

except ImportError:

87

86

SO_BINDTODEVICE = None

88

87

89

version = "1.5.3"

88

version = "1.4.1"

90

89

stored_state_file = "clients.pickle"

91

90

92

91

logger = logging.getLogger()

143

142

self.gnupg.options.meta_interactive = False

144

143

self.gnupg.options.homedir = self.tempdir

145

144

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

146

'--quiet',

147

'--no-use-agent'])

145

'--quiet'])

148

146

149

147

def __enter__(self):

150

148

return self

176

174

177

175

def encrypt(self, data, password):

178

176

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

179

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

177

with open(os.devnull) as devnull:

180

178

try:

181

179

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

182

180

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

193

191

194

192

def decrypt(self, data, password):

195

193

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

196

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

194

with open(os.devnull) as devnull:

197

195

try:

198

196

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

199

197

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

200

198

attach_fhs={'stderr': devnull})

201

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

199

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

202

200

f.write(data)

203

201

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

204

202

decrypted_plaintext = f.read()

209

207

return decrypted_plaintext

210

208

211

209

210

212

211

class AvahiError(Exception):

213

212

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

214

213

self.value = value

243

242

server: D-Bus Server

244

243

bus: dbus.SystemBus()

245

244

"""

246

247

245

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

248

246

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

249

247

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

262

260

self.server = None

263

261

self.bus = bus

264

262

self.entry_group_state_changed_match = None

265

266

263

def rename(self):

267

264

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

268

265

if self.rename_count >= self.max_renames:

278

275

try:

279

276

self.add()

280

277

except dbus.exceptions.DBusException as error:

281

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

278

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

282

279

self.cleanup()

283

280

os._exit(1)

284

281

self.rename_count += 1

285

286

282

def remove(self):

287

283

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

288

284

if self.entry_group_state_changed_match is not None:

290

286

self.entry_group_state_changed_match = None

291

287

if self.group is not None:

292

288

self.group.Reset()

293

294

289

def add(self):

295

290

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

296

291

self.remove()

313

308

dbus.UInt16(self.port),

314

309

avahi.string_array_to_txt_array(self.TXT))

315

310

self.group.Commit()

316

317

311

def entry_group_state_changed(self, state, error):

318

312

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

319

313

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

326

320

elif state == avahi.ENTRY_GROUP_FAILURE:

327

321

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

328

322

unicode(error))

329

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

330

.format(error))

331

323

raise AvahiGroupError("State changed: %s"

324

% unicode(error))

332

325

def cleanup(self):

333

326

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

334

327

if self.group is not None:

339

332

pass

340

333

self.group = None

341

334

self.remove()

342

343

335

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

344

336

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

345

337

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

364

356

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

365

357

else:

366

358

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

367

368

359

def activate(self):

369

360

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

370

361

if self.server is None:

382

373

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

383

374

ret = AvahiService.rename(self)

384

375

syslogger.setFormatter(logging.Formatter

385

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

386

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

387

.format(self.name)))

376

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

377

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

378

% self.name))

388

379

return ret

389

380

390

381

def timedelta_to_milliseconds(td):

392

383

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

393

384

+ (td.seconds * 1000)

394

385

+ (td.microseconds // 1000))

395

386

396

387

class Client(object):

397

388

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

398

389

423

414

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

424

415

last_checker_status: integer between 0 and 255 reflecting exit

425

416

status of last checker. -1 reflects crashed

426

checker, -2 means no checker completed yet.

417

checker, or None.

427

418

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

428

419

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

429

420

D-Bus identifiers

430

421

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

431

422

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

432

423

until this client is disabled

433

extended_timeout: extra long timeout when secret has been sent

424

extended_timeout: extra long timeout when password has been sent

434

425

runtime_expansions: Allowed attributes for runtime expansion.

435

426

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

436

427

disabled, or None

465

456

466

457

def approval_delay_milliseconds(self):

467

458

return timedelta_to_milliseconds(self.approval_delay)

468

459

469

460

@staticmethod

470

461

def config_parser(config):

471

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

462

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

472

463

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

473

with exceptions for any special settings as defined above.

474

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

475

value given the same arguments.

476

"""

464

with exceptions for any special settings as defined above"""

477

465

settings = {}

478

466

for client_name in config.sections():

479

467

section = dict(config.items(client_name))

483

471

# Reformat values from string types to Python types

484

472

client["approved_by_default"] = config.getboolean(

485

473

client_name, "approved_by_default")

486

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

487

"enabled")

474

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

488

475

489

476

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

490

477

.replace(" ", ""))

496

483

"rb") as secfile:

497

484

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

498

485

else:

499

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

500

.format(section))

486

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

487

% section)

501

488

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

502

489

client["extended_timeout"] = string_to_delta(

503

490

section["extended_timeout"])

509

496

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

510

497

client["last_approval_request"] = None

511

498

client["last_checked_ok"] = None

512

client["last_checker_status"] = -2

513

499

client["last_checker_status"] = None

500

if client["enabled"]:

501

client["last_enabled"] = datetime.datetime.utcnow()

502

client["expires"] = (datetime.datetime.utcnow()

503

+ client["timeout"])

504

else:

505

client["last_enabled"] = None

506

client["expires"] = None

507

514

508

return settings

515

509

510

516

511

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

512

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

513

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

514

attribute."""

517

515

self.name = name

518

516

# adding all client settings

519

517

for setting, value in settings.iteritems():

520

518

setattr(self, setting, value)

521

519

522

if self.enabled:

523

if not hasattr(self, "last_enabled"):

524

self.last_enabled = datetime.datetime.utcnow()

525

if not hasattr(self, "expires"):

526

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

527

+ self.timeout)

528

else:

529

self.last_enabled = None

530

self.expires = None

531

532

520

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

533

521

# Uppercase and remove spaces from fingerprint for later

534

522

# comparison purposes with return value from the fingerprint()

535

523

# function

536

524

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

537

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

538

datetime.datetime.utcnow())

539

525

self.created = settings.get("created", datetime.datetime.utcnow())

526

540

527

# attributes specific for this server instance

541

528

self.checker = None

542

529

self.checker_initiator_tag = None

630

617

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

631

618

vars(self))

632

619

633

def checked_ok(self):

634

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

635

self.last_checked_ok = datetime.datetime.utcnow()

636

self.last_checker_status = 0

637

self.bump_timeout()

638

639

def bump_timeout(self, timeout=None):

640

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

620

def checked_ok(self, timeout=None):

621

"""Bump up the timeout for this client.

622

623

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

624

alive and well.

625

"""

641

626

if timeout is None:

642

627

timeout = self.timeout

628

self.last_checked_ok = datetime.datetime.utcnow()

643

629

if self.disable_initiator_tag is not None:

644

630

gobject.source_remove(self.disable_initiator_tag)

645

631

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

657

643

If a checker already exists, leave it running and do

658

644

nothing."""

659

645

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

660

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

661

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

662

# would inevitably timeout, since no checker would get a

663

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

646

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

647

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

648

# client would inevitably timeout, since no checker would get

649

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

664

650

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

665

651

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

666

652

# should be.

696

682

try:

697

683

command = self.checker_command % escaped_attrs

698

684

except TypeError as error:

699

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

700

self.checker_command, exc_info=error)

685

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

686

' %s', self.checker_command, error)

701

687

return True # Try again later

702

688

self.current_checker_command = command

703

689

try:

721

707

gobject.source_remove(self.checker_callback_tag)

722

708

self.checker_callback(pid, status, command)

723

709

except OSError as error:

724

logger.error("Failed to start subprocess",

725

exc_info=error)

710

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

711

error)

726

712

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

727

713

return True

728

714

735

721

return

736

722

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

737

723

try:

738

self.checker.terminate()

724

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

739

725

#time.sleep(0.5)

740

726

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

741

# self.checker.kill()

727

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

742

728

except OSError as error:

743

729

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

744

730

raise

761

747

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

762

748

if byte_arrays and signature != "ay":

763

749

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

764

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

750

" signature %r" % signature)

765

751

def decorator(func):

766

752

func._dbus_is_property = True

767

753

func._dbus_interface = dbus_interface

775

761

return decorator

776

762

777

763

778

def dbus_interface_annotations(dbus_interface):

779

"""Decorator for marking functions returning interface annotations

780

781

Usage:

782

783

@dbus_interface_annotations("org.example.Interface")

784

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

785

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

786

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

787

"false"}

788

"""

789

def decorator(func):

790

func._dbus_is_interface = True

791

func._dbus_interface = dbus_interface

792

func._dbus_name = dbus_interface

793

return func

794

return decorator

795

796

797

def dbus_annotations(annotations):

798

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

799

Usage:

800

801

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

802

access="r")

803

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

804

"org.freedesktop.DBus.Property."

805

"EmitsChangedSignal": "false"})

806

def Property_dbus_property(self):

807

return dbus.Boolean(False)

808

"""

809

def decorator(func):

810

func._dbus_annotations = annotations

811

return func

812

return decorator

813

814

815

764

class DBusPropertyException(dbus.exceptions.DBusException):

816

765

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

817

766

"""

840

789

"""

841

790

842

791

@staticmethod

843

def _is_dbus_thing(thing):

844

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

845

846

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

847

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

848

"""

849

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

850

False)

792

def _is_dbus_property(obj):

793

return getattr(obj, "_dbus_is_property", False)

851

794

852

def _get_all_dbus_things(self, thing):

795

def _get_all_dbus_properties(self):

853

796

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

854

797

"""

855

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

856

name),

857

athing.__get__(self))

798

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

858

799

for cls in self.__class__.__mro__

859

for name, athing in

860

inspect.getmembers(cls,

861

self._is_dbus_thing(thing)))

800

for name, prop in

801

inspect.getmembers(cls, self._is_dbus_property))

862

802

863

803

def _get_dbus_property(self, interface_name, property_name):

864

804

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

866

806

"""

867

807

for cls in self.__class__.__mro__:

868

808

for name, value in (inspect.getmembers

869

(cls,

870

self._is_dbus_thing("property"))):

809

(cls, self._is_dbus_property)):

871

810

if (value._dbus_name == property_name

872

811

and value._dbus_interface == interface_name):

873

812

return value.__get__(self)

902

841

# signatures other than "ay".

903

842

if prop._dbus_signature != "ay":

904

843

raise ValueError

905

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

906

for byte in value))

844

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

845

for byte in value))

907

846

prop(value)

908

847

909

848

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

915

854

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

916

855

"""

917

856

properties = {}

918

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

857

for name, prop in self._get_all_dbus_properties():

919

858

if (interface_name

920

859

and interface_name != prop._dbus_interface):

921

860

# Interface non-empty but did not match

936

875

path_keyword='object_path',

937

876

connection_keyword='connection')

938

877

def Introspect(self, object_path, connection):

939

"""Overloading of standard D-Bus method.

940

941

Inserts property tags and interface annotation tags.

878

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

942

879

"""

943

880

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

944

881

connection)

951

888

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

952

889

return e

953

890

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

954

# Add property tags

955

891

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

956

892

for name, prop

957

in self._get_all_dbus_things("property")

893

in self._get_all_dbus_properties()

958

894

if prop._dbus_interface

959

895

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

960

896

if_tag.appendChild(tag)

961

# Add annotation tags

962

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

963

for tag in if_tag.getElementsByTagName(typ):

964

annots = dict()

965

for name, prop in (self.

966

_get_all_dbus_things(typ)):

967

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

968

and prop._dbus_interface

969

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

970

annots.update(getattr

971

(prop,

972

"_dbus_annotations",

973

{}))

974

for name, value in annots.iteritems():

975

ann_tag = document.createElement(

976

"annotation")

977

ann_tag.setAttribute("name", name)

978

ann_tag.setAttribute("value", value)

979

tag.appendChild(ann_tag)

980

# Add interface annotation tags

981

for annotation, value in dict(

982

itertools.chain.from_iterable(

983

annotations().iteritems()

984

for name, annotations in

985

self._get_all_dbus_things("interface")

986

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

987

)).iteritems():

988

ann_tag = document.createElement("annotation")

989

ann_tag.setAttribute("name", annotation)

990

ann_tag.setAttribute("value", value)

991

if_tag.appendChild(ann_tag)

992

897

# Add the names to the return values for the

993

898

# "org.freedesktop.DBus.Properties" methods

994

899

if (if_tag.getAttribute("name")

1009

914

except (AttributeError, xml.dom.DOMException,

1010

915

xml.parsers.expat.ExpatError) as error:

1011

916

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

1012

exc_info=error)

917

error)

1013

918

return xmlstring

1014

919

1015

920

1021

926

variant_level=variant_level)

1022

927

1023

928

1024

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1025

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

1026

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

1027

interface names according to the "alt_interface_names" mapping.

1028

Usage:

1029

1030

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

1031

"net.example.AlternateInterface"})

1032

class SampleDBusObject(dbus.service.Object):

1033

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

1034

def SampleDBusMethod():

1035

pass

1036

1037

The above "SampleDBusMethod" on "SampleDBusObject" will be

1038

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

1039

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

1040

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

1041

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

1042

1043

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

1044

(from DBusObjectWithProperties) and interfaces (from the

1045

dbus_interface_annotations decorator).

929

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

930

.__metaclass__):

931

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

932

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

1046

933

"""

1047

def wrapper(cls):

1048

for orig_interface_name, alt_interface_name in (

1049

alt_interface_names.iteritems()):

1050

attr = {}

1051

interface_names = set()

1052

# Go though all attributes of the class

1053

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

934

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

935

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

936

# methods, signals, or properties in them

937

for base in (b for b in bases

938

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

939

# Go though all attributes of the base class

940

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

1054

941

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

1055

942

# with the wrong interface name

1056

943

if (not hasattr(attribute, "_dbus_interface")

1057

944

or not attribute._dbus_interface

1058

.startswith(orig_interface_name)):

945

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

1059

946

continue

1060

947

# Create an alternate D-Bus interface name based on

1061

948

# the current name

1062

949

alt_interface = (attribute._dbus_interface

1063

.replace(orig_interface_name,

1064

alt_interface_name))

1065

interface_names.add(alt_interface)

950

.replace("se.recompile.Mandos",

951

"se.bsnet.fukt.Mandos"))

1066

952

# Is this a D-Bus signal?

1067

953

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

1068

954

# Extract the original non-method function by

1083

969

nonmethod_func.func_name,

1084

970

nonmethod_func.func_defaults,

1085

971

nonmethod_func.func_closure)))

1086

# Copy annotations, if any

1087

try:

1088

new_function._dbus_annotations = (

1089

dict(attribute._dbus_annotations))

1090

except AttributeError:

1091

pass

1092

972

# Define a creator of a function to call both the

1093

# original and alternate functions, so both the

1094

# original and alternate signals gets sent when

1095

# the function is called

973

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

974

# signals gets sent when the function is called

1096

975

def fixscope(func1, func2):

1097

976

"""This function is a scope container to pass

1098

977

func1 and func2 to the "call_both" function

1105

984

return call_both

1106

985

# Create the "call_both" function and add it to

1107

986

# the class

1108

attr[attrname] = fixscope(attribute, new_function)

987

attr[attrname] = fixscope(attribute,

988

new_function)

1109

989

# Is this a D-Bus method?

1110

990

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

1111

991

# Create a new, but exactly alike, function

1122

1002

attribute.func_name,

1123

1003

attribute.func_defaults,

1124

1004

attribute.func_closure)))

1125

# Copy annotations, if any

1126

try:

1127

attr[attrname]._dbus_annotations = (

1128

dict(attribute._dbus_annotations))

1129

except AttributeError:

1130

pass

1131

1005

# Is this a D-Bus property?

1132

1006

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

1133

1007

# Create a new, but exactly alike, function

1147

1021

attribute.func_name,

1148

1022

attribute.func_defaults,

1149

1023

attribute.func_closure)))

1150

# Copy annotations, if any

1151

try:

1152

attr[attrname]._dbus_annotations = (

1153

dict(attribute._dbus_annotations))

1154

except AttributeError:

1155

pass

1156

# Is this a D-Bus interface?

1157

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

1158

# Create a new, but exactly alike, function

1159

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

1160

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

1161

# to the class.

1162

attr[attrname] = (dbus_interface_annotations

1163

(alt_interface)

1164

(types.FunctionType

1165

(attribute.func_code,

1166

attribute.func_globals,

1167

attribute.func_name,

1168

attribute.func_defaults,

1169

attribute.func_closure)))

1170

if deprecate:

1171

# Deprecate all alternate interfaces

1172

iname="_AlternateDBusNames_interface_annotation{0}"

1173

for interface_name in interface_names:

1174

@dbus_interface_annotations(interface_name)

1175

def func(self):

1176

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

1177

"true" }

1178

# Find an unused name

1179

for aname in (iname.format(i)

1180

for i in itertools.count()):

1181

if aname not in attr:

1182

attr[aname] = func

1183

break

1184

if interface_names:

1185

# Replace the class with a new subclass of it with

1186

# methods, signals, etc. as created above.

1187

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

1188

(cls,), attr)

1189

return cls

1190

return wrapper

1191

1192

1193

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

1194

"se.bsnet.fukt.Mandos"})

1024

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

1025

1026

1195

1027

class ClientDBus(Client, DBusObjectWithProperties):

1196

1028

"""A Client class using D-Bus

1197

1029

1208

1040

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

1209

1041

self.bus = bus

1210

1042

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

1043

self._approvals_pending = 0

1044

1045

self._approvals_pending = 0

1211

1046

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

1212

1047

# the D-Bus

1213

1048

client_object_name = unicode(self.name).translate(

1217

1052

("/clients/" + client_object_name))

1218

1053

DBusObjectWithProperties.__init__(self, self.bus,

1219

1054

self.dbus_object_path)

1220

1055

1221

1056

def notifychangeproperty(transform_func,

1222

1057

dbus_name, type_func=lambda x: x,

1223

1058

variant_level=1):

1246

1081

1247

1082

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

1248

1083

1084

1249

1085

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1250

1086

approvals_pending = notifychangeproperty(dbus.Boolean,

1251

1087

"ApprovalPending",

1258

1094

checker is not None)

1259

1095

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1260

1096

"LastCheckedOK")

1261

last_checker_status = notifychangeproperty(dbus.Int16,

1262

"LastCheckerStatus")

1263

1097

last_approval_request = notifychangeproperty(

1264

1098

datetime_to_dbus, "LastApprovalRequest")

1265

1099

approved_by_default = notifychangeproperty(dbus.Boolean,

1339

1173

(self.approval_duration),

1340

1174

self._reset_approved)

1341

1175

1176

1342

1177

## D-Bus methods, signals & properties

1343

1178

_interface = "se.recompile.Mandos.Client"

1344

1179

1345

## Interfaces

1346

1347

@dbus_interface_annotations(_interface)

1348

def _foo(self):

1349

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

1350

"false"}

1351

1352

1180

## Signals

1353

1181

1354

1182

# CheckerCompleted - signal

1390

1218

"D-Bus signal"

1391

1219

return self.need_approval()

1392

1220

1221

# NeRwequest - signal

1222

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

1223

def NewRequest(self, ip):

1224

"""D-Bus signal

1225

Is sent after a client request a password.

1226

"""

1227

pass

1228

1393

1229

## Methods

1394

1230

1395

1231

# Approve - method

1505

1341

return

1506

1342

return datetime_to_dbus(self.last_checked_ok)

1507

1343

1508

# LastCheckerStatus - property

1509

@dbus_service_property(_interface, signature="n",

1510

access="read")

1511

def LastCheckerStatus_dbus_property(self):

1512

return dbus.Int16(self.last_checker_status)

1513

1514

1344

# Expires - property

1515

1345

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

1516

1346

def Expires_dbus_property(self):

1528

1358

if value is None: # get

1529

1359

return dbus.UInt64(self.timeout_milliseconds())

1530

1360

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

1361

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

1362

return

1531

1363

# Reschedule timeout

1532

if self.enabled:

1533

now = datetime.datetime.utcnow()

1534

time_to_die = timedelta_to_milliseconds(

1535

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

1536

if time_to_die <= 0:

1537

# The timeout has passed

1538

self.disable()

1539

else:

1540

self.expires = (now +

1541

datetime.timedelta(milliseconds =

1542

time_to_die))

1543

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

1544

is None):

1545

return

1546

gobject.source_remove(self.disable_initiator_tag)

1547

self.disable_initiator_tag = (gobject.timeout_add

1548

(time_to_die,

1549

self.disable))

1364

gobject.source_remove(self.disable_initiator_tag)

1365

self.disable_initiator_tag = None

1366

self.expires = None

1367

time_to_die = timedelta_to_milliseconds((self

1368

.last_checked_ok

1369

+ self.timeout)

1370

- datetime.datetime

1371

.utcnow())

1372

if time_to_die <= 0:

1373

# The timeout has passed

1374

self.disable()

1375

else:

1376

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

1377

+ datetime.timedelta(milliseconds =

1378

time_to_die))

1379

self.disable_initiator_tag = (gobject.timeout_add

1380

(time_to_die, self.disable))

1550

1381

1551

1382

# ExtendedTimeout - property

1552

1383

@dbus_service_property(_interface, signature="t",

1631

1462

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

1632

1463

1633

1464

1465

class ClientDBusTransitional(ClientDBus):

1466

__metaclass__ = AlternateDBusNamesMetaclass

1467

1468

1634

1469

class ClientHandler(socketserver.BaseRequestHandler, object):

1635

1470

"""A class to handle client connections.

1636

1471

1704

1539

except KeyError:

1705

1540

return

1706

1541

1542

if self.server.use_dbus:

1543

# Emit D-Bus signal

1544

client.NewRequest(str(self.client_address))

1545

1707

1546

if client.approval_delay:

1708

1547

delay = client.approval_delay

1709

1548

client.approvals_pending += 1

1764

1603

try:

1765

1604

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

1766

1605

except gnutls.errors.GNUTLSError as error:

1767

logger.warning("gnutls send failed",

1768

exc_info=error)

1606

logger.warning("gnutls send failed")

1769

1607

return

1770

1608

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

1771

1609

sent, len(client.secret)

1774

1612

1775

1613

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

1776

1614

# bump the timeout using extended_timeout

1777

client.bump_timeout(client.extended_timeout)

1615

client.checked_ok(client.extended_timeout)

1778

1616

if self.server.use_dbus:

1779

1617

# Emit D-Bus signal

1780

1618

client.GotSecret()

1785

1623

try:

1786

1624

session.bye()

1787

1625

except gnutls.errors.GNUTLSError as error:

1788

logger.warning("GnuTLS bye failed",

1789

exc_info=error)

1626

logger.warning("GnuTLS bye failed")

1790

1627

1791

1628

@staticmethod

1792

1629

def peer_certificate(session):

1993

1830

1994

1831

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

1995

1832

proc = None, client_object=None):

1833

condition_names = {

1834

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

1835

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

1836

# blocking).

1837

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

1838

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

1839

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

1840

# broken, usually for pipes and

1841

# sockets).

1842

}

1843

conditions_string = ' | '.join(name

1844

for cond, name in

1845

condition_names.iteritems()

1846

if cond & condition)

1996

1847

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

1997

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

1848

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

1998

1849

# Wait for other process to exit

1999

1850

proc.join()

2000

1851

return False

2090

1941

elif suffix == "w":

2091

1942

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

2092

1943

else:

2093

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

2094

.format(suffix))

1944

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

2095

1945

except (ValueError, IndexError) as e:

2096

1946

raise ValueError(*(e.args))

2097

1947

timevalue += delta

2111

1961

sys.exit()

2112

1962

if not noclose:

2113

1963

# Close all standard open file descriptors

2114

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

1964

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

2115

1965

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

2116

1966

raise OSError(errno.ENODEV,

2117

"{0} not a character device"

2118

.format(os.devnull))

1967

"%s not a character device"

1968

% os.path.devnull)

2119

1969

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

2120

1970

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

2121

1971

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

2130

1980

2131

1981

parser = argparse.ArgumentParser()

2132

1982

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

2133

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

1983

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

2134

1984

help="show version number and exit")

2135

1985

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

2136

1986

help="Bind to interface IF")

2239

2089

2240

2090

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

2241

2091

syslogger.setFormatter(logging.Formatter

2242

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

2243

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

2244

.format(server_settings

2245

["servicename"])))

2092

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

2093

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

2094

% server_settings["servicename"]))

2246

2095

2247

2096

# Parse config file with clients

2248

client_config = configparser.SafeConfigParser(Client

2249

.client_defaults)

2097

client_config = configparser.SafeConfigParser(Client.client_defaults)

2250

2098

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

2251

2099

"clients.conf"))

2252

2100

2266

2114

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

2267

2115

try:

2268

2116

pidfile = open(pidfilename, "w")

2269

except IOError as e:

2270

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

2271

exc_info=e)

2117

except IOError:

2118

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

2272

2119

2273

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

2120

try:

2121

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

2122

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

2123

except KeyError:

2274

2124

try:

2275

uid = pwd.getpwnam(name).pw_uid

2276

gid = pwd.getpwnam(name).pw_gid

2277

break

2125

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

2126

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

2278

2127

except KeyError:

2279

continue

2280

else:

2281

uid = 65534

2282

gid = 65534

2128

try:

2129

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

2130

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

2131

except KeyError:

2132

uid = 65534

2133

gid = 65534

2283

2134

try:

2284

2135

os.setgid(gid)

2285

2136

os.setuid(uid)

2302

2153

.gnutls_global_set_log_function(debug_gnutls))

2303

2154

2304

2155

# Redirect stdin so all checkers get /dev/null

2305

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

2156

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

2306

2157

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

2307

2158

if null > 2:

2308

2159

os.close(null)

2316

2167

2317

2168

global main_loop

2318

2169

# From the Avahi example code

2319

DBusGMainLoop(set_as_default=True)

2170

DBusGMainLoop(set_as_default=True )

2320

2171

main_loop = gobject.MainLoop()

2321

2172

bus = dbus.SystemBus()

2322

2173

# End of Avahi example code

2328

2179

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

2329

2180

do_not_queue=True))

2330

2181

except dbus.exceptions.NameExistsException as e:

2331

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

2182

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

2332

2183

use_dbus = False

2333

2184

server_settings["use_dbus"] = False

2334

2185

tcp_server.use_dbus = False

2346

2197

2347

2198

client_class = Client

2348

2199

if use_dbus:

2349

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

2200

client_class = functools.partial(ClientDBusTransitional,

2201

bus = bus)

2350

2202

2351

2203

client_settings = Client.config_parser(client_config)

2352

2204

old_client_settings = {}

2360

2212

(stored_state))

2361

2213

os.remove(stored_state_path)

2362

2214

except IOError as e:

2363

if e.errno == errno.ENOENT:

2364

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

2365

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

2366

else:

2367

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

2368

exc_info=e)

2215

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

2216

.format(e))

2217

if e.errno != errno.ENOENT:

2369

2218

raise

2370

2219

except EOFError as e:

2371

2220

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

2372

"EOFError:", exc_info=e)

2221

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

2373

2222

2374

2223

with PGPEngine() as pgp:

2375

2224

for client_name, client in clients_data.iteritems():

2392

2241

2393

2242

# Clients who has passed its expire date can still be

2394

2243

# enabled if its last checker was successful. Clients

2395

# whose checker succeeded before we stored its state is

2396

# assumed to have successfully run all checkers during

2397

# downtime.

2244

# whose checker failed before we stored its state is

2245

# assumed to have failed all checkers during downtime.

2398

2246

if client["enabled"]:

2399

2247

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

2400

2248

if not client["last_checked_ok"]:

2401

2249

logger.warning(

2402

2250

"disabling client {0} - Client never "

2403

"performed a successful checker"

2404

.format(client_name))

2251

"performed a successfull checker"

2252

.format(client["name"]))

2405

2253

client["enabled"] = False

2406

2254

elif client["last_checker_status"] != 0:

2407

2255

logger.warning(

2408

2256

"disabling client {0} - Client "

2409

2257

"last checker failed with error code {1}"

2410

.format(client_name,

2258

.format(client["name"],

2411

2259

client["last_checker_status"]))

2412

2260

client["enabled"] = False

2413

2261

else:

2414

2262

client["expires"] = (datetime.datetime

2415

2263

.utcnow()

2416

2264

+ client["timeout"])

2417

logger.debug("Last checker succeeded,"

2418

" keeping {0} enabled"

2419

.format(client_name))

2265

2420

2266

try:

2421

2267

client["secret"] = (

2422

2268

pgp.decrypt(client["encrypted_secret"],

2428

2274

.format(client_name))

2429

2275

client["secret"] = (

2430

2276

client_settings[client_name]["secret"])

2277

2431

2278

2432

2279

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

2433

for client_name in (set(old_client_settings)

2434

- set(client_settings)):

2280

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

2435

2281

del clients_data[client_name]

2436

for client_name in (set(client_settings)

2437

- set(old_client_settings)):

2282

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

2438

2283

clients_data[client_name] = client_settings[client_name]

2439

2440

# Create all client objects

2284

2285

# Create clients all clients

2441

2286

for client_name, client in clients_data.iteritems():

2442

2287

tcp_server.clients[client_name] = client_class(

2443

2288

name = client_name, settings = client)

2444

2289

2445

2290

if not tcp_server.clients:

2446

2291

logger.warning("No clients defined")

2447

2292

2448

2293

if not debug:

2449

2294

try:

2450

2295

with pidfile:

2464

2309

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

2465

2310

2466

2311

if use_dbus:

2467

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

2468

"se.bsnet.fukt.Mandos"})

2469

class MandosDBusService(DBusObjectWithProperties):

2312

class MandosDBusService(dbus.service.Object):

2470

2313

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

2471

2314

def __init__(self):

2472

2315

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

2473

2316

_interface = "se.recompile.Mandos"

2474

2317

2475

@dbus_interface_annotations(_interface)

2476

def _foo(self):

2477

return { "org.freedesktop.DBus.Property"

2478

".EmitsChangedSignal":

2479

"false"}

2480

2481

2318

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

2482

2319

def ClientAdded(self, objpath):

2483

2320

"D-Bus signal"

2525

2362

2526

2363

del _interface

2527

2364

2528

mandos_dbus_service = MandosDBusService()

2365

class MandosDBusServiceTransitional(MandosDBusService):

2366

__metaclass__ = AlternateDBusNamesMetaclass

2367

mandos_dbus_service = MandosDBusServiceTransitional()

2529

2368

2530

2369

def cleanup():

2531

2370

"Cleanup function; run on exit"

2572

2411

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

2573

2412

os.rename(tempname, stored_state_path)

2574

2413

except (IOError, OSError) as e:

2414

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

2415

.format(e))

2575

2416

if not debug:

2576

2417

try:

2577

2418

os.remove(tempname)

2578

2419

except NameError:

2579

2420

pass

2580

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

2581

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

2582

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

2583

else:

2584

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

2585

exc_info=e)

2421

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

2422

errno.EEXIST)):

2586

2423

raise e

2587

2424

2588

2425

# Delete all clients, and settings from config

2616

2453

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

2617

2454

if use_ipv6:

2618

2455

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

2619

" flowinfo %d, scope_id %d",

2620

*tcp_server.socket.getsockname())

2456

" flowinfo %d, scope_id %d"

2457

% tcp_server.socket.getsockname())

2621

2458

else: # IPv4

2622

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

2623

*tcp_server.socket.getsockname())

2459

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

2460

% tcp_server.socket.getsockname())

2624

2461

2625

2462

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

2626

2463

2629

2466

try:

2630

2467

service.activate()

2631

2468

except dbus.exceptions.DBusException as error:

2632

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

2469

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

2633

2470

cleanup()

2634

2471

sys.exit(1)

2635

2472

# End of Avahi example code

2642

2479

logger.debug("Starting main loop")

2643

2480

main_loop.run()

2644

2481

except AvahiError as error:

2645

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

2482

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

2646

2483

cleanup()

2647

2484

sys.exit(1)

2648

2485

except KeyboardInterrupt: