/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

632

617

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

633

618

vars(self))

634

619

635

def checked_ok(self):

636

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

637

self.last_checked_ok = datetime.datetime.utcnow()

638

self.last_checker_status = 0

639

self.bump_timeout()

640

641

def bump_timeout(self, timeout=None):

642

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

"""

643

626

if timeout is None:

644

627

timeout = self.timeout

628

self.last_checked_ok = datetime.datetime.utcnow()

645

629

if self.disable_initiator_tag is not None:

646

630

gobject.source_remove(self.disable_initiator_tag)

647

631

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

659

643

If a checker already exists, leave it running and do

660

644

nothing."""

661

645

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

662

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

663

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

664

# would inevitably timeout, since no checker would get a

665

# 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

666

650

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

667

651

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

668

652

# should be.

698

682

try:

699

683

command = self.checker_command % escaped_attrs

700

684

except TypeError as error:

701

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

702

self.checker_command, exc_info=error)

685

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

686

' %s', self.checker_command, error)

703

687

return True # Try again later

704

688

self.current_checker_command = command

705

689

try:

723

707

gobject.source_remove(self.checker_callback_tag)

724

708

self.checker_callback(pid, status, command)

725

709

except OSError as error:

726

logger.error("Failed to start subprocess",

727

exc_info=error)

710

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

711

error)

728

712

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

729

713

return True

730

714

737

721

return

738

722

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

739

723

try:

740

self.checker.terminate()

724

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

741

725

#time.sleep(0.5)

742

726

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

743

# self.checker.kill()

727

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

744

728

except OSError as error:

745

729

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

746

730

raise

763

747

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

764

748

if byte_arrays and signature != "ay":

765

749

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

766

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

750

" signature %r" % signature)

767

751

def decorator(func):

768

752

func._dbus_is_property = True

769

753

func._dbus_interface = dbus_interface

777

761

return decorator

778

762

779

763

780

def dbus_interface_annotations(dbus_interface):

781

"""Decorator for marking functions returning interface annotations

782

783

Usage:

784

785

@dbus_interface_annotations("org.example.Interface")

786

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

787

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

788

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

789

"false"}

790

"""

791

def decorator(func):

792

func._dbus_is_interface = True

793

func._dbus_interface = dbus_interface

794

func._dbus_name = dbus_interface

795

return func

796

return decorator

797

798

799

def dbus_annotations(annotations):

800

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

801

Usage:

802

803

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

804

access="r")

805

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

806

"org.freedesktop.DBus.Property."

807

"EmitsChangedSignal": "false"})

808

def Property_dbus_property(self):

809

return dbus.Boolean(False)

810

"""

811

def decorator(func):

812

func._dbus_annotations = annotations

813

return func

814

return decorator

815

816

817

764

class DBusPropertyException(dbus.exceptions.DBusException):

818

765

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

819

766

"""

842

789

"""

843

790

844

791

@staticmethod

845

def _is_dbus_thing(thing):

846

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

847

848

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

849

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

850

"""

851

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

852

False)

792

def _is_dbus_property(obj):

793

return getattr(obj, "_dbus_is_property", False)

853

794

854

def _get_all_dbus_things(self, thing):

795

def _get_all_dbus_properties(self):

855

796

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

856

797

"""

857

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

858

name),

859

athing.__get__(self))

798

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

860

799

for cls in self.__class__.__mro__

861

for name, athing in

862

inspect.getmembers(cls,

863

self._is_dbus_thing(thing)))

800

for name, prop in

801

inspect.getmembers(cls, self._is_dbus_property))

864

802

865

803

def _get_dbus_property(self, interface_name, property_name):

866

804

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

868

806

"""

869

807

for cls in self.__class__.__mro__:

870

808

for name, value in (inspect.getmembers

871

(cls,

872

self._is_dbus_thing("property"))):

809

(cls, self._is_dbus_property)):

873

810

if (value._dbus_name == property_name

874

811

and value._dbus_interface == interface_name):

875

812

return value.__get__(self)

904

841

# signatures other than "ay".

905

842

if prop._dbus_signature != "ay":

906

843

raise ValueError

907

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

908

for byte in value))

844

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

845

for byte in value))

909

846

prop(value)

910

847

911

848

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

917

854

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

918

855

"""

919

856

properties = {}

920

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

857

for name, prop in self._get_all_dbus_properties():

921

858

if (interface_name

922

859

and interface_name != prop._dbus_interface):

923

860

# Interface non-empty but did not match

938

875

path_keyword='object_path',

939

876

connection_keyword='connection')

940

877

def Introspect(self, object_path, connection):

941

"""Overloading of standard D-Bus method.

942

943

Inserts property tags and interface annotation tags.

878

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

944

879

"""

945

880

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

946

881

connection)

953

888

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

954

889

return e

955

890

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

956

# Add property tags

957

891

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

958

892

for name, prop

959

in self._get_all_dbus_things("property")

893

in self._get_all_dbus_properties()

960

894

if prop._dbus_interface

961

895

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

962

896

if_tag.appendChild(tag)

963

# Add annotation tags

964

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

965

for tag in if_tag.getElementsByTagName(typ):

966

annots = dict()

967

for name, prop in (self.

968

_get_all_dbus_things(typ)):

969

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

970

and prop._dbus_interface

971

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

972

annots.update(getattr

973

(prop,

974

"_dbus_annotations",

975

{}))

976

for name, value in annots.iteritems():

977

ann_tag = document.createElement(

978

"annotation")

979

ann_tag.setAttribute("name", name)

980

ann_tag.setAttribute("value", value)

981

tag.appendChild(ann_tag)

982

# Add interface annotation tags

983

for annotation, value in dict(

984

itertools.chain.from_iterable(

985

annotations().iteritems()

986

for name, annotations in

987

self._get_all_dbus_things("interface")

988

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

989

)).iteritems():

990

ann_tag = document.createElement("annotation")

991

ann_tag.setAttribute("name", annotation)

992

ann_tag.setAttribute("value", value)

993

if_tag.appendChild(ann_tag)

994

897

# Add the names to the return values for the

995

898

# "org.freedesktop.DBus.Properties" methods

996

899

if (if_tag.getAttribute("name")

1011

914

except (AttributeError, xml.dom.DOMException,

1012

915

xml.parsers.expat.ExpatError) as error:

1013

916

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

1014

exc_info=error)

917

error)

1015

918

return xmlstring

1016

919

1017

920

1023

926

variant_level=variant_level)

1024

927

1025

928

1026

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1027

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

1028

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

1029

interface names according to the "alt_interface_names" mapping.

1030

Usage:

1031

1032

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

1033

"net.example.AlternateInterface"})

1034

class SampleDBusObject(dbus.service.Object):

1035

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

1036

def SampleDBusMethod():

1037

pass

1038

1039

The above "SampleDBusMethod" on "SampleDBusObject" will be

1040

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

1041

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

1042

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

1043

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

1044

1045

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

1046

(from DBusObjectWithProperties) and interfaces (from the

1047

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.

1048

933

"""

1049

def wrapper(cls):

1050

for orig_interface_name, alt_interface_name in (

1051

alt_interface_names.iteritems()):

1052

attr = {}

1053

interface_names = set()

1054

# Go though all attributes of the class

1055

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

1056

941

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

1057

942

# with the wrong interface name

1058

943

if (not hasattr(attribute, "_dbus_interface")

1059

944

or not attribute._dbus_interface

1060

.startswith(orig_interface_name)):

945

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

1061

946

continue

1062

947

# Create an alternate D-Bus interface name based on

1063

948

# the current name

1064

949

alt_interface = (attribute._dbus_interface

1065

.replace(orig_interface_name,

1066

alt_interface_name))

1067

interface_names.add(alt_interface)

950

.replace("se.recompile.Mandos",

951

"se.bsnet.fukt.Mandos"))

1068

952

# Is this a D-Bus signal?

1069

953

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

1070

954

# Extract the original non-method function by

1085

969

nonmethod_func.func_name,

1086

970

nonmethod_func.func_defaults,

1087

971

nonmethod_func.func_closure)))

1088

# Copy annotations, if any

1089

try:

1090

new_function._dbus_annotations = (

1091

dict(attribute._dbus_annotations))

1092

except AttributeError:

1093

pass

1094

972

# Define a creator of a function to call both the

1095

# original and alternate functions, so both the

1096

# original and alternate signals gets sent when

1097

# the function is called

973

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

974

# signals gets sent when the function is called

1098

975

def fixscope(func1, func2):

1099

976

"""This function is a scope container to pass

1100

977

func1 and func2 to the "call_both" function

1107

984

return call_both

1108

985

# Create the "call_both" function and add it to

1109

986

# the class

1110

attr[attrname] = fixscope(attribute, new_function)

987

attr[attrname] = fixscope(attribute,

988

new_function)

1111

989

# Is this a D-Bus method?

1112

990

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

1113

991

# Create a new, but exactly alike, function

1124

1002

attribute.func_name,

1125

1003

attribute.func_defaults,

1126

1004

attribute.func_closure)))

1127

# Copy annotations, if any

1128

try:

1129

attr[attrname]._dbus_annotations = (

1130

dict(attribute._dbus_annotations))

1131

except AttributeError:

1132

pass

1133

1005

# Is this a D-Bus property?

1134

1006

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

1135

1007

# Create a new, but exactly alike, function

1149

1021

attribute.func_name,

1150

1022

attribute.func_defaults,

1151

1023

attribute.func_closure)))

1152

# Copy annotations, if any

1153

try:

1154

attr[attrname]._dbus_annotations = (

1155

dict(attribute._dbus_annotations))

1156

except AttributeError:

1157

pass

1158

# Is this a D-Bus interface?

1159

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

1160

# Create a new, but exactly alike, function

1161

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

1162

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

1163

# to the class.

1164

attr[attrname] = (dbus_interface_annotations

1165

(alt_interface)

1166

(types.FunctionType

1167

(attribute.func_code,

1168

attribute.func_globals,

1169

attribute.func_name,

1170

attribute.func_defaults,

1171

attribute.func_closure)))

1172

if deprecate:

1173

# Deprecate all alternate interfaces

1174

iname="_AlternateDBusNames_interface_annotation{0}"

1175

for interface_name in interface_names:

1176

@dbus_interface_annotations(interface_name)

1177

def func(self):

1178

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

1179

"true" }

1180

# Find an unused name

1181

for aname in (iname.format(i)

1182

for i in itertools.count()):

1183

if aname not in attr:

1184

attr[aname] = func

1185

break

1186

if interface_names:

1187

# Replace the class with a new subclass of it with

1188

# methods, signals, etc. as created above.

1189

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

1190

(cls,), attr)

1191

return cls

1192

return wrapper

1193

1194

1195

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

1196

"se.bsnet.fukt.Mandos"})

1024

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

1025

1026

1197

1027

class ClientDBus(Client, DBusObjectWithProperties):

1198

1028

"""A Client class using D-Bus

1199

1029

1210

1040

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

1211

1041

self.bus = bus

1212

1042

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

1043

self._approvals_pending = 0

1044

1045

self._approvals_pending = 0

1213

1046

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

1214

1047

# the D-Bus

1215

1048

client_object_name = unicode(self.name).translate(

1219

1052

("/clients/" + client_object_name))

1220

1053

DBusObjectWithProperties.__init__(self, self.bus,

1221

1054

self.dbus_object_path)

1222

1055

1223

1056

def notifychangeproperty(transform_func,

1224

1057

dbus_name, type_func=lambda x: x,

1225

1058

variant_level=1):

1248

1081

1249

1082

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

1250

1083

1084

1251

1085

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1252

1086

approvals_pending = notifychangeproperty(dbus.Boolean,

1253

1087

"ApprovalPending",

1260

1094

checker is not None)

1261

1095

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1262

1096

"LastCheckedOK")

1263

last_checker_status = notifychangeproperty(dbus.Int16,

1264

"LastCheckerStatus")

1265

1097

last_approval_request = notifychangeproperty(

1266

1098

datetime_to_dbus, "LastApprovalRequest")

1267

1099

approved_by_default = notifychangeproperty(dbus.Boolean,

1341

1173

(self.approval_duration),

1342

1174

self._reset_approved)

1343

1175

1176

1344

1177

## D-Bus methods, signals & properties

1345

1178

_interface = "se.recompile.Mandos.Client"

1346

1179

1347

## Interfaces

1348

1349

@dbus_interface_annotations(_interface)

1350

def _foo(self):

1351

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

1352

"false"}

1353

1354

1180

## Signals

1355

1181

1356

1182

# CheckerCompleted - signal

1392

1218

"D-Bus signal"

1393

1219

return self.need_approval()

1394

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

1395

1229

## Methods

1396

1230

1397

1231

# Approve - method

1507

1341

return

1508

1342

return datetime_to_dbus(self.last_checked_ok)

1509

1343

1510

# LastCheckerStatus - property

1511

@dbus_service_property(_interface, signature="n",

1512

access="read")

1513

def LastCheckerStatus_dbus_property(self):

1514

return dbus.Int16(self.last_checker_status)

1515

1516

1344

# Expires - property

1517

1345

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

1518

1346

def Expires_dbus_property(self):

1530

1358

if value is None: # get

1531

1359

return dbus.UInt64(self.timeout_milliseconds())

1532

1360

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

1361

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

1362

return

1533

1363

# Reschedule timeout

1534

if self.enabled:

1535

now = datetime.datetime.utcnow()

1536

time_to_die = timedelta_to_milliseconds(

1537

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

1538

if time_to_die <= 0:

1539

# The timeout has passed

1540

self.disable()

1541

else:

1542

self.expires = (now +

1543

datetime.timedelta(milliseconds =

1544

time_to_die))

1545

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

1546

is None):

1547

return

1548

gobject.source_remove(self.disable_initiator_tag)

1549

self.disable_initiator_tag = (gobject.timeout_add

1550

(time_to_die,

1551

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

1552

1381

1553

1382

# ExtendedTimeout - property

1554

1383

@dbus_service_property(_interface, signature="t",

1633

1462

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

1634

1463

1635

1464

1465

class ClientDBusTransitional(ClientDBus):

1466

__metaclass__ = AlternateDBusNamesMetaclass

1467

1468

1636

1469

class ClientHandler(socketserver.BaseRequestHandler, object):

1637

1470

"""A class to handle client connections.

1638

1471

1706

1539

except KeyError:

1707

1540

return

1708

1541

1542

if self.server.use_dbus:

1543

# Emit D-Bus signal

1544

client.NewRequest(str(self.client_address))

1545

1709

1546

if client.approval_delay:

1710

1547

delay = client.approval_delay

1711

1548

client.approvals_pending += 1

1766

1603

try:

1767

1604

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

1768

1605

except gnutls.errors.GNUTLSError as error:

1769

logger.warning("gnutls send failed",

1770

exc_info=error)

1606

logger.warning("gnutls send failed")

1771

1607

return

1772

1608

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

1773

1609

sent, len(client.secret)

1776

1612

1777

1613

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

1778

1614

# bump the timeout using extended_timeout

1779

client.bump_timeout(client.extended_timeout)

1615

client.checked_ok(client.extended_timeout)

1780

1616

if self.server.use_dbus:

1781

1617

# Emit D-Bus signal

1782

1618

client.GotSecret()

1787

1623

try:

1788

1624

session.bye()

1789

1625

except gnutls.errors.GNUTLSError as error:

1790

logger.warning("GnuTLS bye failed",

1791

exc_info=error)

1626

logger.warning("GnuTLS bye failed")

1792

1627

1793

1628

@staticmethod

1794

1629

def peer_certificate(session):

1866

1701

def process_request(self, request, address):

1867

1702

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

1868

1703

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

1869

args = (request, address))

1704

args = (request,

1705

address))

1870

1706

proc.start()

1871

1707

return proc

1872

1708

1994

1830

1995

1831

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

1996

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)

1997

1847

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

1998

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

1848

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

1999

1849

# Wait for other process to exit

2000

1850

proc.join()

2001

1851

return False

2091

1941

elif suffix == "w":

2092

1942

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

2093

1943

else:

2094

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

2095

.format(suffix))

1944

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

2096

1945

except (ValueError, IndexError) as e:

2097

1946

raise ValueError(*(e.args))

2098

1947

timevalue += delta

2112

1961

sys.exit()

2113

1962

if not noclose:

2114

1963

# Close all standard open file descriptors

2115

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

1964

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

2116

1965

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

2117

1966

raise OSError(errno.ENODEV,

2118

"{0} not a character device"

2119

.format(os.devnull))

1967

"%s not a character device"

1968

% os.path.devnull)

2120

1969

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

2121

1970

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

2122

1971

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

2131

1980

2132

1981

parser = argparse.ArgumentParser()

2133

1982

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

2134

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

1983

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

2135

1984

help="show version number and exit")

2136

1985

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

2137

1986

help="Bind to interface IF")

2240

2089

2241

2090

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

2242

2091

syslogger.setFormatter(logging.Formatter

2243

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

2244

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

2245

.format(server_settings

2246

["servicename"])))

2092

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

2093

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

2094

% server_settings["servicename"]))

2247

2095

2248

2096

# Parse config file with clients

2249

client_config = configparser.SafeConfigParser(Client

2250

.client_defaults)

2097

client_config = configparser.SafeConfigParser(Client.client_defaults)

2251

2098

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

2252

2099

"clients.conf"))

2253

2100

2267

2114

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

2268

2115

try:

2269

2116

pidfile = open(pidfilename, "w")

2270

except IOError as e:

2271

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

2272

exc_info=e)

2117

except IOError:

2118

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

2273

2119

2274

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:

2275

2124

try:

2276

uid = pwd.getpwnam(name).pw_uid

2277

gid = pwd.getpwnam(name).pw_gid

2278

break

2125

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

2126

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

2279

2127

except KeyError:

2280

continue

2281

else:

2282

uid = 65534

2283

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

2284

2134

try:

2285

2135

os.setgid(gid)

2286

2136

os.setuid(uid)

2303

2153

.gnutls_global_set_log_function(debug_gnutls))

2304

2154

2305

2155

# Redirect stdin so all checkers get /dev/null

2306

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

2156

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

2307

2157

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

2308

2158

if null > 2:

2309

2159

os.close(null)

2317

2167

2318

2168

global main_loop

2319

2169

# From the Avahi example code

2320

DBusGMainLoop(set_as_default=True)

2170

DBusGMainLoop(set_as_default=True )

2321

2171

main_loop = gobject.MainLoop()

2322

2172

bus = dbus.SystemBus()

2323

2173

# End of Avahi example code

2329

2179

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

2330

2180

do_not_queue=True))

2331

2181

except dbus.exceptions.NameExistsException as e:

2332

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

2182

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

2333

2183

use_dbus = False

2334

2184

server_settings["use_dbus"] = False

2335

2185

tcp_server.use_dbus = False

2347

2197

2348

2198

client_class = Client

2349

2199

if use_dbus:

2350

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

2200

client_class = functools.partial(ClientDBusTransitional,

2201

bus = bus)

2351

2202

2352

2203

client_settings = Client.config_parser(client_config)

2353

2204

old_client_settings = {}

2361

2212

(stored_state))

2362

2213

os.remove(stored_state_path)

2363

2214

except IOError as e:

2364

if e.errno == errno.ENOENT:

2365

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

2366

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

2367

else:

2368

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

2369

exc_info=e)

2215

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

2216

.format(e))

2217

if e.errno != errno.ENOENT:

2370

2218

raise

2371

2219

except EOFError as e:

2372

2220

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

2373

"EOFError:", exc_info=e)

2221

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

2374

2222

2375

2223

with PGPEngine() as pgp:

2376

2224

for client_name, client in clients_data.iteritems():

2393

2241

2394

2242

# Clients who has passed its expire date can still be

2395

2243

# enabled if its last checker was successful. Clients

2396

# whose checker succeeded before we stored its state is

2397

# assumed to have successfully run all checkers during

2398

# downtime.

2244

# whose checker failed before we stored its state is

2245

# assumed to have failed all checkers during downtime.

2399

2246

if client["enabled"]:

2400

2247

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

2401

2248

if not client["last_checked_ok"]:

2402

2249

logger.warning(

2403

2250

"disabling client {0} - Client never "

2404

"performed a successful checker"

2405

.format(client_name))

2251

"performed a successfull checker"

2252

.format(client["name"]))

2406

2253

client["enabled"] = False

2407

2254

elif client["last_checker_status"] != 0:

2408

2255

logger.warning(

2409

2256

"disabling client {0} - Client "

2410

2257

"last checker failed with error code {1}"

2411

.format(client_name,

2258

.format(client["name"],

2412

2259

client["last_checker_status"]))

2413

2260

client["enabled"] = False

2414

2261

else:

2415

2262

client["expires"] = (datetime.datetime

2416

2263

.utcnow()

2417

2264

+ client["timeout"])

2418

logger.debug("Last checker succeeded,"

2419

" keeping {0} enabled"

2420

.format(client_name))

2265

2421

2266

try:

2422

2267

client["secret"] = (

2423

2268

pgp.decrypt(client["encrypted_secret"],

2429

2274

.format(client_name))

2430

2275

client["secret"] = (

2431

2276

client_settings[client_name]["secret"])

2277

2432

2278

2433

2279

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

2434

for client_name in (set(old_client_settings)

2435

- set(client_settings)):

2280

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

2436

2281

del clients_data[client_name]

2437

for client_name in (set(client_settings)

2438

- set(old_client_settings)):

2282

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

2439

2283

clients_data[client_name] = client_settings[client_name]

2440

2441

# Create all client objects

2284

2285

# Create clients all clients

2442

2286

for client_name, client in clients_data.iteritems():

2443

2287

tcp_server.clients[client_name] = client_class(

2444

2288

name = client_name, settings = client)

2445

2289

2446

2290

if not tcp_server.clients:

2447

2291

logger.warning("No clients defined")

2448

2292

2449

2293

if not debug:

2450

2294

try:

2451

2295

with pidfile:

2465

2309

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

2466

2310

2467

2311

if use_dbus:

2468

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

2469

"se.bsnet.fukt.Mandos"})

2470

class MandosDBusService(DBusObjectWithProperties):

2312

class MandosDBusService(dbus.service.Object):

2471

2313

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

2472

2314

def __init__(self):

2473

2315

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

2474

2316

_interface = "se.recompile.Mandos"

2475

2317

2476

@dbus_interface_annotations(_interface)

2477

def _foo(self):

2478

return { "org.freedesktop.DBus.Property"

2479

".EmitsChangedSignal":

2480

"false"}

2481

2482

2318

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

2483

2319

def ClientAdded(self, objpath):

2484

2320

"D-Bus signal"

2526

2362

2527

2363

del _interface

2528

2364

2529

mandos_dbus_service = MandosDBusService()

2365

class MandosDBusServiceTransitional(MandosDBusService):

2366

__metaclass__ = AlternateDBusNamesMetaclass

2367

mandos_dbus_service = MandosDBusServiceTransitional()

2530

2368

2531

2369

def cleanup():

2532

2370

"Cleanup function; run on exit"

2565

2403

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

2566

2404

2567

2405

try:

2568

with (tempfile.NamedTemporaryFile

2569

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

2570

dir=os.path.dirname(stored_state_path),

2571

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:

2572

2411

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

2573

tempname=stored_state.name

2574

2412

os.rename(tempname, stored_state_path)

2575

2413

except (IOError, OSError) as e:

2414

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

2415

.format(e))

2576

2416

if not debug:

2577

2417

try:

2578

2418

os.remove(tempname)

2579

2419

except NameError:

2580

2420

pass

2581

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

2582

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

2583

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

2584

else:

2585

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

2586

exc_info=e)

2421

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

2422

errno.EEXIST)):

2587

2423

raise e

2588

2424

2589

2425

# Delete all clients, and settings from config

2617

2453

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

2618

2454

if use_ipv6:

2619

2455

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

2620

" flowinfo %d, scope_id %d",

2621

*tcp_server.socket.getsockname())

2456

" flowinfo %d, scope_id %d"

2457

% tcp_server.socket.getsockname())

2622

2458

else: # IPv4

2623

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

2624

*tcp_server.socket.getsockname())

2459

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

2460

% tcp_server.socket.getsockname())

2625

2461

2626

2462

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

2627

2463

2630

2466

try:

2631

2467

service.activate()

2632

2468

except dbus.exceptions.DBusException as error:

2633

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

2469

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

2634

2470

cleanup()

2635

2471

sys.exit(1)

2636

2472

# End of Avahi example code

2643

2479

logger.debug("Starting main loop")

2644

2480

main_loop.run()

2645

2481

except AvahiError as error:

2646

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

2482

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

2647

2483

cleanup()

2648

2484

sys.exit(1)

2649

2485

except KeyboardInterrupt: