/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

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

67

65

import types

68

66

import binascii

69

67

import tempfile

70

import itertools

71

68

72

69

import dbus

73

70

import dbus.service

88

85

except ImportError:

89

86

SO_BINDTODEVICE = None

90

87

91

version = "1.5.3"

88

version = "1.4.1"

92

89

stored_state_file = "clients.pickle"

93

90

94

91

logger = logging.getLogger()

145

142

self.gnupg.options.meta_interactive = False

146

143

self.gnupg.options.homedir = self.tempdir

147

144

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

148

'--quiet',

149

'--no-use-agent'])

145

'--quiet'])

150

146

151

147

def __enter__(self):

152

148

return self

178

174

179

175

def encrypt(self, data, password):

180

176

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

181

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

177

with open(os.devnull) as devnull:

182

178

try:

183

179

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

184

180

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

195

191

196

192

def decrypt(self, data, password):

197

193

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

198

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

194

with open(os.devnull) as devnull:

199

195

try:

200

196

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

201

197

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

202

198

attach_fhs={'stderr': devnull})

203

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

199

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

204

200

f.write(data)

205

201

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

206

202

decrypted_plaintext = f.read()

211

207

return decrypted_plaintext

212

208

213

209

210

214

211

class AvahiError(Exception):

215

212

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

216

213

self.value = value

245

242

server: D-Bus Server

246

243

bus: dbus.SystemBus()

247

244

"""

248

249

245

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

250

246

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

251

247

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

264

260

self.server = None

265

261

self.bus = bus

266

262

self.entry_group_state_changed_match = None

267

268

263

def rename(self):

269

264

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

270

265

if self.rename_count >= self.max_renames:

280

275

try:

281

276

self.add()

282

277

except dbus.exceptions.DBusException as error:

283

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

278

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

284

279

self.cleanup()

285

280

os._exit(1)

286

281

self.rename_count += 1

287

288

282

def remove(self):

289

283

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

290

284

if self.entry_group_state_changed_match is not None:

292

286

self.entry_group_state_changed_match = None

293

287

if self.group is not None:

294

288

self.group.Reset()

295

296

289

def add(self):

297

290

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

298

291

self.remove()

315

308

dbus.UInt16(self.port),

316

309

avahi.string_array_to_txt_array(self.TXT))

317

310

self.group.Commit()

318

319

311

def entry_group_state_changed(self, state, error):

320

312

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

321

313

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

328

320

elif state == avahi.ENTRY_GROUP_FAILURE:

329

321

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

330

322

unicode(error))

331

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

332

.format(error))

333

323

raise AvahiGroupError("State changed: %s"

324

% unicode(error))

334

325

def cleanup(self):

335

326

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

336

327

if self.group is not None:

341

332

pass

342

333

self.group = None

343

334

self.remove()

344

345

335

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

346

336

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

347

337

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

366

356

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

367

357

else:

368

358

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

369

370

359

def activate(self):

371

360

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

372

361

if self.server is None:

384

373

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

385

374

ret = AvahiService.rename(self)

386

375

syslogger.setFormatter(logging.Formatter

387

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

388

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

389

.format(self.name)))

376

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

377

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

378

% self.name))

390

379

return ret

391

380

392

381

def timedelta_to_milliseconds(td):

394

383

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

395

384

+ (td.seconds * 1000)

396

385

+ (td.microseconds // 1000))

397

386

398

387

class Client(object):

399

388

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

400

389

425

414

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

426

415

last_checker_status: integer between 0 and 255 reflecting exit

427

416

status of last checker. -1 reflects crashed

428

checker, -2 means no checker completed yet.

417

checker, or None.

429

418

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

430

419

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

431

420

D-Bus identifiers

432

421

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

433

422

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

434

423

until this client is disabled

435

extended_timeout: extra long timeout when secret has been sent

424

extended_timeout: extra long timeout when password has been sent

436

425

runtime_expansions: Allowed attributes for runtime expansion.

437

426

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

438

427

disabled, or None

467

456

468

457

def approval_delay_milliseconds(self):

469

458

return timedelta_to_milliseconds(self.approval_delay)

470

459

471

460

@staticmethod

472

461

def config_parser(config):

473

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

462

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

474

463

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

475

with exceptions for any special settings as defined above.

476

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

477

value given the same arguments.

478

"""

464

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

479

465

settings = {}

480

466

for client_name in config.sections():

481

467

section = dict(config.items(client_name))

485

471

# Reformat values from string types to Python types

486

472

client["approved_by_default"] = config.getboolean(

487

473

client_name, "approved_by_default")

488

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

489

"enabled")

474

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

490

475

491

476

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

492

477

.replace(" ", ""))

498

483

"rb") as secfile:

499

484

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

500

485

else:

501

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

502

.format(section))

486

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

487

% section)

503

488

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

504

489

client["extended_timeout"] = string_to_delta(

505

490

section["extended_timeout"])

511

496

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

512

497

client["last_approval_request"] = None

513

498

client["last_checked_ok"] = None

514

client["last_checker_status"] = -2

515

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

516

508

return settings

517

509

510

518

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

519

515

self.name = name

520

516

# adding all client settings

521

517

for setting, value in settings.iteritems():

522

518

setattr(self, setting, value)

523

519

524

if self.enabled:

525

if not hasattr(self, "last_enabled"):

526

self.last_enabled = datetime.datetime.utcnow()

527

if not hasattr(self, "expires"):

528

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

529

+ self.timeout)

530

else:

531

self.last_enabled = None

532

self.expires = None

533

534

520

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

535

521

# Uppercase and remove spaces from fingerprint for later

536

522

# comparison purposes with return value from the fingerprint()

537

523

# function

538

524

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

539

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

540

datetime.datetime.utcnow())

541

525

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

526

542

527

# attributes specific for this server instance

543

528

self.checker = None

544

529

self.checker_initiator_tag = None

572

557

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

573

558

# Already enabled

574

559

return

560

self.send_changedstate()

575

561

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

576

562

self.enabled = True

577

563

self.last_enabled = datetime.datetime.utcnow()

578

564

self.init_checker()

579

self.send_changedstate()

580

565

581

566

def disable(self, quiet=True):

582

567

"""Disable this client."""

583

568

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

584

569

return False

585

570

if not quiet:

571

self.send_changedstate()

572

if not quiet:

586

573

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

587

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

574

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

588

575

gobject.source_remove(self.disable_initiator_tag)

589

576

self.disable_initiator_tag = None

590

577

self.expires = None

591

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

578

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

592

579

gobject.source_remove(self.checker_initiator_tag)

593

580

self.checker_initiator_tag = None

594

581

self.stop_checker()

595

582

self.enabled = False

596

if not quiet:

597

self.send_changedstate()

598

583

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

599

584

return False

600

585

604

589

def init_checker(self):

605

590

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

606

591

# and every interval from then on.

607

if self.checker_initiator_tag is not None:

608

gobject.source_remove(self.checker_initiator_tag)

609

592

self.checker_initiator_tag = (gobject.timeout_add

610

593

(self.interval_milliseconds(),

611

594

self.start_checker))

612

595

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

613

if self.disable_initiator_tag is not None:

614

gobject.source_remove(self.disable_initiator_tag)

615

596

self.disable_initiator_tag = (gobject.timeout_add

616

597

(self.timeout_milliseconds(),

617

598

self.disable))

636

617

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

637

618

vars(self))

638

619

639

def checked_ok(self):

640

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

641

self.last_checked_ok = datetime.datetime.utcnow()

642

self.last_checker_status = 0

643

self.bump_timeout()

644

645

def bump_timeout(self, timeout=None):

646

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

"""

647

626

if timeout is None:

648

627

timeout = self.timeout

628

self.last_checked_ok = datetime.datetime.utcnow()

649

629

if self.disable_initiator_tag is not None:

650

630

gobject.source_remove(self.disable_initiator_tag)

651

self.disable_initiator_tag = None

652

631

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

653

632

self.disable_initiator_tag = (gobject.timeout_add

654

633

(timedelta_to_milliseconds

664

643

If a checker already exists, leave it running and do

665

644

nothing."""

666

645

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

667

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

668

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

669

# would inevitably timeout, since no checker would get a

670

# 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

671

650

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

672

651

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

673

652

# should be.

703

682

try:

704

683

command = self.checker_command % escaped_attrs

705

684

except TypeError as error:

706

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

707

self.checker_command, exc_info=error)

685

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

686

' %s', self.checker_command, error)

708

687

return True # Try again later

709

688

self.current_checker_command = command

710

689

try:

728

707

gobject.source_remove(self.checker_callback_tag)

729

708

self.checker_callback(pid, status, command)

730

709

except OSError as error:

731

logger.error("Failed to start subprocess",

732

exc_info=error)

710

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

711

error)

733

712

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

734

713

return True

735

714

742

721

return

743

722

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

744

723

try:

745

self.checker.terminate()

724

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

746

725

#time.sleep(0.5)

747

726

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

748

# self.checker.kill()

727

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

749

728

except OSError as error:

750

729

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

751

730

raise

768

747

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

769

748

if byte_arrays and signature != "ay":

770

749

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

771

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

750

" signature %r" % signature)

772

751

def decorator(func):

773

752

func._dbus_is_property = True

774

753

func._dbus_interface = dbus_interface

782

761

return decorator

783

762

784

763

785

def dbus_interface_annotations(dbus_interface):

786

"""Decorator for marking functions returning interface annotations

787

788

Usage:

789

790

@dbus_interface_annotations("org.example.Interface")

791

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

792

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

793

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

794

"false"}

795

"""

796

def decorator(func):

797

func._dbus_is_interface = True

798

func._dbus_interface = dbus_interface

799

func._dbus_name = dbus_interface

800

return func

801

return decorator

802

803

804

def dbus_annotations(annotations):

805

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

806

Usage:

807

808

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

809

access="r")

810

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

811

"org.freedesktop.DBus.Property."

812

"EmitsChangedSignal": "false"})

813

def Property_dbus_property(self):

814

return dbus.Boolean(False)

815

"""

816

def decorator(func):

817

func._dbus_annotations = annotations

818

return func

819

return decorator

820

821

822

764

class DBusPropertyException(dbus.exceptions.DBusException):

823

765

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

824

766

"""

847

789

"""

848

790

849

791

@staticmethod

850

def _is_dbus_thing(thing):

851

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

852

853

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

854

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

855

"""

856

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

857

False)

792

def _is_dbus_property(obj):

793

return getattr(obj, "_dbus_is_property", False)

858

794

859

def _get_all_dbus_things(self, thing):

795

def _get_all_dbus_properties(self):

860

796

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

861

797

"""

862

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

863

name),

864

athing.__get__(self))

798

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

865

799

for cls in self.__class__.__mro__

866

for name, athing in

867

inspect.getmembers(cls,

868

self._is_dbus_thing(thing)))

800

for name, prop in

801

inspect.getmembers(cls, self._is_dbus_property))

869

802

870

803

def _get_dbus_property(self, interface_name, property_name):

871

804

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

873

806

"""

874

807

for cls in self.__class__.__mro__:

875

808

for name, value in (inspect.getmembers

876

(cls,

877

self._is_dbus_thing("property"))):

809

(cls, self._is_dbus_property)):

878

810

if (value._dbus_name == property_name

879

811

and value._dbus_interface == interface_name):

880

812

return value.__get__(self)

909

841

# signatures other than "ay".

910

842

if prop._dbus_signature != "ay":

911

843

raise ValueError

912

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

913

for byte in value))

844

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

845

for byte in value))

914

846

prop(value)

915

847

916

848

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

922

854

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

923

855

"""

924

856

properties = {}

925

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

857

for name, prop in self._get_all_dbus_properties():

926

858

if (interface_name

927

859

and interface_name != prop._dbus_interface):

928

860

# Interface non-empty but did not match

943

875

path_keyword='object_path',

944

876

connection_keyword='connection')

945

877

def Introspect(self, object_path, connection):

946

"""Overloading of standard D-Bus method.

947

948

Inserts property tags and interface annotation tags.

878

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

949

879

"""

950

880

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

951

881

connection)

958

888

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

959

889

return e

960

890

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

961

# Add property tags

962

891

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

963

892

for name, prop

964

in self._get_all_dbus_things("property")

893

in self._get_all_dbus_properties()

965

894

if prop._dbus_interface

966

895

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

967

896

if_tag.appendChild(tag)

968

# Add annotation tags

969

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

970

for tag in if_tag.getElementsByTagName(typ):

971

annots = dict()

972

for name, prop in (self.

973

_get_all_dbus_things(typ)):

974

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

975

and prop._dbus_interface

976

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

977

annots.update(getattr

978

(prop,

979

"_dbus_annotations",

980

{}))

981

for name, value in annots.iteritems():

982

ann_tag = document.createElement(

983

"annotation")

984

ann_tag.setAttribute("name", name)

985

ann_tag.setAttribute("value", value)

986

tag.appendChild(ann_tag)

987

# Add interface annotation tags

988

for annotation, value in dict(

989

itertools.chain.from_iterable(

990

annotations().iteritems()

991

for name, annotations in

992

self._get_all_dbus_things("interface")

993

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

994

)).iteritems():

995

ann_tag = document.createElement("annotation")

996

ann_tag.setAttribute("name", annotation)

997

ann_tag.setAttribute("value", value)

998

if_tag.appendChild(ann_tag)

999

897

# Add the names to the return values for the

1000

898

# "org.freedesktop.DBus.Properties" methods

1001

899

if (if_tag.getAttribute("name")

1016

914

except (AttributeError, xml.dom.DOMException,

1017

915

xml.parsers.expat.ExpatError) as error:

1018

916

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

1019

exc_info=error)

917

error)

1020

918

return xmlstring

1021

919

1022

920

1028

926

variant_level=variant_level)

1029

927

1030

928

1031

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1032

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

1033

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

1034

interface names according to the "alt_interface_names" mapping.

1035

Usage:

1036

1037

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

1038

"net.example.AlternateInterface"})

1039

class SampleDBusObject(dbus.service.Object):

1040

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

1041

def SampleDBusMethod():

1042

pass

1043

1044

The above "SampleDBusMethod" on "SampleDBusObject" will be

1045

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

1046

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

1047

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

1048

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

1049

1050

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

1051

(from DBusObjectWithProperties) and interfaces (from the

1052

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.

1053

933

"""

1054

def wrapper(cls):

1055

for orig_interface_name, alt_interface_name in (

1056

alt_interface_names.iteritems()):

1057

attr = {}

1058

interface_names = set()

1059

# Go though all attributes of the class

1060

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

1061

941

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

1062

942

# with the wrong interface name

1063

943

if (not hasattr(attribute, "_dbus_interface")

1064

944

or not attribute._dbus_interface

1065

.startswith(orig_interface_name)):

945

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

1066

946

continue

1067

947

# Create an alternate D-Bus interface name based on

1068

948

# the current name

1069

949

alt_interface = (attribute._dbus_interface

1070

.replace(orig_interface_name,

1071

alt_interface_name))

1072

interface_names.add(alt_interface)

950

.replace("se.recompile.Mandos",

951

"se.bsnet.fukt.Mandos"))

1073

952

# Is this a D-Bus signal?

1074

953

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

1075

954

# Extract the original non-method function by

1090

969

nonmethod_func.func_name,

1091

970

nonmethod_func.func_defaults,

1092

971

nonmethod_func.func_closure)))

1093

# Copy annotations, if any

1094

try:

1095

new_function._dbus_annotations = (

1096

dict(attribute._dbus_annotations))

1097

except AttributeError:

1098

pass

1099

972

# Define a creator of a function to call both the

1100

# original and alternate functions, so both the

1101

# original and alternate signals gets sent when

1102

# the function is called

973

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

974

# signals gets sent when the function is called

1103

975

def fixscope(func1, func2):

1104

976

"""This function is a scope container to pass

1105

977

func1 and func2 to the "call_both" function

1112

984

return call_both

1113

985

# Create the "call_both" function and add it to

1114

986

# the class

1115

attr[attrname] = fixscope(attribute, new_function)

987

attr[attrname] = fixscope(attribute,

988

new_function)

1116

989

# Is this a D-Bus method?

1117

990

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

1118

991

# Create a new, but exactly alike, function

1129

1002

attribute.func_name,

1130

1003

attribute.func_defaults,

1131

1004

attribute.func_closure)))

1132

# Copy annotations, if any

1133

try:

1134

attr[attrname]._dbus_annotations = (

1135

dict(attribute._dbus_annotations))

1136

except AttributeError:

1137

pass

1138

1005

# Is this a D-Bus property?

1139

1006

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

1140

1007

# Create a new, but exactly alike, function

1154

1021

attribute.func_name,

1155

1022

attribute.func_defaults,

1156

1023

attribute.func_closure)))

1157

# Copy annotations, if any

1158

try:

1159

attr[attrname]._dbus_annotations = (

1160

dict(attribute._dbus_annotations))

1161

except AttributeError:

1162

pass

1163

# Is this a D-Bus interface?

1164

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

1165

# Create a new, but exactly alike, function

1166

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

1167

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

1168

# to the class.

1169

attr[attrname] = (dbus_interface_annotations

1170

(alt_interface)

1171

(types.FunctionType

1172

(attribute.func_code,

1173

attribute.func_globals,

1174

attribute.func_name,

1175

attribute.func_defaults,

1176

attribute.func_closure)))

1177

if deprecate:

1178

# Deprecate all alternate interfaces

1179

iname="_AlternateDBusNames_interface_annotation{0}"

1180

for interface_name in interface_names:

1181

@dbus_interface_annotations(interface_name)

1182

def func(self):

1183

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

1184

"true" }

1185

# Find an unused name

1186

for aname in (iname.format(i)

1187

for i in itertools.count()):

1188

if aname not in attr:

1189

attr[aname] = func

1190

break

1191

if interface_names:

1192

# Replace the class with a new subclass of it with

1193

# methods, signals, etc. as created above.

1194

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

1195

(cls,), attr)

1196

return cls

1197

return wrapper

1198

1199

1200

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

1201

"se.bsnet.fukt.Mandos"})

1024

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

1025

1026

1202

1027

class ClientDBus(Client, DBusObjectWithProperties):

1203

1028

"""A Client class using D-Bus

1204

1029

1215

1040

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

1216

1041

self.bus = bus

1217

1042

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

1043

self._approvals_pending = 0

1044

1045

self._approvals_pending = 0

1218

1046

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

1219

1047

# the D-Bus

1220

1048

client_object_name = unicode(self.name).translate(

1224

1052

("/clients/" + client_object_name))

1225

1053

DBusObjectWithProperties.__init__(self, self.bus,

1226

1054

self.dbus_object_path)

1227

1055

1228

1056

def notifychangeproperty(transform_func,

1229

1057

dbus_name, type_func=lambda x: x,

1230

1058

variant_level=1):

1253

1081

1254

1082

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

1255

1083

1084

1256

1085

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1257

1086

approvals_pending = notifychangeproperty(dbus.Boolean,

1258

1087

"ApprovalPending",

1265

1094

checker is not None)

1266

1095

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1267

1096

"LastCheckedOK")

1268

last_checker_status = notifychangeproperty(dbus.Int16,

1269

"LastCheckerStatus")

1270

1097

last_approval_request = notifychangeproperty(

1271

1098

datetime_to_dbus, "LastApprovalRequest")

1272

1099

approved_by_default = notifychangeproperty(dbus.Boolean,

1340

1167

return False

1341

1168

1342

1169

def approve(self, value=True):

1170

self.send_changedstate()

1343

1171

self.approved = value

1344

1172

gobject.timeout_add(timedelta_to_milliseconds

1345

1173

(self.approval_duration),

1346

1174

self._reset_approved)

1347

self.send_changedstate()

1175

1348

1176

1349

1177

## D-Bus methods, signals & properties

1350

1178

_interface = "se.recompile.Mandos.Client"

1351

1179

1352

## Interfaces

1353

1354

@dbus_interface_annotations(_interface)

1355

def _foo(self):

1356

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

1357

"false"}

1358

1359

1180

## Signals

1360

1181

1361

1182

# CheckerCompleted - signal

1397

1218

"D-Bus signal"

1398

1219

return self.need_approval()

1399

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

1400

1229

## Methods

1401

1230

1402

1231

# Approve - method

1512

1341

return

1513

1342

return datetime_to_dbus(self.last_checked_ok)

1514

1343

1515

# LastCheckerStatus - property

1516

@dbus_service_property(_interface, signature="n",

1517

access="read")

1518

def LastCheckerStatus_dbus_property(self):

1519

return dbus.Int16(self.last_checker_status)

1520

1521

1344

# Expires - property

1522

1345

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

1523

1346

def Expires_dbus_property(self):

1534

1357

def Timeout_dbus_property(self, value=None):

1535

1358

if value is None: # get

1536

1359

return dbus.UInt64(self.timeout_milliseconds())

1537

old_timeout = self.timeout

1538

1360

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

1539

# Reschedule disabling

1540

if self.enabled:

1541

now = datetime.datetime.utcnow()

1542

self.expires += self.timeout - old_timeout

1543

if self.expires <= now:

1544

# The timeout has passed

1545

self.disable()

1546

else:

1547

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

1548

is None):

1549

return

1550

gobject.source_remove(self.disable_initiator_tag)

1551

self.disable_initiator_tag = (

1552

gobject.timeout_add(

1553

timedelta_to_milliseconds(self.expires - now),

1554

self.disable))

1361

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

1362

return

1363

# Reschedule timeout

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

1555

1381

1556

1382

# ExtendedTimeout - property

1557

1383

@dbus_service_property(_interface, signature="t",

1636

1462

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

1637

1463

1638

1464

1465

class ClientDBusTransitional(ClientDBus):

1466

__metaclass__ = AlternateDBusNamesMetaclass

1467

1468

1639

1469

class ClientHandler(socketserver.BaseRequestHandler, object):

1640

1470

"""A class to handle client connections.

1641

1471

1709

1539

except KeyError:

1710

1540

return

1711

1541

1542

if self.server.use_dbus:

1543

# Emit D-Bus signal

1544

client.NewRequest(str(self.client_address))

1545

1712

1546

if client.approval_delay:

1713

1547

delay = client.approval_delay

1714

1548

client.approvals_pending += 1

1745

1579

#wait until timeout or approved

1746

1580

time = datetime.datetime.now()

1747

1581

client.changedstate.acquire()

1748

client.changedstate.wait(

1749

float(timedelta_to_milliseconds(delay)

1750

/ 1000))

1582

(client.changedstate.wait

1583

(float(client.timedelta_to_milliseconds(delay)

1584

/ 1000)))

1751

1585

client.changedstate.release()

1752

1586

time2 = datetime.datetime.now()

1753

1587

if (time2 - time) >= delay:

1769

1603

try:

1770

1604

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

1771

1605

except gnutls.errors.GNUTLSError as error:

1772

logger.warning("gnutls send failed",

1773

exc_info=error)

1606

logger.warning("gnutls send failed")

1774

1607

return

1775

1608

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

1776

1609

sent, len(client.secret)

1779

1612

1780

1613

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

1781

1614

# bump the timeout using extended_timeout

1782

client.bump_timeout(client.extended_timeout)

1615

client.checked_ok(client.extended_timeout)

1783

1616

if self.server.use_dbus:

1784

1617

# Emit D-Bus signal

1785

1618

client.GotSecret()

1790

1623

try:

1791

1624

session.bye()

1792

1625

except gnutls.errors.GNUTLSError as error:

1793

logger.warning("GnuTLS bye failed",

1794

exc_info=error)

1626

logger.warning("GnuTLS bye failed")

1795

1627

1796

1628

@staticmethod

1797

1629

def peer_certificate(session):

1869

1701

def process_request(self, request, address):

1870

1702

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

1871

1703

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

1872

args = (request, address))

1704

args = (request,

1705

address))

1873

1706

proc.start()

1874

1707

return proc

1875

1708

1997

1830

1998

1831

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

1999

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)

2000

1847

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

2001

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

1848

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

2002

1849

# Wait for other process to exit

2003

1850

proc.join()

2004

1851

return False

2094

1941

elif suffix == "w":

2095

1942

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

2096

1943

else:

2097

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

2098

.format(suffix))

1944

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

2099

1945

except (ValueError, IndexError) as e:

2100

1946

raise ValueError(*(e.args))

2101

1947

timevalue += delta

2115

1961

sys.exit()

2116

1962

if not noclose:

2117

1963

# Close all standard open file descriptors

2118

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

1964

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

2119

1965

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

2120

1966

raise OSError(errno.ENODEV,

2121

"{0} not a character device"

2122

.format(os.devnull))

1967

"%s not a character device"

1968

% os.path.devnull)

2123

1969

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

2124

1970

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

2125

1971

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

2134

1980

2135

1981

parser = argparse.ArgumentParser()

2136

1982

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

2137

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

1983

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

2138

1984

help="show version number and exit")

2139

1985

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

2140

1986

help="Bind to interface IF")

2243

2089

2244

2090

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

2245

2091

syslogger.setFormatter(logging.Formatter

2246

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

2247

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

2248

.format(server_settings

2249

["servicename"])))

2092

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

2093

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

2094

% server_settings["servicename"]))

2250

2095

2251

2096

# Parse config file with clients

2252

client_config = configparser.SafeConfigParser(Client

2253

.client_defaults)

2097

client_config = configparser.SafeConfigParser(Client.client_defaults)

2254

2098

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

2255

2099

"clients.conf"))

2256

2100

2270

2114

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

2271

2115

try:

2272

2116

pidfile = open(pidfilename, "w")

2273

except IOError as e:

2274

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

2275

exc_info=e)

2117

except IOError:

2118

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

2276

2119

2277

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:

2278

2124

try:

2279

uid = pwd.getpwnam(name).pw_uid

2280

gid = pwd.getpwnam(name).pw_gid

2281

break

2125

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

2126

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

2282

2127

except KeyError:

2283

continue

2284

else:

2285

uid = 65534

2286

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

2287

2134

try:

2288

2135

os.setgid(gid)

2289

2136

os.setuid(uid)

2306

2153

.gnutls_global_set_log_function(debug_gnutls))

2307

2154

2308

2155

# Redirect stdin so all checkers get /dev/null

2309

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

2156

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

2310

2157

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

2311

2158

if null > 2:

2312

2159

os.close(null)

2320

2167

2321

2168

global main_loop

2322

2169

# From the Avahi example code

2323

DBusGMainLoop(set_as_default=True)

2170

DBusGMainLoop(set_as_default=True )

2324

2171

main_loop = gobject.MainLoop()

2325

2172

bus = dbus.SystemBus()

2326

2173

# End of Avahi example code

2332

2179

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

2333

2180

do_not_queue=True))

2334

2181

except dbus.exceptions.NameExistsException as e:

2335

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

2182

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

2336

2183

use_dbus = False

2337

2184

server_settings["use_dbus"] = False

2338

2185

tcp_server.use_dbus = False

2350

2197

2351

2198

client_class = Client

2352

2199

if use_dbus:

2353

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

2200

client_class = functools.partial(ClientDBusTransitional,

2201

bus = bus)

2354

2202

2355

2203

client_settings = Client.config_parser(client_config)

2356

2204

old_client_settings = {}

2364

2212

(stored_state))

2365

2213

os.remove(stored_state_path)

2366

2214

except IOError as e:

2367

if e.errno == errno.ENOENT:

2368

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

2369

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

2370

else:

2371

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

2372

exc_info=e)

2215

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

2216

.format(e))

2217

if e.errno != errno.ENOENT:

2373

2218

raise

2374

2219

except EOFError as e:

2375

2220

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

2376

"EOFError:", exc_info=e)

2221

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

2377

2222

2378

2223

with PGPEngine() as pgp:

2379

2224

for client_name, client in clients_data.iteritems():

2396

2241

2397

2242

# Clients who has passed its expire date can still be

2398

2243

# enabled if its last checker was successful. Clients

2399

# whose checker succeeded before we stored its state is

2400

# assumed to have successfully run all checkers during

2401

# downtime.

2244

# whose checker failed before we stored its state is

2245

# assumed to have failed all checkers during downtime.

2402

2246

if client["enabled"]:

2403

2247

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

2404

2248

if not client["last_checked_ok"]:

2405

2249

logger.warning(

2406

2250

"disabling client {0} - Client never "

2407

"performed a successful checker"

2408

.format(client_name))

2251

"performed a successfull checker"

2252

.format(client["name"]))

2409

2253

client["enabled"] = False

2410

2254

elif client["last_checker_status"] != 0:

2411

2255

logger.warning(

2412

2256

"disabling client {0} - Client "

2413

2257

"last checker failed with error code {1}"

2414

.format(client_name,

2258

.format(client["name"],

2415

2259

client["last_checker_status"]))

2416

2260

client["enabled"] = False

2417

2261

else:

2418

2262

client["expires"] = (datetime.datetime

2419

2263

.utcnow()

2420

2264

+ client["timeout"])

2421

logger.debug("Last checker succeeded,"

2422

" keeping {0} enabled"

2423

.format(client_name))

2265

2424

2266

try:

2425

2267

client["secret"] = (

2426

2268

pgp.decrypt(client["encrypted_secret"],

2432

2274

.format(client_name))

2433

2275

client["secret"] = (

2434

2276

client_settings[client_name]["secret"])

2277

2435

2278

2436

2279

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

2437

for client_name in (set(old_client_settings)

2438

- set(client_settings)):

2280

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

2439

2281

del clients_data[client_name]

2440

for client_name in (set(client_settings)

2441

- set(old_client_settings)):

2282

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

2442

2283

clients_data[client_name] = client_settings[client_name]

2443

2444

# Create all client objects

2284

2285

# Create clients all clients

2445

2286

for client_name, client in clients_data.iteritems():

2446

2287

tcp_server.clients[client_name] = client_class(

2447

2288

name = client_name, settings = client)

2448

2289

2449

2290

if not tcp_server.clients:

2450

2291

logger.warning("No clients defined")

2451

2292

2452

2293

if not debug:

2453

2294

try:

2454

2295

with pidfile:

2468

2309

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

2469

2310

2470

2311

if use_dbus:

2471

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

2472

"se.bsnet.fukt.Mandos"})

2473

class MandosDBusService(DBusObjectWithProperties):

2312

class MandosDBusService(dbus.service.Object):

2474

2313

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

2475

2314

def __init__(self):

2476

2315

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

2477

2316

_interface = "se.recompile.Mandos"

2478

2317

2479

@dbus_interface_annotations(_interface)

2480

def _foo(self):

2481

return { "org.freedesktop.DBus.Property"

2482

".EmitsChangedSignal":

2483

"false"}

2484

2485

2318

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

2486

2319

def ClientAdded(self, objpath):

2487

2320

"D-Bus signal"

2529

2362

2530

2363

del _interface

2531

2364

2532

mandos_dbus_service = MandosDBusService()

2365

class MandosDBusServiceTransitional(MandosDBusService):

2366

__metaclass__ = AlternateDBusNamesMetaclass

2367

mandos_dbus_service = MandosDBusServiceTransitional()

2533

2368

2534

2369

def cleanup():

2535

2370

"Cleanup function; run on exit"

2568

2403

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

2569

2404

2570

2405

try:

2571

with (tempfile.NamedTemporaryFile

2572

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

2573

dir=os.path.dirname(stored_state_path),

2574

delete=False)) as stored_state:

2406

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

2407

prefix="clients-",

2408

dir=os.path.dirname

2409

(stored_state_path))

2410

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

2575

2411

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

2576

tempname=stored_state.name

2577

2412

os.rename(tempname, stored_state_path)

2578

2413

except (IOError, OSError) as e:

2414

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

2415

.format(e))

2579

2416

if not debug:

2580

2417

try:

2581

2418

os.remove(tempname)

2582

2419

except NameError:

2583

2420

pass

2584

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

2585

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

2586

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

2587

else:

2588

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

2589

exc_info=e)

2421

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

2422

errno.EEXIST)):

2590

2423

raise e

2591

2424

2592

2425

# Delete all clients, and settings from config

2620

2453

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

2621

2454

if use_ipv6:

2622

2455

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

2623

" flowinfo %d, scope_id %d",

2624

*tcp_server.socket.getsockname())

2456

" flowinfo %d, scope_id %d"

2457

% tcp_server.socket.getsockname())

2625

2458

else: # IPv4

2626

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

2627

*tcp_server.socket.getsockname())

2459

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

2460

% tcp_server.socket.getsockname())

2628

2461

2629

2462

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

2630

2463

2633

2466

try:

2634

2467

service.activate()

2635

2468

except dbus.exceptions.DBusException as error:

2636

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

2469

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

2637

2470

cleanup()

2638

2471

sys.exit(1)

2639

2472

# End of Avahi example code

2646

2479

logger.debug("Starting main loop")

2647

2480

main_loop.run()

2648

2481

except AvahiError as error:

2649

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

2482

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

2650

2483

cleanup()

2651

2484

sys.exit(1)

2652

2485

except KeyboardInterrupt: