/mandos/trunk : revision 502

28

# along with this program. If not, see

29

# <http://www.gnu.org/licenses/>.

30

#

31

# Contact the authors at <mandos@recompile.se>.

31

# Contact the authors at <mandos@fukt.bsnet.se>.

32

#

33

34

from __future__ import (division, absolute_import, print_function,

62

import functools

63

import cPickle as pickle

64

import multiprocessing

65

import types

66

import hashlib

67

65

68

66

import dbus

69

67

import dbus.service

74

72

import ctypes.util

75

73

import xml.dom.minidom

76

74

import inspect

77

import Crypto.Cipher.AES

78

75

79

76

try:

80

77

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

85

82

SO_BINDTODEVICE = None

86

83

87

84

88

version = "1.4.1"

89

90

logger = logging.getLogger()

91

stored_state_path = "/var/lib/mandos/clients.pickle"

92

85

version = "1.3.1"

86

87

#logger = logging.getLogger('mandos')

88

logger = logging.Logger('mandos')

93

89

syslogger = (logging.handlers.SysLogHandler

94

90

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

95

91

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

99

95

logger.addHandler(syslogger)

100

96

101

97

console = logging.StreamHandler()

102

console.setFormatter(logging.Formatter('%(asctime)s %(name)s'

103

' [%(process)d]:'

98

console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'

104

99

' %(levelname)s:'

105

100

' %(message)s'))

106

101

logger.addHandler(console)

107

102

108

109

103

class AvahiError(Exception):

110

104

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

111

105

self.value = value

165

159

" after %i retries, exiting.",

166

160

self.rename_count)

167

161

raise AvahiServiceError("Too many renames")

168

self.name = unicode(self.server

169

.GetAlternativeServiceName(self.name))

162

self.name = unicode(self.server.GetAlternativeServiceName(self.name))

170

163

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

171

164

self.name)

165

syslogger.setFormatter(logging.Formatter

166

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

167

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

168

% self.name))

172

169

self.remove()

173

170

try:

174

171

self.add()

194

191

avahi.DBUS_INTERFACE_ENTRY_GROUP)

195

192

self.entry_group_state_changed_match = (

196

193

self.group.connect_to_signal(

197

'StateChanged', self.entry_group_state_changed))

194

'StateChanged', self .entry_group_state_changed))

198

195

logger.debug("Adding Zeroconf service '%s' of type '%s' ...",

199

196

self.name, self.type)

200

197

self.group.AddService(

266

263

self.server_state_changed)

267

264

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

268

265

269

class AvahiServiceToSyslog(AvahiService):

270

def rename(self):

271

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

272

ret = AvahiService.rename(self)

273

syslogger.setFormatter(logging.Formatter

274

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

275

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

276

% self.name))

277

return ret

278

266

279

267

def _timedelta_to_milliseconds(td):

280

268

"Convert a datetime.timedelta() to milliseconds"

299

287

instance %(name)s can be used in the command.

300

288

checker_initiator_tag: a gobject event source tag, or None

301

289

created: datetime.datetime(); (UTC) object creation

302

client_structure: Object describing what attributes a client has

303

and is used for storing the client at exit

304

290

current_checker_command: string; current running checker_command

291

disable_hook: If set, called by disable() as disable_hook(self)

305

292

disable_initiator_tag: a gobject event source tag, or None

306

293

enabled: bool()

307

294

fingerprint: string (40 or 32 hexadecimal digits); used to

310

297

interval: datetime.timedelta(); How often to start a new checker

311

298

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

312

299

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

313

last_checker_status: integer between 0 and 255 reflecting exit

314

status of last checker. -1 reflect crashed

315

checker, or None.

316

300

last_enabled: datetime.datetime(); (UTC)

317

301

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

318

302

D-Bus identifiers

329

313

"created", "enabled", "fingerprint",

330

314

"host", "interval", "last_checked_ok",

331

315

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

332

316

333

317

def timeout_milliseconds(self):

334

318

"Return the 'timeout' attribute in milliseconds"

335

319

return _timedelta_to_milliseconds(self.timeout)

336

320

337

321

def extended_timeout_milliseconds(self):

338

322

"Return the 'extended_timeout' attribute in milliseconds"

339

return _timedelta_to_milliseconds(self.extended_timeout)

323

return _timedelta_to_milliseconds(self.extended_timeout)

340

324

341

325

def interval_milliseconds(self):

342

326

"Return the 'interval' attribute in milliseconds"

343

327

return _timedelta_to_milliseconds(self.interval)

344

328

345

329

def approval_delay_milliseconds(self):

346

330

return _timedelta_to_milliseconds(self.approval_delay)

347

331

348

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

332

def __init__(self, name = None, disable_hook=None, config=None):

349

333

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

350

334

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

351

335

attribute."""

371

355

% self.name)

372

356

self.host = config.get("host", "")

373

357

self.created = datetime.datetime.utcnow()

374

self.enabled = True

358

self.enabled = False

375

359

self.last_approval_request = None

376

self.last_enabled = datetime.datetime.utcnow()

360

self.last_enabled = None

377

361

self.last_checked_ok = None

378

self.last_checker_status = None

379

362

self.timeout = string_to_delta(config["timeout"])

380

self.extended_timeout = string_to_delta(config

381

["extended_timeout"])

363

self.extended_timeout = string_to_delta(config["extended_timeout"])

382

364

self.interval = string_to_delta(config["interval"])

365

self.disable_hook = disable_hook

383

366

self.checker = None

384

367

self.checker_initiator_tag = None

385

368

self.disable_initiator_tag = None

386

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

369

self.expires = None

387

370

self.checker_callback_tag = None

388

371

self.checker_command = config["checker"]

389

372

self.current_checker_command = None

373

self.last_connect = None

390

374

self._approved = None

391

375

self.approved_by_default = config.get("approved_by_default",

392

376

True)

395

379

config["approval_delay"])

396

380

self.approval_duration = string_to_delta(

397

381

config["approval_duration"])

398

self.changedstate = (multiprocessing_manager

399

.Condition(multiprocessing_manager

400

.Lock()))

401

self.client_structure = [attr for attr

402

in self.__dict__.iterkeys()

403

if not attr.startswith("_")]

404

self.client_structure.append("client_structure")

405

406

407

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

408

lambda obj:

409

isinstance(obj,

410

property)):

411

if not name.startswith("_"):

412

self.client_structure.append(name)

382

self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())

413

383

414

# Send notice to process children that client state has changed

415

384

def send_changedstate(self):

416

with self.changedstate:

417

self.changedstate.notify_all()

418

385

self.changedstate.acquire()

386

self.changedstate.notify_all()

387

self.changedstate.release()

388

419

389

def enable(self):

420

390

"""Start this client's checker and timeout hooks"""

421

391

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

422

392

# Already enabled

423

393

return

424

394

self.send_changedstate()

395

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

396

# and every interval from then on.

397

self.checker_initiator_tag = (gobject.timeout_add

398

(self.interval_milliseconds(),

399

self.start_checker))

400

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

425

401

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

402

self.disable_initiator_tag = (gobject.timeout_add

403

(self.timeout_milliseconds(),

404

self.disable))

426

405

self.enabled = True

427

406

self.last_enabled = datetime.datetime.utcnow()

428

self.init_checker()

407

# Also start a new checker *right now*.

408

self.start_checker()

429

409

430

410

def disable(self, quiet=True):

431

411

"""Disable this client."""

443

423

gobject.source_remove(self.checker_initiator_tag)

444

424

self.checker_initiator_tag = None

445

425

self.stop_checker()

426

if self.disable_hook:

427

self.disable_hook(self)

446

428

self.enabled = False

447

429

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

448

430

return False

449

431

450

432

def __del__(self):

433

self.disable_hook = None

451

434

self.disable()

452

453

def init_checker(self):

454

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

455

# and every interval from then on.

456

self.checker_initiator_tag = (gobject.timeout_add

457

(self.interval_milliseconds(),

458

self.start_checker))

459

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

460

self.disable_initiator_tag = (gobject.timeout_add

461

(self.timeout_milliseconds(),

462

self.disable))

463

# Also start a new checker *right now*.

464

self.start_checker()

465

466

435

467

436

def checker_callback(self, pid, condition, command):

468

437

"""The checker has completed, so take appropriate actions."""

469

438

self.checker_callback_tag = None

470

439

self.checker = None

471

440

if os.WIFEXITED(condition):

472

self.last_checker_status = os.WEXITSTATUS(condition)

473

if self.last_checker_status == 0:

441

exitstatus = os.WEXITSTATUS(condition)

442

if exitstatus == 0:

474

443

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

475

444

vars(self))

476

445

self.checked_ok()

478

447

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

479

448

vars(self))

480

449

else:

481

self.last_checker_status = -1

482

450

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

483

451

vars(self))

484

452

491

459

if timeout is None:

492

460

timeout = self.timeout

493

461

self.last_checked_ok = datetime.datetime.utcnow()

494

if self.disable_initiator_tag is not None:

495

gobject.source_remove(self.disable_initiator_tag)

496

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

497

self.disable_initiator_tag = (gobject.timeout_add

498

(_timedelta_to_milliseconds

499

(timeout), self.disable))

500

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

462

gobject.source_remove(self.disable_initiator_tag)

463

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

464

self.disable_initiator_tag = (gobject.timeout_add

465

(_timedelta_to_milliseconds(timeout),

466

self.disable))

501

467

502

468

def need_approval(self):

503

469

self.last_approval_request = datetime.datetime.utcnow()

543

509

'replace')))

544

510

for attr in

545

511

self.runtime_expansions)

546

512

547

513

try:

548

514

command = self.checker_command % escaped_attrs

549

515

except TypeError as error:

595

561

raise

596

562

self.checker = None

597

563

598

# Encrypts a client secret and stores it in a varible

599

# encrypted_secret

600

def encrypt_secret(self, key):

601

# Encryption-key need to be of a specific size, so we hash

602

# supplied key

603

hasheng = hashlib.sha256()

604

hasheng.update(key)

605

encryptionkey = hasheng.digest()

606

607

# Create validation hash so we know at decryption if it was

608

# sucessful

609

hasheng = hashlib.sha256()

610

hasheng.update(self.secret)

611

validationhash = hasheng.digest()

612

613

# Encrypt secret

614

iv = os.urandom(Crypto.Cipher.AES.block_size)

615

ciphereng = Crypto.Cipher.AES.new(encryptionkey,

616

Crypto.Cipher.AES.MODE_CFB, iv)

617

ciphertext = ciphereng.encrypt(validationhash+self.secret)

618

self.encrypted_secret = (ciphertext, iv)

619

620

# Decrypt a encrypted client secret

621

def decrypt_secret(self, key):

622

# Decryption-key need to be of a specific size, so we hash

623

# supplied key

624

hasheng = hashlib.sha256()

625

hasheng.update(key)

626

encryptionkey = hasheng.digest()

627

628

# Decrypt encrypted secret

629

ciphertext, iv = self.encrypted_secret

630

ciphereng = Crypto.Cipher.AES.new(encryptionkey,

631

Crypto.Cipher.AES.MODE_CFB, iv)

632

plain = ciphereng.decrypt(ciphertext)

633

634

# Validate decrypted secret to know if it was succesful

635

hasheng = hashlib.sha256()

636

validationhash = plain[:hasheng.digest_size]

637

secret = plain[hasheng.digest_size:]

638

hasheng.update(secret)

639

640

# If validation fails, we use key as new secret. Otherwise, we

641

# use the decrypted secret

642

if hasheng.digest() == validationhash:

643

self.secret = secret

644

else:

645

self.secret = key

646

del self.encrypted_secret

647

648

649

564

def dbus_service_property(dbus_interface, signature="v",

650

565

access="readwrite", byte_arrays=False):

651

566

"""Decorators for marking methods of a DBusObjectWithProperties to

697

612

698

613

class DBusObjectWithProperties(dbus.service.Object):

699

614

"""A D-Bus object with properties.

700

615

701

616

Classes inheriting from this can use the dbus_service_property

702

617

decorator to expose methods as D-Bus properties. It exposes the

703

618

standard Get(), Set(), and GetAll() methods on the D-Bus.

710

625

def _get_all_dbus_properties(self):

711

626

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

712

627

"""

713

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

714

for cls in self.__class__.__mro__

628

return ((prop._dbus_name, prop)

715

629

for name, prop in

716

inspect.getmembers(cls, self._is_dbus_property))

630

inspect.getmembers(self, self._is_dbus_property))

717

631

718

632

def _get_dbus_property(self, interface_name, property_name):

719

633

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

720

634

property with the specified name and interface.

721

635

"""

722

for cls in self.__class__.__mro__:

723

for name, value in (inspect.getmembers

724

(cls, self._is_dbus_property)):

725

if (value._dbus_name == property_name

726

and value._dbus_interface == interface_name):

727

return value.__get__(self)

728

636

for name in (property_name,

637

property_name + "_dbus_property"):

638

prop = getattr(self, name, None)

639

if (prop is None

640

or not self._is_dbus_property(prop)

641

or prop._dbus_name != property_name

642

or (interface_name and prop._dbus_interface

643

and interface_name != prop._dbus_interface)):

644

continue

645

return prop

729

646

# No such property

730

647

raise DBusPropertyNotFound(self.dbus_object_path + ":"

731

648

+ interface_name + "."

765

682

def GetAll(self, interface_name):

766

683

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

767

684

standard.

768

685

769

686

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

770

687

"""

771

688

all = {}

840

757

return dbus.String(dt.isoformat(),

841

758

variant_level=variant_level)

842

759

843

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

844

.__metaclass__):

845

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

846

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

847

"""

848

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

849

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

850

# methods, signals, or properties in them

851

for base in (b for b in bases

852

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

853

# Go though all attributes of the base class

854

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

855

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

856

# with the wrong interface name

857

if (not hasattr(attribute, "_dbus_interface")

858

or not attribute._dbus_interface

859

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

860

continue

861

# Create an alternate D-Bus interface name based on

862

# the current name

863

alt_interface = (attribute._dbus_interface

864

.replace("se.recompile.Mandos",

865

"se.bsnet.fukt.Mandos"))

866

# Is this a D-Bus signal?

867

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

868

# Extract the original non-method function by

869

# black magic

870

nonmethod_func = (dict(

871

zip(attribute.func_code.co_freevars,

872

attribute.__closure__))["func"]

873

.cell_contents)

874

# Create a new, but exactly alike, function

875

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

876

# with the alternate D-Bus interface name

877

new_function = (dbus.service.signal

878

(alt_interface,

879

attribute._dbus_signature)

880

(types.FunctionType(

881

nonmethod_func.func_code,

882

nonmethod_func.func_globals,

883

nonmethod_func.func_name,

884

nonmethod_func.func_defaults,

885

nonmethod_func.func_closure)))

886

# Define a creator of a function to call both the

887

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

888

# signals gets sent when the function is called

889

def fixscope(func1, func2):

890

"""This function is a scope container to pass

891

func1 and func2 to the "call_both" function

892

outside of its arguments"""

893

def call_both(*args, **kwargs):

894

"""This function will emit two D-Bus

895

signals by calling func1 and func2"""

896

func1(*args, **kwargs)

897

func2(*args, **kwargs)

898

return call_both

899

# Create the "call_both" function and add it to

900

# the class

901

attr[attrname] = fixscope(attribute,

902

new_function)

903

# Is this a D-Bus method?

904

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

905

# Create a new, but exactly alike, function

906

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

907

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

908

# to the class.

909

attr[attrname] = (dbus.service.method

910

(alt_interface,

911

attribute._dbus_in_signature,

912

attribute._dbus_out_signature)

913

(types.FunctionType

914

(attribute.func_code,

915

attribute.func_globals,

916

attribute.func_name,

917

attribute.func_defaults,

918

attribute.func_closure)))

919

# Is this a D-Bus property?

920

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

921

# Create a new, but exactly alike, function

922

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

923

# property with the alternate D-Bus interface

924

# name. Add it to the class.

925

attr[attrname] = (dbus_service_property

926

(alt_interface,

927

attribute._dbus_signature,

928

attribute._dbus_access,

929

attribute

930

._dbus_get_args_options

931

["byte_arrays"])

932

(types.FunctionType

933

(attribute.func_code,

934

attribute.func_globals,

935

attribute.func_name,

936

attribute.func_defaults,

937

attribute.func_closure)))

938

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

939

940

760

class ClientDBus(Client, DBusObjectWithProperties):

941

761

"""A Client class using D-Bus

942

762

951

771

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

952

772

953

773

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

954

self.bus = bus

955

774

self._approvals_pending = 0

775

self.bus = bus

956

776

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

957

self.add_to_dbus()

958

959

def add_to_dbus(self):

960

777

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

961

778

# the D-Bus

962

779

client_object_name = unicode(self.name).translate(

970

787

def notifychangeproperty(transform_func,

971

788

dbus_name, type_func=lambda x: x,

972

789

variant_level=1):

973

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

974

its changes to DBus.

975

976

transform_fun: Function that takes a value and a variant_level

977

and transforms it to a D-Bus type.

978

dbus_name: D-Bus name of the variable

790

""" Modify a variable so that its a property that announce its

791

changes to DBus.

792

transform_fun: Function that takes a value and transform it to

793

DBus type.

794

dbus_name: DBus name of the variable

979

795

type_func: Function that transform the value before sending it

980

to the D-Bus. Default: no transform

981

variant_level: D-Bus variant level. Default: 1

796

to DBus

797

variant_level: DBus variant level. default: 1

982

798

"""

983

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

799

real_value = [None,]

984

800

def setter(self, value):

801

old_value = real_value[0]

802

real_value[0] = value

985

803

if hasattr(self, "dbus_object_path"):

986

if (not hasattr(self, attrname) or

987

type_func(getattr(self, attrname, None))

988

!= type_func(value)):

989

dbus_value = transform_func(type_func(value),

990

variant_level

991

=variant_level)

804

if type_func(old_value) != type_func(real_value[0]):

805

dbus_value = transform_func(type_func(real_value[0]),

806

variant_level)

992

807

self.PropertyChanged(dbus.String(dbus_name),

993

808

dbus_value)

994

setattr(self, attrname, value)

995

996

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

997

998

809

810

return property(lambda self: real_value[0], setter)

811

812

999

813

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1000

814

approvals_pending = notifychangeproperty(dbus.Boolean,

1001

815

"ApprovalPending",

1004

818

last_enabled = notifychangeproperty(datetime_to_dbus,

1005

819

"LastEnabled")

1006

820

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

1007

type_func = lambda checker:

1008

checker is not None)

821

type_func = lambda checker: checker is not None)

1009

822

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1010

823

"LastCheckedOK")

1011

last_approval_request = notifychangeproperty(

1012

datetime_to_dbus, "LastApprovalRequest")

824

last_approval_request = notifychangeproperty(datetime_to_dbus,

825

"LastApprovalRequest")

1013

826

approved_by_default = notifychangeproperty(dbus.Boolean,

1014

827

"ApprovedByDefault")

1015

approval_delay = notifychangeproperty(dbus.UInt16,

1016

"ApprovalDelay",

1017

type_func =

1018

_timedelta_to_milliseconds)

1019

approval_duration = notifychangeproperty(

1020

dbus.UInt16, "ApprovalDuration",

1021

type_func = _timedelta_to_milliseconds)

828

approval_delay = notifychangeproperty(dbus.UInt16, "ApprovalDelay",

829

type_func = _timedelta_to_milliseconds)

830

approval_duration = notifychangeproperty(dbus.UInt16, "ApprovalDuration",

831

type_func = _timedelta_to_milliseconds)

1022

832

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

1023

833

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

1024

type_func =

1025

_timedelta_to_milliseconds)

1026

extended_timeout = notifychangeproperty(

1027

dbus.UInt16, "ExtendedTimeout",

1028

type_func = _timedelta_to_milliseconds)

1029

interval = notifychangeproperty(dbus.UInt16,

1030

"Interval",

1031

type_func =

1032

_timedelta_to_milliseconds)

834

type_func = _timedelta_to_milliseconds)

835

extended_timeout = notifychangeproperty(dbus.UInt16, "ExtendedTimeout",

836

type_func = _timedelta_to_milliseconds)

837

interval = notifychangeproperty(dbus.UInt16, "Interval",

838

type_func = _timedelta_to_milliseconds)

1033

839

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

1034

840

1035

841

del notifychangeproperty

1061

867

1062

868

return Client.checker_callback(self, pid, condition, command,

1063

869

*args, **kwargs)

1064

870

1065

871

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

1066

872

old_checker = self.checker

1067

873

if self.checker is not None:

1089

895

1090

896

1091

897

## D-Bus methods, signals & properties

1092

_interface = "se.recompile.Mandos.Client"

898

_interface = "se.bsnet.fukt.Mandos.Client"

1093

899

1094

900

## Signals

1095

901

1270

1076

gobject.source_remove(self.disable_initiator_tag)

1271

1077

self.disable_initiator_tag = None

1272

1078

self.expires = None

1273

time_to_die = _timedelta_to_milliseconds((self

1274

.last_checked_ok

1275

+ self.timeout)

1276

- datetime.datetime

1277

.utcnow())

1079

time_to_die = (self.

1080

_timedelta_to_milliseconds((self

1081

.last_checked_ok

1082

+ self.timeout)

1083

- datetime.datetime

1084

.utcnow()))

1278

1085

if time_to_die <= 0:

1279

1086

# The timeout has passed

1280

1087

self.disable()

1281

1088

else:

1282

1089

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

1283

+ datetime.timedelta(milliseconds =

1284

time_to_die))

1090

+ datetime.timedelta(milliseconds = time_to_die))

1285

1091

self.disable_initiator_tag = (gobject.timeout_add

1286

1092

(time_to_die, self.disable))

1287

1093

1288

1094

# ExtendedTimeout - property

1289

1095

@dbus_service_property(_interface, signature="t",

1290

1096

access="readwrite")

1292

1098

if value is None: # get

1293

1099

return dbus.UInt64(self.extended_timeout_milliseconds())

1294

1100

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

1295

1101

1296

1102

# Interval - property

1297

1103

@dbus_service_property(_interface, signature="t",

1298

1104

access="readwrite")

1307

1113

self.checker_initiator_tag = (gobject.timeout_add

1308

1114

(value, self.start_checker))

1309

1115

self.start_checker() # Start one now, too

1310

1116

1311

1117

# Checker - property

1312

1118

@dbus_service_property(_interface, signature="s",

1313

1119

access="readwrite")

1347

1153

self._pipe.send(('init', fpr, address))

1348

1154

if not self._pipe.recv():

1349

1155

raise KeyError()

1350

1156

1351

1157

def __getattribute__(self, name):

1352

1158

if(name == '_pipe'):

1353

1159

return super(ProxyClient, self).__getattribute__(name)

1360

1166

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

1361

1167

return self._pipe.recv()[1]

1362

1168

return func

1363

1169

1364

1170

def __setattr__(self, name, value):

1365

1171

if(name == '_pipe'):

1366

1172

return super(ProxyClient, self).__setattr__(name, value)

1367

1173

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

1368

1174

1369

class ClientDBusTransitional(ClientDBus):

1370

__metaclass__ = AlternateDBusNamesMetaclass

1371

1175

1372

1176

class ClientHandler(socketserver.BaseRequestHandler, object):

1373

1177

"""A class to handle client connections.

1381

1185

unicode(self.client_address))

1382

1186

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

1383

1187

self.server.child_pipe.fileno())

1384

1188

1385

1189

session = (gnutls.connection

1386

1190

.ClientSession(self.request,

1387

1191

gnutls.connection

1388

1192

.X509Credentials()))

1389

1193

1390

1194

# Note: gnutls.connection.X509Credentials is really a

1391

1195

# generic GnuTLS certificate credentials object so long as

1392

1196

# no X.509 keys are added to it. Therefore, we can use it

1393

1197

# here despite using OpenPGP certificates.

1394

1198

1395

1199

#priority = ':'.join(("NONE", "+VERS-TLS1.1",

1396

1200

# "+AES-256-CBC", "+SHA1",

1397

1201

# "+COMP-NULL", "+CTYPE-OPENPGP",

1403

1207

(gnutls.library.functions

1404

1208

.gnutls_priority_set_direct(session._c_object,

1405

1209

priority, None))

1406

1210

1407

1211

# Start communication using the Mandos protocol

1408

1212

# Get protocol number

1409

1213

line = self.request.makefile().readline()

1414

1218

except (ValueError, IndexError, RuntimeError) as error:

1415

1219

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

1416

1220

return

1417

1221

1418

1222

# Start GnuTLS connection

1419

1223

try:

1420

1224

session.handshake()

1424

1228

# established. Just abandon the request.

1425

1229

return

1426

1230

logger.debug("Handshake succeeded")

1427

1231

1428

1232

approval_required = False

1429

1233

try:

1430

1234

try:

1435

1239

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

1436

1240

return

1437

1241

logger.debug("Fingerprint: %s", fpr)

1438

1242

1439

1243

try:

1440

1244

client = ProxyClient(child_pipe, fpr,

1441

1245

self.client_address)

1453

1257

client.name)

1454

1258

if self.server.use_dbus:

1455

1259

# Emit D-Bus signal

1456

client.Rejected("Disabled")

1260

client.Rejected("Disabled")

1457

1261

return

1458

1262

1459

1263

if client._approved or not client.approval_delay:

1476

1280

return

1477

1281

1478

1282

#wait until timeout or approved

1283

#x = float(client._timedelta_to_milliseconds(delay))

1479

1284

time = datetime.datetime.now()

1480

1285

client.changedstate.acquire()

1481

(client.changedstate.wait

1482

(float(client._timedelta_to_milliseconds(delay)

1483

/ 1000)))

1286

client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))

1484

1287

client.changedstate.release()

1485

1288

time2 = datetime.datetime.now()

1486

1289

if (time2 - time) >= delay:

1508

1311

sent, len(client.secret)

1509

1312

- (sent_size + sent))

1510

1313

sent_size += sent

1511

1314

1512

1315

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

1513

# bump the timeout using extended_timeout

1316

# bump the timeout as if seen

1514

1317

client.checked_ok(client.extended_timeout)

1515

1318

if self.server.use_dbus:

1516

1319

# Emit D-Bus signal

1596

1399

except:

1597

1400

self.handle_error(request, address)

1598

1401

self.close_request(request)

1599

1402

1600

1403

def process_request(self, request, address):

1601

1404

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

1602

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

1603

args = (request,

1604

address))

1605

proc.start()

1606

return proc

1607

1405

multiprocessing.Process(target = self.sub_process_main,

1406

args = (request, address)).start()

1608

1407

1609

1408

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1610

1409

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

1614

1413

This function creates a new pipe in self.pipe

1615

1414

"""

1616

1415

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1617

1618

proc = MultiprocessingMixIn.process_request(self, request,

1619

client_address)

1416

1417

super(MultiprocessingMixInWithPipe,

1418

self).process_request(request, client_address)

1620

1419

self.child_pipe.close()

1621

self.add_pipe(parent_pipe, proc)

1622

1623

def add_pipe(self, parent_pipe, proc):

1420

self.add_pipe(parent_pipe)

1421

1422

def add_pipe(self, parent_pipe):

1624

1423

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

1625

1424

raise NotImplementedError

1626

1425

1627

1628

1426

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1629

1427

socketserver.TCPServer, object):

1630

1428

"""IPv6-capable TCP server. Accepts 'None' as address and/or port

1704

1502

self.enabled = False

1705

1503

self.clients = clients

1706

1504

if self.clients is None:

1707

self.clients = {}

1505

self.clients = set()

1708

1506

self.use_dbus = use_dbus

1709

1507

self.gnutls_priority = gnutls_priority

1710

1508

IPv6_TCPServer.__init__(self, server_address,

1714

1512

def server_activate(self):

1715

1513

if self.enabled:

1716

1514

return socketserver.TCPServer.server_activate(self)

1717

1718

1515

def enable(self):

1719

1516

self.enabled = True

1720

1721

def add_pipe(self, parent_pipe, proc):

1517

def add_pipe(self, parent_pipe):

1722

1518

# Call "handle_ipc" for both data and EOF events

1723

1519

gobject.io_add_watch(parent_pipe.fileno(),

1724

1520

gobject.IO_IN | gobject.IO_HUP,

1725

1521

functools.partial(self.handle_ipc,

1726

parent_pipe =

1727

parent_pipe,

1728

proc = proc))

1729

1522

parent_pipe = parent_pipe))

1523

1730

1524

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

1731

proc = None, client_object=None):

1525

client_object=None):

1732

1526

condition_names = {

1733

1527

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

1734

1528

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

1743

1537

for cond, name in

1744

1538

condition_names.iteritems()

1745

1539

if cond & condition)

1746

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

1540

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

1747

1541

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

1748

# Wait for other process to exit

1749

proc.join()

1750

1542

return False

1751

1543

1752

1544

# Read a request from the child

1757

1549

fpr = request[1]

1758

1550

address = request[2]

1759

1551

1760

for c in self.clients.itervalues():

1552

for c in self.clients:

1761

1553

if c.fingerprint == fpr:

1762

1554

client = c

1763

1555

break

1766

1558

"dress: %s", fpr, address)

1767

1559

if self.use_dbus:

1768

1560

# Emit D-Bus signal

1769

mandos_dbus_service.ClientNotFound(fpr,

1770

address[0])

1561

mandos_dbus_service.ClientNotFound(fpr, address[0])

1771

1562

parent_pipe.send(False)

1772

1563

return False

1773

1564

1774

1565

gobject.io_add_watch(parent_pipe.fileno(),

1775

1566

gobject.IO_IN | gobject.IO_HUP,

1776

1567

functools.partial(self.handle_ipc,

1777

parent_pipe =

1778

parent_pipe,

1779

proc = proc,

1780

client_object =

1781

client))

1568

parent_pipe = parent_pipe,

1569

client_object = client))

1782

1570

parent_pipe.send(True)

1783

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

1784

# same fileno

1571

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

1785

1572

return False

1786

1573

if command == 'funcall':

1787

1574

funcname = request[1]

1788

1575

args = request[2]

1789

1576

kwargs = request[3]

1790

1577

1791

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

1792

funcname)(*args,

1793

**kwargs)))

1794

1578

parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))

1579

1795

1580

if command == 'getattr':

1796

1581

attrname = request[1]

1797

1582

if callable(client_object.__getattribute__(attrname)):

1798

1583

parent_pipe.send(('function',))

1799

1584

else:

1800

parent_pipe.send(('data', client_object

1801

.__getattribute__(attrname)))

1585

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

1802

1586

1803

1587

if command == 'setattr':

1804

1588

attrname = request[1]

1805

1589

value = request[2]

1806

1590

setattr(client_object, attrname, value)

1807

1591

1808

1592

return True

1809

1593

1810

1594

1931

1715

" system bus interface")

1932

1716

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

1933

1717

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

1934

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

1935

dest="restore",

1936

help="Do not restore stored state",

1937

default=True)

1938

1939

1718

options = parser.parse_args()

1940

1719

1941

1720

if options.check:

1976

1755

# options, if set.

1977

1756

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

1978

1757

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

1979

"use_dbus", "use_ipv6", "debuglevel", "restore"):

1758

"use_dbus", "use_ipv6", "debuglevel"):

1980

1759

value = getattr(options, option)

1981

1760

if value is not None:

1982

1761

server_settings[option] = value

1994

1773

debuglevel = server_settings["debuglevel"]

1995

1774

use_dbus = server_settings["use_dbus"]

1996

1775

use_ipv6 = server_settings["use_ipv6"]

1997

1776

1998

1777

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

1999

1778

syslogger.setFormatter(logging.Formatter

2000

1779

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

2055

1834

raise error

2056

1835

2057

1836

if not debug and not debuglevel:

2058

logger.setLevel(logging.WARNING)

1837

syslogger.setLevel(logging.WARNING)

1838

console.setLevel(logging.WARNING)

2059

1839

if debuglevel:

2060

1840

level = getattr(logging, debuglevel.upper())

2061

logger.setLevel(level)

2062

1841

syslogger.setLevel(level)

1842

console.setLevel(level)

1843

2063

1844

if debug:

2064

logger.setLevel(logging.DEBUG)

2065

1845

# Enable all possible GnuTLS debugging

2066

1846

2067

1847

# "Use a log level over 10 to enable all debugging options."

2097

1877

# End of Avahi example code

2098

1878

if use_dbus:

2099

1879

try:

2100

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

1880

bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",

2101

1881

bus, do_not_queue=True)

2102

old_bus_name = (dbus.service.BusName

2103

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

2104

do_not_queue=True))

2105

1882

except dbus.exceptions.NameExistsException as e:

2106

1883

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

2107

1884

use_dbus = False

2108

1885

server_settings["use_dbus"] = False

2109

1886

tcp_server.use_dbus = False

2110

1887

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2111

service = AvahiServiceToSyslog(name =

2112

server_settings["servicename"],

2113

servicetype = "_mandos._tcp",

2114

protocol = protocol, bus = bus)

1888

service = AvahiService(name = server_settings["servicename"],

1889

servicetype = "_mandos._tcp",

1890

protocol = protocol, bus = bus)

2115

1891

if server_settings["interface"]:

2116

1892

service.interface = (if_nametoindex

2117

1893

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

2121

1897

2122

1898

client_class = Client

2123

1899

if use_dbus:

2124

client_class = functools.partial(ClientDBusTransitional,

2125

bus = bus)

2126

2127

special_settings = {

2128

# Some settings need to be accessd by special methods;

2129

# booleans need .getboolean(), etc. Here is a list of them:

2130

"approved_by_default":

2131

lambda section:

2132

client_config.getboolean(section, "approved_by_default"),

2133

}

2134

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

2135

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

2136

# with exceptions for any special settings as defined above

2137

client_settings = dict((clientname,

2138

dict((setting,

2139

(value if

2140

setting not in special_settings

2141

else special_settings[setting]

2142

(clientname)))

2143

for setting, value

2144

in client_config.items(clientname)))

2145

for clientname in client_config.sections())

2146

2147

old_client_settings = {}

2148

clients_data = []

2149

2150

# Get client data and settings from last running state.

2151

if server_settings["restore"]:

2152

try:

2153

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

2154

clients_data, old_client_settings = (

2155

pickle.load(stored_state))

2156

os.remove(stored_state_path)

2157

except IOError as e:

2158

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

2159

.format(e))

2160

if e.errno != errno.ENOENT:

2161

raise

2162

2163

for client in clients_data:

2164

client_name = client["name"]

2165

2166

# Decide which value to use after restoring saved state.

2167

# We have three different values: Old config file,

2168

# new config file, and saved state.

2169

# New config value takes precedence if it differs from old

2170

# config value, otherwise use saved state.

2171

for name, value in client_settings[client_name].items():

1900

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

1901

def client_config_items(config, section):

1902

special_settings = {

1903

"approved_by_default":

1904

lambda: config.getboolean(section,

1905

"approved_by_default"),

1906

}

1907

for name, value in config.items(section):

2172

1908

try:

2173

# For each value in new config, check if it differs

2174

# from the old config value (Except for the "secret"

2175

# attribute)

2176

if (name != "secret" and

2177

value != old_client_settings[client_name][name]):

2178

setattr(client, name, value)

1909

yield (name, special_settings[name]())

2179

1910

except KeyError:

2180

pass

2181

2182

# Clients who has passed its expire date, can still be enabled

2183

# if its last checker was sucessful. Clients who checkers

2184

# failed before we stored it state is asumed to had failed

2185

# checker during downtime.

2186

if client["enabled"] and client["last_checked_ok"]:

2187

if ((datetime.datetime.utcnow()

2188

- client["last_checked_ok"]) > client["interval"]):

2189

if client["last_checker_status"] != 0:

2190

client["enabled"] = False

2191

else:

2192

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

2193

+ client["timeout"])

2194

2195

client["changedstate"] = (multiprocessing_manager

2196

.Condition(multiprocessing_manager

2197

.Lock()))

2198

if use_dbus:

2199

new_client = ClientDBusTransitional.__new__(

2200

ClientDBusTransitional)

2201

tcp_server.clients[client_name] = new_client

2202

new_client.bus = bus

2203

for name, value in client.iteritems():

2204

setattr(new_client, name, value)

2205

new_client._approvals_pending = 0

2206

new_client.add_to_dbus()

2207

else:

2208

tcp_server.clients[client_name] = Client.__new__(Client)

2209

for name, value in client.iteritems():

2210

setattr(tcp_server.clients[client_name], name, value)

2211

2212

tcp_server.clients[client_name].decrypt_secret(

2213

client_settings[client_name]["secret"])

2214

2215

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

2216

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

2217

del tcp_server.clients[clientname]

2218

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

2219

tcp_server.clients[clientname] = client_class(name

2220

= clientname,

2221

config =

2222

client_settings

2223

[clientname])

1911

yield (name, value)

2224

1912

1913

tcp_server.clients.update(set(

1914

client_class(name = section,

1915

config= dict(client_config_items(

1916

client_config, section)))

1917

for section in client_config.sections()))

2225

1918

if not tcp_server.clients:

2226

1919

logger.warning("No clients defined")

2227

1920

2240

1933

del pidfilename

2241

1934

2242

1935

signal.signal(signal.SIGINT, signal.SIG_IGN)

2243

1936

2244

1937

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

2245

1938

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

2246

1939

2249

1942

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

2250

1943

def __init__(self):

2251

1944

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

2252

_interface = "se.recompile.Mandos"

1945

_interface = "se.bsnet.fukt.Mandos"

2253

1946

2254

1947

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

2255

1948

def ClientAdded(self, objpath):

2270

1963

def GetAllClients(self):

2271

1964

"D-Bus method"

2272

1965

return dbus.Array(c.dbus_object_path

2273

for c in

2274

tcp_server.clients.itervalues())

1966

for c in tcp_server.clients)

2275

1967

2276

1968

@dbus.service.method(_interface,

2277

1969

out_signature="a{oa{sv}}")

2279

1971

"D-Bus method"

2280

1972

return dbus.Dictionary(

2281

1973

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

2282

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

1974

for c in tcp_server.clients),

2283

1975

signature="oa{sv}")

2284

1976

2285

1977

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

2286

1978

def RemoveClient(self, object_path):

2287

1979

"D-Bus method"

2288

for c in tcp_server.clients.itervalues():

1980

for c in tcp_server.clients:

2289

1981

if c.dbus_object_path == object_path:

2290

del tcp_server.clients[c.name]

1982

tcp_server.clients.remove(c)

2291

1983

c.remove_from_connection()

2292

1984

# Don't signal anything except ClientRemoved

2293

1985

c.disable(quiet=True)

2298

1990

2299

1991

del _interface

2300

1992

2301

class MandosDBusServiceTransitional(MandosDBusService):

2302

__metaclass__ = AlternateDBusNamesMetaclass

2303

mandos_dbus_service = MandosDBusServiceTransitional()

1993

mandos_dbus_service = MandosDBusService()

2304

1994

2305

1995

def cleanup():

2306

1996

"Cleanup function; run on exit"

2307

1997

service.cleanup()

2308

1998

2309

multiprocessing.active_children()

2310

if not (tcp_server.clients or client_settings):

2311

return

2312

2313

# Store client before exiting. Secrets are encrypted with key

2314

# based on what config file has. If config file is

2315

# removed/edited, old secret will thus be unrecovable.

2316

clients = []

2317

for client in tcp_server.clients.itervalues():

2318

client.encrypt_secret(

2319

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

2320

2321

client_dict = {}

2322

2323

# A list of attributes that will not be stored when

2324

# shutting down.

2325

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

2326

for name, typ in inspect.getmembers(dbus.service.Object):

2327

exclude.add(name)

2328

2329

client_dict["encrypted_secret"] = client.encrypted_secret

2330

for attr in client.client_structure:

2331

if attr not in exclude:

2332

client_dict[attr] = getattr(client, attr)

2333

2334

clients.append(client_dict)

2335

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

2336

2337

try:

2338

with os.fdopen(os.open(stored_state_path,

2339

os.O_CREAT|os.O_WRONLY|os.O_TRUNC,

2340

stat.S_IRUSR | stat.S_IWUSR),

2341

"wb") as stored_state:

2342

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

2343

except IOError as e:

2344

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

2345

.format(e))

2346

if e.errno != errno.ENOENT:

2347

raise

2348

2349

# Delete all clients, and settings from config

2350

1999

while tcp_server.clients:

2351

name, client = tcp_server.clients.popitem()

2000

client = tcp_server.clients.pop()

2352

2001

if use_dbus:

2353

2002

client.remove_from_connection()

2003

client.disable_hook = None

2354

2004

# Don't signal anything except ClientRemoved

2355

2005

client.disable(quiet=True)

2356

2006

if use_dbus:

2357

2007

# Emit D-Bus signal

2358

mandos_dbus_service.ClientRemoved(client

2359

.dbus_object_path,

2008

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2360

2009

client.name)

2361

client_settings.clear()

2362

2010

2363

2011

atexit.register(cleanup)

2364

2012

2365

for client in tcp_server.clients.itervalues():

2013

for client in tcp_server.clients:

2366

2014

if use_dbus:

2367

2015

# Emit D-Bus signal

2368

2016

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2369

# Need to initiate checking of clients

2370

if client.enabled:

2371

client.init_checker()

2372

2017

client.enable()

2373

2018

2374

2019

tcp_server.enable()

2375

2020

tcp_server.server_activate()

2415

2060

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

2416

2061

cleanup()

2417

2062

2418

2419

2063

if __name__ == '__main__':

2420

2064

main()