/mandos/trunk : revision 603

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

37

39

import SocketServer as socketserver

38

40

import socket

39

41

import argparse

65

67

import types

66

68

import binascii

67

69

import tempfile

70

import itertools

68

71

69

72

import dbus

70

73

import dbus.service

85

88

except ImportError:

86

89

SO_BINDTODEVICE = None

87

90

88

89

version = "1.4.1"

91

version = "1.5.5"

90

92

stored_state_file = "clients.pickle"

91

93

92

94

logger = logging.getLogger()

111

113

return interface_index

112

114

113

115

114

def initlogger(level=logging.WARNING):

116

def initlogger(debug, level=logging.WARNING):

115

117

"""init logger and add loglevel"""

116

118

117

119

syslogger.setFormatter(logging.Formatter

119

121

' %(message)s'))

120

122

logger.addHandler(syslogger)

121

123

122

console = logging.StreamHandler()

123

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

124

' [%(process)d]:'

125

' %(levelname)s:'

126

' %(message)s'))

127

logger.addHandler(console)

124

if debug:

125

console = logging.StreamHandler()

126

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

127

' [%(process)d]:'

128

' %(levelname)s:'

129

' %(message)s'))

130

logger.addHandler(console)

128

131

logger.setLevel(level)

129

132

130

133

142

145

self.gnupg.options.meta_interactive = False

143

146

self.gnupg.options.homedir = self.tempdir

144

147

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

145

'--quiet'])

148

'--quiet',

149

'--no-use-agent'])

146

150

147

151

def __enter__(self):

148

152

return self

149

153

150

def __exit__ (self, exc_type, exc_value, traceback):

154

def __exit__(self, exc_type, exc_value, traceback):

151

155

self._cleanup()

152

156

return False

153

157

174

178

175

179

def encrypt(self, data, password):

176

180

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

177

with open(os.devnull) as devnull:

181

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

178

182

try:

179

183

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

180

184

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

191

195

192

196

def decrypt(self, data, password):

193

197

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

194

with open(os.devnull) as devnull:

198

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

195

199

try:

196

200

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

197

201

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

198

202

attach_fhs={'stderr': devnull})

199

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

203

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

200

204

f.write(data)

201

205

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

202

206

decrypted_plaintext = f.read()

207

211

return decrypted_plaintext

208

212

209

213

210

211

214

class AvahiError(Exception):

212

215

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

213

216

self.value = value

242

245

server: D-Bus Server

243

246

bus: dbus.SystemBus()

244

247

"""

248

245

249

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

246

250

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

247

251

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

260

264

self.server = None

261

265

self.bus = bus

262

266

self.entry_group_state_changed_match = None

267

263

268

def rename(self):

264

269

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

265

270

if self.rename_count >= self.max_renames:

275

280

try:

276

281

self.add()

277

282

except dbus.exceptions.DBusException as error:

278

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

283

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

279

284

self.cleanup()

280

285

os._exit(1)

281

286

self.rename_count += 1

287

282

288

def remove(self):

283

289

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

284

290

if self.entry_group_state_changed_match is not None:

286

292

self.entry_group_state_changed_match = None

287

293

if self.group is not None:

288

294

self.group.Reset()

295

289

296

def add(self):

290

297

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

291

298

self.remove()

308

315

dbus.UInt16(self.port),

309

316

avahi.string_array_to_txt_array(self.TXT))

310

317

self.group.Commit()

318

311

319

def entry_group_state_changed(self, state, error):

312

320

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

313

321

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

320

328

elif state == avahi.ENTRY_GROUP_FAILURE:

321

329

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

322

330

unicode(error))

323

raise AvahiGroupError("State changed: %s"

324

% unicode(error))

331

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

332

.format(error))

333

325

334

def cleanup(self):

326

335

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

327

336

if self.group is not None:

332

341

pass

333

342

self.group = None

334

343

self.remove()

344

335

345

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

336

346

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

337

347

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

356

366

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

357

367

else:

358

368

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

369

359

370

def activate(self):

360

371

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

361

372

if self.server is None:

368

379

self.server_state_changed)

369

380

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

370

381

382

371

383

class AvahiServiceToSyslog(AvahiService):

372

384

def rename(self):

373

385

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

374

386

ret = AvahiService.rename(self)

375

387

syslogger.setFormatter(logging.Formatter

376

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

377

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

378

% self.name))

388

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

389

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

390

.format(self.name)))

379

391

return ret

380

392

393

381

394

def timedelta_to_milliseconds(td):

382

395

"Convert a datetime.timedelta() to milliseconds"

383

396

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

384

397

+ (td.seconds * 1000)

385

398

+ (td.microseconds // 1000))

386

399

400

387

401

class Client(object):

388

402

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

389

403

412

426

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

413

427

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

414

428

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

415

416

429

last_checker_status: integer between 0 and 255 reflecting exit

417

430

status of last checker. -1 reflects crashed

418

checker, or None.

431

checker, -2 means no checker completed yet.

419

432

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

420

433

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

421

434

D-Bus identifiers

422

435

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

423

436

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

424

437

until this client is disabled

425

extended_timeout: extra long timeout when password has been sent

438

extended_timeout: extra long timeout when secret has been sent

426

439

runtime_expansions: Allowed attributes for runtime expansion.

427

440

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

428

441

disabled, or None

429

442

"""

430

443

431

444

runtime_expansions = ("approval_delay", "approval_duration",

432

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

433

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

445

"created", "enabled", "expires",

446

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

447

"last_approval_request", "last_checked_ok",

434

448

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

449

client_defaults = { "timeout": "5m",

450

"extended_timeout": "15m",

451

"interval": "2m",

452

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

453

"host": "",

454

"approval_delay": "0s",

455

"approval_duration": "1s",

456

"approved_by_default": "True",

457

"enabled": "True",

458

}

435

459

436

460

def timeout_milliseconds(self):

437

461

"Return the 'timeout' attribute in milliseconds"

448

472

def approval_delay_milliseconds(self):

449

473

return timedelta_to_milliseconds(self.approval_delay)

450

474

451

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

452

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

453

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

454

attribute."""

475

@staticmethod

476

def config_parser(config):

477

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

478

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

479

with exceptions for any special settings as defined above.

480

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

481

value given the same arguments.

482

"""

483

settings = {}

484

for client_name in config.sections():

485

section = dict(config.items(client_name))

486

client = settings[client_name] = {}

487

488

client["host"] = section["host"]

489

# Reformat values from string types to Python types

490

client["approved_by_default"] = config.getboolean(

491

client_name, "approved_by_default")

492

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

493

"enabled")

494

495

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

496

.replace(" ", ""))

497

if "secret" in section:

498

client["secret"] = section["secret"].decode("base64")

499

elif "secfile" in section:

500

with open(os.path.expanduser(os.path.expandvars

501

(section["secfile"])),

502

"rb") as secfile:

503

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

504

else:

505

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

506

.format(section))

507

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

508

client["extended_timeout"] = string_to_delta(

509

section["extended_timeout"])

510

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

511

client["approval_delay"] = string_to_delta(

512

section["approval_delay"])

513

client["approval_duration"] = string_to_delta(

514

section["approval_duration"])

515

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

516

client["last_approval_request"] = None

517

client["last_checked_ok"] = None

518

client["last_checker_status"] = -2

519

520

return settings

521

522

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

455

523

self.name = name

456

if config is None:

457

config = {}

524

# adding all client settings

525

for setting, value in settings.iteritems():

526

setattr(self, setting, value)

527

528

if self.enabled:

529

if not hasattr(self, "last_enabled"):

530

self.last_enabled = datetime.datetime.utcnow()

531

if not hasattr(self, "expires"):

532

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

533

+ self.timeout)

534

else:

535

self.last_enabled = None

536

self.expires = None

537

458

538

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

459

539

# Uppercase and remove spaces from fingerprint for later

460

540

# comparison purposes with return value from the fingerprint()

461

541

# function

462

self.fingerprint = (config["fingerprint"].upper()

463

.replace(" ", ""))

464

542

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

465

if "secret" in config:

466

self.secret = config["secret"].decode("base64")

467

elif "secfile" in config:

468

with open(os.path.expanduser(os.path.expandvars

469

(config["secfile"])),

470

"rb") as secfile:

471

self.secret = secfile.read()

472

else:

473

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

474

% self.name)

475

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

476

self.created = datetime.datetime.utcnow()

477

self.enabled = config.get("enabled", True)

478

self.last_approval_request = None

479

if self.enabled:

480

self.last_enabled = datetime.datetime.utcnow()

481

else:

482

self.last_enabled = None

483

self.last_checked_ok = None

484

self.last_checker_status = None

485

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

486

self.extended_timeout = string_to_delta(config

487

["extended_timeout"])

488

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

543

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

544

datetime.datetime.utcnow())

545

546

# attributes specific for this server instance

489

547

self.checker = None

490

548

self.checker_initiator_tag = None

491

549

self.disable_initiator_tag = None

492

if self.enabled:

493

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

494

else:

495

self.expires = None

496

550

self.checker_callback_tag = None

497

self.checker_command = config["checker"]

498

551

self.current_checker_command = None

499

552

self.approved = None

500

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

501

True)

502

553

self.approvals_pending = 0

503

self.approval_delay = string_to_delta(

504

config["approval_delay"])

505

self.approval_duration = string_to_delta(

506

config["approval_duration"])

507

554

self.changedstate = (multiprocessing_manager

508

555

.Condition(multiprocessing_manager

509

556

.Lock()))

529

576

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

530

577

# Already enabled

531

578

return

532

self.send_changedstate()

533

579

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

534

580

self.enabled = True

535

581

self.last_enabled = datetime.datetime.utcnow()

536

582

self.init_checker()

583

self.send_changedstate()

537

584

538

585

def disable(self, quiet=True):

539

586

"""Disable this client."""

540

587

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

541

588

return False

542

589

if not quiet:

543

self.send_changedstate()

544

if not quiet:

545

590

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

546

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

591

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

547

592

gobject.source_remove(self.disable_initiator_tag)

548

593

self.disable_initiator_tag = None

549

594

self.expires = None

550

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

595

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

551

596

gobject.source_remove(self.checker_initiator_tag)

552

597

self.checker_initiator_tag = None

553

598

self.stop_checker()

554

599

self.enabled = False

600

if not quiet:

601

self.send_changedstate()

555

602

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

556

603

return False

557

604

561

608

def init_checker(self):

562

609

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

563

610

# and every interval from then on.

611

if self.checker_initiator_tag is not None:

612

gobject.source_remove(self.checker_initiator_tag)

564

613

self.checker_initiator_tag = (gobject.timeout_add

565

614

(self.interval_milliseconds(),

566

615

self.start_checker))

567

616

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

617

if self.disable_initiator_tag is not None:

618

gobject.source_remove(self.disable_initiator_tag)

568

619

self.disable_initiator_tag = (gobject.timeout_add

569

620

(self.timeout_milliseconds(),

570

621

self.disable))

589

640

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

590

641

vars(self))

591

642

592

def checked_ok(self, timeout=None):

593

"""Bump up the timeout for this client.

594

595

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

596

alive and well.

597

"""

643

def checked_ok(self):

644

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

645

self.last_checked_ok = datetime.datetime.utcnow()

646

self.last_checker_status = 0

647

self.bump_timeout()

648

649

def bump_timeout(self, timeout=None):

650

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

598

651

if timeout is None:

599

652

timeout = self.timeout

600

self.last_checked_ok = datetime.datetime.utcnow()

601

653

if self.disable_initiator_tag is not None:

602

654

gobject.source_remove(self.disable_initiator_tag)

655

self.disable_initiator_tag = None

603

656

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

604

657

self.disable_initiator_tag = (gobject.timeout_add

605

658

(timedelta_to_milliseconds

615

668

If a checker already exists, leave it running and do

616

669

nothing."""

617

670

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

618

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

619

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

620

# client would inevitably timeout, since no checker would get

621

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

671

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

672

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

673

# would inevitably timeout, since no checker would get a

674

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

622

675

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

623

676

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

624

677

# should be.

638

691

self.current_checker_command)

639

692

# Start a new checker if needed

640

693

if self.checker is None:

694

# Escape attributes for the shell

695

escaped_attrs = dict(

696

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

697

for attr in

698

self.runtime_expansions)

641

699

try:

642

# In case checker_command has exactly one % operator

643

command = self.checker_command % self.host

644

except TypeError:

645

# Escape attributes for the shell

646

escaped_attrs = dict(

647

(attr,

648

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

649

errors=

650

'replace')))

651

for attr in

652

self.runtime_expansions)

653

654

try:

655

command = self.checker_command % escaped_attrs

656

except TypeError as error:

657

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

658

' %s', self.checker_command, error)

659

return True # Try again later

700

command = self.checker_command % escaped_attrs

701

except TypeError as error:

702

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

703

self.checker_command, exc_info=error)

704

return True # Try again later

660

705

self.current_checker_command = command

661

706

try:

662

707

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

668

713

self.checker = subprocess.Popen(command,

669

714

close_fds=True,

670

715

shell=True, cwd="/")

671

self.checker_callback_tag = (gobject.child_watch_add

672

(self.checker.pid,

673

self.checker_callback,

674

data=command))

675

# The checker may have completed before the gobject

676

# watch was added. Check for this.

677

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

678

if pid:

679

gobject.source_remove(self.checker_callback_tag)

680

self.checker_callback(pid, status, command)

681

716

except OSError as error:

682

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

683

error)

717

logger.error("Failed to start subprocess",

718

exc_info=error)

719

self.checker_callback_tag = (gobject.child_watch_add

720

(self.checker.pid,

721

self.checker_callback,

722

data=command))

723

# The checker may have completed before the gobject

724

# watch was added. Check for this.

725

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

726

if pid:

727

gobject.source_remove(self.checker_callback_tag)

728

self.checker_callback(pid, status, command)

684

729

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

685

730

return True

686

731

693

738

return

694

739

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

695

740

try:

696

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

741

self.checker.terminate()

697

742

#time.sleep(0.5)

698

743

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

699

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

744

# self.checker.kill()

700

745

except OSError as error:

701

746

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

702

747

raise

719

764

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

720

765

if byte_arrays and signature != "ay":

721

766

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

722

" signature %r" % signature)

767

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

723

768

def decorator(func):

724

769

func._dbus_is_property = True

725

770

func._dbus_interface = dbus_interface

733

778

return decorator

734

779

735

780

781

def dbus_interface_annotations(dbus_interface):

782

"""Decorator for marking functions returning interface annotations

783

784

Usage:

785

786

@dbus_interface_annotations("org.example.Interface")

787

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

788

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

789

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

790

"false"}

791

"""

792

def decorator(func):

793

func._dbus_is_interface = True

794

func._dbus_interface = dbus_interface

795

func._dbus_name = dbus_interface

796

return func

797

return decorator

798

799

800

def dbus_annotations(annotations):

801

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

802

Usage:

803

804

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

805

access="r")

806

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

807

"org.freedesktop.DBus.Property."

808

"EmitsChangedSignal": "false"})

809

def Property_dbus_property(self):

810

return dbus.Boolean(False)

811

"""

812

def decorator(func):

813

func._dbus_annotations = annotations

814

return func

815

return decorator

816

817

736

818

class DBusPropertyException(dbus.exceptions.DBusException):

737

819

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

738

820

"""

761

843

"""

762

844

763

845

@staticmethod

764

def _is_dbus_property(obj):

765

return getattr(obj, "_dbus_is_property", False)

846

def _is_dbus_thing(thing):

847

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

848

849

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

850

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

851

"""

852

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

853

False)

766

854

767

def _get_all_dbus_properties(self):

855

def _get_all_dbus_things(self, thing):

768

856

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

769

857

"""

770

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

858

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

859

name),

860

athing.__get__(self))

771

861

for cls in self.__class__.__mro__

772

for name, prop in

773

inspect.getmembers(cls, self._is_dbus_property))

862

for name, athing in

863

inspect.getmembers(cls,

864

self._is_dbus_thing(thing)))

774

865

775

866

def _get_dbus_property(self, interface_name, property_name):

776

867

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

778

869

"""

779

870

for cls in self.__class__.__mro__:

780

871

for name, value in (inspect.getmembers

781

(cls, self._is_dbus_property)):

872

(cls,

873

self._is_dbus_thing("property"))):

782

874

if (value._dbus_name == property_name

783

875

and value._dbus_interface == interface_name):

784

876

return value.__get__(self)

813

905

# signatures other than "ay".

814

906

if prop._dbus_signature != "ay":

815

907

raise ValueError

816

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

817

for byte in value))

908

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

909

for byte in value))

818

910

prop(value)

819

911

820

912

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

826

918

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

827

919

"""

828

920

properties = {}

829

for name, prop in self._get_all_dbus_properties():

921

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

830

922

if (interface_name

831

923

and interface_name != prop._dbus_interface):

832

924

# Interface non-empty but did not match

847

939

path_keyword='object_path',

848

940

connection_keyword='connection')

849

941

def Introspect(self, object_path, connection):

850

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

942

"""Overloading of standard D-Bus method.

943

944

Inserts property tags and interface annotation tags.

851

945

"""

852

946

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

853

947

connection)

860

954

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

861

955

return e

862

956

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

957

# Add property tags

863

958

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

864

959

for name, prop

865

in self._get_all_dbus_properties()

960

in self._get_all_dbus_things("property")

866

961

if prop._dbus_interface

867

962

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

868

963

if_tag.appendChild(tag)

964

# Add annotation tags

965

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

966

for tag in if_tag.getElementsByTagName(typ):

967

annots = dict()

968

for name, prop in (self.

969

_get_all_dbus_things(typ)):

970

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

971

and prop._dbus_interface

972

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

973

annots.update(getattr

974

(prop,

975

"_dbus_annotations",

976

{}))

977

for name, value in annots.iteritems():

978

ann_tag = document.createElement(

979

"annotation")

980

ann_tag.setAttribute("name", name)

981

ann_tag.setAttribute("value", value)

982

tag.appendChild(ann_tag)

983

# Add interface annotation tags

984

for annotation, value in dict(

985

itertools.chain.from_iterable(

986

annotations().iteritems()

987

for name, annotations in

988

self._get_all_dbus_things("interface")

989

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

990

)).iteritems():

991

ann_tag = document.createElement("annotation")

992

ann_tag.setAttribute("name", annotation)

993

ann_tag.setAttribute("value", value)

994

if_tag.appendChild(ann_tag)

869

995

# Add the names to the return values for the

870

996

# "org.freedesktop.DBus.Properties" methods

871

997

if (if_tag.getAttribute("name")

886

1012

except (AttributeError, xml.dom.DOMException,

887

1013

xml.parsers.expat.ExpatError) as error:

888

1014

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

889

error)

1015

exc_info=error)

890

1016

return xmlstring

891

1017

892

1018

893

def datetime_to_dbus (dt, variant_level=0):

1019

def datetime_to_dbus(dt, variant_level=0):

894

1020

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

895

1021

if dt is None:

896

1022

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

898

1024

variant_level=variant_level)

899

1025

900

1026

901

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

902

.__metaclass__):

903

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

904

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

1027

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1028

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

1029

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

1030

interface names according to the "alt_interface_names" mapping.

1031

Usage:

1032

1033

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

1034

"net.example.AlternateInterface"})

1035

class SampleDBusObject(dbus.service.Object):

1036

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

1037

def SampleDBusMethod():

1038

pass

1039

1040

The above "SampleDBusMethod" on "SampleDBusObject" will be

1041

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

1042

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

1043

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

1044

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

1045

1046

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

1047

(from DBusObjectWithProperties) and interfaces (from the

1048

dbus_interface_annotations decorator).

905

1049

"""

906

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

907

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

908

# methods, signals, or properties in them

909

for base in (b for b in bases

910

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

911

# Go though all attributes of the base class

912

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

1050

def wrapper(cls):

1051

for orig_interface_name, alt_interface_name in (

1052

alt_interface_names.iteritems()):

1053

attr = {}

1054

interface_names = set()

1055

# Go though all attributes of the class

1056

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

913

1057

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

914

1058

# with the wrong interface name

915

1059

if (not hasattr(attribute, "_dbus_interface")

916

1060

or not attribute._dbus_interface

917

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

1061

.startswith(orig_interface_name)):

918

1062

continue

919

1063

# Create an alternate D-Bus interface name based on

920

1064

# the current name

921

1065

alt_interface = (attribute._dbus_interface

922

.replace("se.recompile.Mandos",

923

"se.bsnet.fukt.Mandos"))

1066

.replace(orig_interface_name,

1067

alt_interface_name))

1068

interface_names.add(alt_interface)

924

1069

# Is this a D-Bus signal?

925

1070

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

926

1071

# Extract the original non-method function by

941

1086

nonmethod_func.func_name,

942

1087

nonmethod_func.func_defaults,

943

1088

nonmethod_func.func_closure)))

1089

# Copy annotations, if any

1090

try:

1091

new_function._dbus_annotations = (

1092

dict(attribute._dbus_annotations))

1093

except AttributeError:

1094

pass

944

1095

# Define a creator of a function to call both the

945

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

946

# signals gets sent when the function is called

1096

# original and alternate functions, so both the

1097

# original and alternate signals gets sent when

1098

# the function is called

947

1099

def fixscope(func1, func2):

948

1100

"""This function is a scope container to pass

949

1101

func1 and func2 to the "call_both" function

956

1108

return call_both

957

1109

# Create the "call_both" function and add it to

958

1110

# the class

959

attr[attrname] = fixscope(attribute,

960

new_function)

1111

attr[attrname] = fixscope(attribute, new_function)

961

1112

# Is this a D-Bus method?

962

1113

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

963

1114

# Create a new, but exactly alike, function

974

1125

attribute.func_name,

975

1126

attribute.func_defaults,

976

1127

attribute.func_closure)))

1128

# Copy annotations, if any

1129

try:

1130

attr[attrname]._dbus_annotations = (

1131

dict(attribute._dbus_annotations))

1132

except AttributeError:

1133

pass

977

1134

# Is this a D-Bus property?

978

1135

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

979

1136

# Create a new, but exactly alike, function

993

1150

attribute.func_name,

994

1151

attribute.func_defaults,

995

1152

attribute.func_closure)))

996

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

997

998

1153

# Copy annotations, if any

1154

try:

1155

attr[attrname]._dbus_annotations = (

1156

dict(attribute._dbus_annotations))

1157

except AttributeError:

1158

pass

1159

# Is this a D-Bus interface?

1160

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

1161

# Create a new, but exactly alike, function

1162

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

1163

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

1164

# to the class.

1165

attr[attrname] = (dbus_interface_annotations

1166

(alt_interface)

1167

(types.FunctionType

1168

(attribute.func_code,

1169

attribute.func_globals,

1170

attribute.func_name,

1171

attribute.func_defaults,

1172

attribute.func_closure)))

1173

if deprecate:

1174

# Deprecate all alternate interfaces

1175

iname="_AlternateDBusNames_interface_annotation{0}"

1176

for interface_name in interface_names:

1177

@dbus_interface_annotations(interface_name)

1178

def func(self):

1179

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

1180

"true" }

1181

# Find an unused name

1182

for aname in (iname.format(i)

1183

for i in itertools.count()):

1184

if aname not in attr:

1185

attr[aname] = func

1186

break

1187

if interface_names:

1188

# Replace the class with a new subclass of it with

1189

# methods, signals, etc. as created above.

1190

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

1191

(cls,), attr)

1192

return cls

1193

return wrapper

1194

1195

1196

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

1197

"se.bsnet.fukt.Mandos"})

999

1198

class ClientDBus(Client, DBusObjectWithProperties):

1000

1199

"""A Client class using D-Bus

1001

1200

1012

1211

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

1013

1212

self.bus = bus

1014

1213

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

1015

1016

self._approvals_pending = 0

1017

1214

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

1018

1215

# the D-Bus

1019

1216

client_object_name = unicode(self.name).translate(

1023

1220

("/clients/" + client_object_name))

1024

1221

DBusObjectWithProperties.__init__(self, self.bus,

1025

1222

self.dbus_object_path)

1026

1223

1027

1224

def notifychangeproperty(transform_func,

1028

1225

dbus_name, type_func=lambda x: x,

1029

1226

variant_level=1):

1052

1249

1053

1250

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

1054

1251

1055

1056

1252

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1057

1253

approvals_pending = notifychangeproperty(dbus.Boolean,

1058

1254

"ApprovalPending",

1065

1261

checker is not None)

1066

1262

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1067

1263

"LastCheckedOK")

1264

last_checker_status = notifychangeproperty(dbus.Int16,

1265

"LastCheckerStatus")

1068

1266

last_approval_request = notifychangeproperty(

1069

1267

datetime_to_dbus, "LastApprovalRequest")

1070

1268

approved_by_default = notifychangeproperty(dbus.Boolean,

1071

1269

"ApprovedByDefault")

1072

approval_delay = notifychangeproperty(dbus.UInt16,

1270

approval_delay = notifychangeproperty(dbus.UInt64,

1073

1271

"ApprovalDelay",

1074

1272

type_func =

1075

1273

timedelta_to_milliseconds)

1076

1274

approval_duration = notifychangeproperty(

1077

dbus.UInt16, "ApprovalDuration",

1275

dbus.UInt64, "ApprovalDuration",

1078

1276

type_func = timedelta_to_milliseconds)

1079

1277

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

1080

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

1278

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

1081

1279

type_func =

1082

1280

timedelta_to_milliseconds)

1083

1281

extended_timeout = notifychangeproperty(

1084

dbus.UInt16, "ExtendedTimeout",

1282

dbus.UInt64, "ExtendedTimeout",

1085

1283

type_func = timedelta_to_milliseconds)

1086

interval = notifychangeproperty(dbus.UInt16,

1284

interval = notifychangeproperty(dbus.UInt64,

1087

1285

"Interval",

1088

1286

type_func =

1089

1287

timedelta_to_milliseconds)

1138

1336

return False

1139

1337

1140

1338

def approve(self, value=True):

1141

self.send_changedstate()

1142

1339

self.approved = value

1143

1340

gobject.timeout_add(timedelta_to_milliseconds

1144

1341

(self.approval_duration),

1145

1342

self._reset_approved)

1146

1343

self.send_changedstate()

1147

1344

1148

1345

## D-Bus methods, signals & properties

1149

1346

_interface = "se.recompile.Mandos.Client"

1150

1347

1348

## Interfaces

1349

1350

@dbus_interface_annotations(_interface)

1351

def _foo(self):

1352

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

1353

"false"}

1354

1151

1355

## Signals

1152

1356

1153

1357

# CheckerCompleted - signal

1189

1393

"D-Bus signal"

1190

1394

return self.need_approval()

1191

1395

1192

# NeRwequest - signal

1193

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

1194

def NewRequest(self, ip):

1195

"""D-Bus signal

1196

Is sent after a client request a password.

1197

"""

1198

pass

1199

1200

1396

## Methods

1201

1397

1202

1398

# Approve - method

1312

1508

return

1313

1509

return datetime_to_dbus(self.last_checked_ok)

1314

1510

1511

# LastCheckerStatus - property

1512

@dbus_service_property(_interface, signature="n",

1513

access="read")

1514

def LastCheckerStatus_dbus_property(self):

1515

return dbus.Int16(self.last_checker_status)

1516

1315

1517

# Expires - property

1316

1518

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

1317

1519

def Expires_dbus_property(self):

1328

1530

def Timeout_dbus_property(self, value=None):

1329

1531

if value is None: # get

1330

1532

return dbus.UInt64(self.timeout_milliseconds())

1533

old_timeout = self.timeout

1331

1534

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

1332

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

1333

return

1334

# Reschedule timeout

1335

gobject.source_remove(self.disable_initiator_tag)

1336

self.disable_initiator_tag = None

1337

self.expires = None

1338

time_to_die = timedelta_to_milliseconds((self

1339

.last_checked_ok

1340

+ self.timeout)

1341

- datetime.datetime

1342

.utcnow())

1343

if time_to_die <= 0:

1344

# The timeout has passed

1345

self.disable()

1346

else:

1347

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

1348

+ datetime.timedelta(milliseconds =

1349

time_to_die))

1350

self.disable_initiator_tag = (gobject.timeout_add

1351

(time_to_die, self.disable))

1535

# Reschedule disabling

1536

if self.enabled:

1537

now = datetime.datetime.utcnow()

1538

self.expires += self.timeout - old_timeout

1539

if self.expires <= now:

1540

# The timeout has passed

1541

self.disable()

1542

else:

1543

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

1544

is None):

1545

return

1546

gobject.source_remove(self.disable_initiator_tag)

1547

self.disable_initiator_tag = (

1548

gobject.timeout_add(

1549

timedelta_to_milliseconds(self.expires - now),

1550

self.disable))

1352

1551

1353

1552

# ExtendedTimeout - property

1354

1553

@dbus_service_property(_interface, signature="t",

1433

1632

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

1434

1633

1435

1634

1436

class ClientDBusTransitional(ClientDBus):

1437

__metaclass__ = AlternateDBusNamesMetaclass

1438

1439

1440

1635

class ClientHandler(socketserver.BaseRequestHandler, object):

1441

1636

"""A class to handle client connections.

1442

1637

1510

1705

except KeyError:

1511

1706

return

1512

1707

1513

if self.server.use_dbus:

1514

# Emit D-Bus signal

1515

client.NewRequest(str(self.client_address))

1516

1517

1708

if client.approval_delay:

1518

1709

delay = client.approval_delay

1519

1710

client.approvals_pending += 1

1550

1741

#wait until timeout or approved

1551

1742

time = datetime.datetime.now()

1552

1743

client.changedstate.acquire()

1553

(client.changedstate.wait

1554

(float(client.timedelta_to_milliseconds(delay)

1555

/ 1000)))

1744

client.changedstate.wait(

1745

float(timedelta_to_milliseconds(delay)

1746

/ 1000))

1556

1747

client.changedstate.release()

1557

1748

time2 = datetime.datetime.now()

1558

1749

if (time2 - time) >= delay:

1574

1765

try:

1575

1766

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

1576

1767

except gnutls.errors.GNUTLSError as error:

1577

logger.warning("gnutls send failed")

1768

logger.warning("gnutls send failed",

1769

exc_info=error)

1578

1770

return

1579

1771

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

1580

1772

sent, len(client.secret)

1583

1775

1584

1776

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

1585

1777

# bump the timeout using extended_timeout

1586

client.checked_ok(client.extended_timeout)

1778

client.bump_timeout(client.extended_timeout)

1587

1779

if self.server.use_dbus:

1588

1780

# Emit D-Bus signal

1589

1781

client.GotSecret()

1594

1786

try:

1595

1787

session.bye()

1596

1788

except gnutls.errors.GNUTLSError as error:

1597

logger.warning("GnuTLS bye failed")

1789

logger.warning("GnuTLS bye failed",

1790

exc_info=error)

1598

1791

1599

1792

@staticmethod

1600

1793

def peer_certificate(session):

1665

1858

def sub_process_main(self, request, address):

1666

1859

try:

1667

1860

self.finish_request(request, address)

1668

except:

1861

except Exception:

1669

1862

self.handle_error(request, address)

1670

1863

self.close_request(request)

1671

1864

1672

1865

def process_request(self, request, address):

1673

1866

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

1674

1867

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

1675

args = (request,

1676

address))

1868

args = (request, address))

1677

1869

proc.start()

1678

1870

return proc

1679

1871

1707

1899

use_ipv6: Boolean; to use IPv6 or not

1708

1900

"""

1709

1901

def __init__(self, server_address, RequestHandlerClass,

1710

interface=None, use_ipv6=True):

1902

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

1903

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

1904

creating a new one with socket.socket().

1905

"""

1711

1906

self.interface = interface

1712

1907

if use_ipv6:

1713

1908

self.address_family = socket.AF_INET6

1909

if socketfd is not None:

1910

# Save the file descriptor

1911

self.socketfd = socketfd

1912

# Save the original socket.socket() function

1913

self.socket_socket = socket.socket

1914

# To implement --socket, we monkey patch socket.socket.

1915

#

1916

# (When socketserver.TCPServer is a new-style class, we

1917

# could make self.socket into a property instead of monkey

1918

# patching socket.socket.)

1919

#

1920

# Create a one-time-only replacement for socket.socket()

1921

@functools.wraps(socket.socket)

1922

def socket_wrapper(*args, **kwargs):

1923

# Restore original function so subsequent calls are

1924

# not affected.

1925

socket.socket = self.socket_socket

1926

del self.socket_socket

1927

# This time only, return a new socket object from the

1928

# saved file descriptor.

1929

return socket.fromfd(self.socketfd, *args, **kwargs)

1930

# Replace socket.socket() function with wrapper

1931

socket.socket = socket_wrapper

1932

# The socketserver.TCPServer.__init__ will call

1933

# socket.socket(), which might be our replacement,

1934

# socket_wrapper(), if socketfd was set.

1714

1935

socketserver.TCPServer.__init__(self, server_address,

1715

1936

RequestHandlerClass)

1937

1716

1938

def server_bind(self):

1717

1939

"""This overrides the normal server_bind() function

1718

1940

to bind to an interface if one was specified, and also NOT to

1729

1951

str(self.interface

1730

1952

+ '\0'))

1731

1953

except socket.error as error:

1732

if error[0] == errno.EPERM:

1954

if error.errno == errno.EPERM:

1733

1955

logger.error("No permission to"

1734

1956

" bind to interface %s",

1735

1957

self.interface)

1736

elif error[0] == errno.ENOPROTOOPT:

1958

elif error.errno == errno.ENOPROTOOPT:

1737

1959

logger.error("SO_BINDTODEVICE not available;"

1738

1960

" cannot bind to interface %s",

1739

1961

self.interface)

1962

elif error.errno == errno.ENODEV:

1963

logger.error("Interface %s does not"

1964

" exist, cannot bind",

1965

self.interface)

1740

1966

else:

1741

1967

raise

1742

1968

# Only bind(2) the socket if we really need to.

1772

1998

"""

1773

1999

def __init__(self, server_address, RequestHandlerClass,

1774

2000

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

1775

gnutls_priority=None, use_dbus=True):

2001

gnutls_priority=None, use_dbus=True, socketfd=None):

1776

2002

self.enabled = False

1777

2003

self.clients = clients

1778

2004

if self.clients is None:

1782

2008

IPv6_TCPServer.__init__(self, server_address,

1783

2009

RequestHandlerClass,

1784

2010

interface = interface,

1785

use_ipv6 = use_ipv6)

2011

use_ipv6 = use_ipv6,

2012

socketfd = socketfd)

1786

2013

def server_activate(self):

1787

2014

if self.enabled:

1788

2015

return socketserver.TCPServer.server_activate(self)

1801

2028

1802

2029

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

1803

2030

proc = None, client_object=None):

1804

condition_names = {

1805

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

1806

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

1807

# blocking).

1808

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

1809

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

1810

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

1811

# broken, usually for pipes and

1812

# sockets).

1813

}

1814

conditions_string = ' | '.join(name

1815

for cond, name in

1816

condition_names.iteritems()

1817

if cond & condition)

1818

2031

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

1819

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

2032

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

1820

2033

# Wait for other process to exit

1821

2034

proc.join()

1822

2035

return False

1912

2125

elif suffix == "w":

1913

2126

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

1914

2127

else:

1915

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

2128

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

2129

.format(suffix))

1916

2130

except (ValueError, IndexError) as e:

1917

2131

raise ValueError(*(e.args))

1918

2132

timevalue += delta

1932

2146

sys.exit()

1933

2147

if not noclose:

1934

2148

# Close all standard open file descriptors

1935

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

2149

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

1936

2150

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

1937

2151

raise OSError(errno.ENODEV,

1938

"%s not a character device"

1939

% os.path.devnull)

2152

"{0} not a character device"

2153

.format(os.devnull))

1940

2154

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

1941

2155

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

1942

2156

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

1951

2165

1952

2166

parser = argparse.ArgumentParser()

1953

2167

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

1954

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

2168

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

1955

2169

help="show version number and exit")

1956

2170

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

1957

2171

help="Bind to interface IF")

1982

2196

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

1983

2197

dest="restore", help="Do not restore stored"

1984

2198

" state")

2199

parser.add_argument("--socket", type=int,

2200

help="Specify a file descriptor to a network"

2201

" socket to use instead of creating one")

1985

2202

parser.add_argument("--statedir", metavar="DIR",

1986

2203

help="Directory to save/restore state in")

1987

2204

2004

2221

"use_ipv6": "True",

2005

2222

"debuglevel": "",

2006

2223

"restore": "True",

2224

"socket": "",

2007

2225

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

2008

2226

}

2009

2227

2021

2239

if server_settings["port"]:

2022

2240

server_settings["port"] = server_config.getint("DEFAULT",

2023

2241

"port")

2242

if server_settings["socket"]:

2243

server_settings["socket"] = server_config.getint("DEFAULT",

2244

"socket")

2245

# Later, stdin will, and stdout and stderr might, be dup'ed

2246

# over with an opened os.devnull. But we don't want this to

2247

# happen with a supplied network socket.

2248

if 0 <= server_settings["socket"] <= 2:

2249

server_settings["socket"] = os.dup(server_settings

2250

["socket"])

2024

2251

del server_config

2025

2252

2026

2253

# Override the settings from the config file with command line

2028

2255

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

2029

2256

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

2030

2257

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

2031

"statedir"):

2258

"statedir", "socket"):

2032

2259

value = getattr(options, option)

2033

2260

if value is not None:

2034

2261

server_settings[option] = value

2050

2277

stored_state_file)

2051

2278

2052

2279

if debug:

2053

initlogger(logging.DEBUG)

2280

initlogger(debug, logging.DEBUG)

2054

2281

else:

2055

2282

if not debuglevel:

2056

initlogger()

2283

initlogger(debug)

2057

2284

else:

2058

2285

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

2059

initlogger(level)

2286

initlogger(debug, level)

2060

2287

2061

2288

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

2062

2289

syslogger.setFormatter(logging.Formatter

2063

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

2064

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

2065

% server_settings["servicename"]))

2290

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

2291

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

2292

.format(server_settings

2293

["servicename"])))

2066

2294

2067

2295

# Parse config file with clients

2068

client_defaults = { "timeout": "5m",

2069

"extended_timeout": "15m",

2070

"interval": "2m",

2071

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

2072

"host": "",

2073

"approval_delay": "0s",

2074

"approval_duration": "1s",

2075

}

2076

client_config = configparser.SafeConfigParser(client_defaults)

2296

client_config = configparser.SafeConfigParser(Client

2297

.client_defaults)

2077

2298

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

2078

2299

"clients.conf"))

2079

2300

2088

2309

use_ipv6=use_ipv6,

2089

2310

gnutls_priority=

2090

2311

server_settings["priority"],

2091

use_dbus=use_dbus)

2312

use_dbus=use_dbus,

2313

socketfd=(server_settings["socket"]

2314

or None))

2092

2315

if not debug:

2093

2316

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

2094

2317

try:

2095

2318

pidfile = open(pidfilename, "w")

2096

except IOError:

2097

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

2319

except IOError as e:

2320

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

2321

exc_info=e)

2098

2322

2099

try:

2100

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

2101

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

2102

except KeyError:

2323

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

2103

2324

try:

2104

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

2105

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

2325

uid = pwd.getpwnam(name).pw_uid

2326

gid = pwd.getpwnam(name).pw_gid

2327

break

2106

2328

except KeyError:

2107

try:

2108

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

2109

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

2110

except KeyError:

2111

uid = 65534

2112

gid = 65534

2329

continue

2330

else:

2331

uid = 65534

2332

gid = 65534

2113

2333

try:

2114

2334

os.setgid(gid)

2115

2335

os.setuid(uid)

2116

2336

except OSError as error:

2117

if error[0] != errno.EPERM:

2337

if error.errno != errno.EPERM:

2118

2338

raise error

2119

2339

2120

2340

if debug:

2132

2352

.gnutls_global_set_log_function(debug_gnutls))

2133

2353

2134

2354

# Redirect stdin so all checkers get /dev/null

2135

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

2355

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

2136

2356

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

2137

2357

if null > 2:

2138

2358

os.close(null)

2139

else:

2140

# No console logging

2141

logger.removeHandler(console)

2142

2359

2143

2360

# Need to fork before connecting to D-Bus

2144

2361

if not debug:

2145

2362

# Close all input and output, do double fork, etc.

2146

2363

daemon()

2147

2364

2365

# multiprocessing will use threads, so before we use gobject we

2366

# need to inform gobject that threads will be used.

2367

gobject.threads_init()

2368

2148

2369

global main_loop

2149

2370

# From the Avahi example code

2150

DBusGMainLoop(set_as_default=True )

2371

DBusGMainLoop(set_as_default=True)

2151

2372

main_loop = gobject.MainLoop()

2152

2373

bus = dbus.SystemBus()

2153

2374

# End of Avahi example code

2159

2380

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

2160

2381

do_not_queue=True))

2161

2382

except dbus.exceptions.NameExistsException as e:

2162

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

2383

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

2163

2384

use_dbus = False

2164

2385

server_settings["use_dbus"] = False

2165

2386

tcp_server.use_dbus = False

2177

2398

2178

2399

client_class = Client

2179

2400

if use_dbus:

2180

client_class = functools.partial(ClientDBusTransitional,

2181

bus = bus)

2182

2183

special_settings = {

2184

# Some settings need to be accessd by special methods;

2185

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

2186

"approved_by_default":

2187

lambda section:

2188

client_config.getboolean(section, "approved_by_default"),

2189

"enabled":

2190

lambda section:

2191

client_config.getboolean(section, "enabled"),

2192

}

2193

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

2194

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

2195

# with exceptions for any special settings as defined above

2196

client_settings = dict((clientname,

2197

dict((setting,

2198

(value

2199

if setting not in special_settings

2200

else special_settings[setting]

2201

(clientname)))

2202

for setting, value in

2203

client_config.items(clientname)))

2204

for clientname in client_config.sections())

2205

2401

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

2402

2403

client_settings = Client.config_parser(client_config)

2206

2404

old_client_settings = {}

2207

clients_data = []

2405

clients_data = {}

2208

2406

2209

2407

# Get client data and settings from last running state.

2210

2408

if server_settings["restore"]:

2214

2412

(stored_state))

2215

2413

os.remove(stored_state_path)

2216

2414

except IOError as e:

2217

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

2218

.format(e))

2219

if e.errno != errno.ENOENT:

2415

if e.errno == errno.ENOENT:

2416

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

2417

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

2418

else:

2419

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

2420

exc_info=e)

2220

2421

raise

2422

except EOFError as e:

2423

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

2424

"EOFError:", exc_info=e)

2221

2425

2222

2426

with PGPEngine() as pgp:

2223

for client in clients_data:

2224

client_name = client["name"]

2225

2427

for client_name, client in clients_data.iteritems():

2226

2428

# Decide which value to use after restoring saved state.

2227

2429

# We have three different values: Old config file,

2228

2430

# new config file, and saved state.

2236

2438

if (name != "secret" and

2237

2439

value != old_client_settings[client_name]

2238

2440

[name]):

2239

setattr(client, name, value)

2441

client[name] = value

2240

2442

except KeyError:

2241

2443

pass

2242

2444

2243

2445

# Clients who has passed its expire date can still be

2244

# enabled if its last checker was sucessful. Clients

2245

# whose checker failed before we stored its state is

2246

# assumed to have failed all checkers during downtime.

2446

# enabled if its last checker was successful. Clients

2447

# whose checker succeeded before we stored its state is

2448

# assumed to have successfully run all checkers during

2449

# downtime.

2247

2450

if client["enabled"]:

2248

if client["expires"] <= (datetime.datetime

2249

.utcnow()):

2250

# Client has expired

2251

if client["last_checker_status"] != 0:

2451

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

2452

if not client["last_checked_ok"]:

2453

logger.warning(

2454

"disabling client {0} - Client never "

2455

"performed a successful checker"

2456

.format(client_name))

2457

client["enabled"] = False

2458

elif client["last_checker_status"] != 0:

2459

logger.warning(

2460

"disabling client {0} - Client "

2461

"last checker failed with error code {1}"

2462

.format(client_name,

2463

client["last_checker_status"]))

2252

2464

client["enabled"] = False

2253

2465

else:

2254

2466

client["expires"] = (datetime.datetime

2255

2467

.utcnow()

2256

2468

+ client["timeout"])

2257

2258

client["changedstate"] = (multiprocessing_manager

2259

.Condition

2260

(multiprocessing_manager

2261

.Lock()))

2262

if use_dbus:

2263

new_client = (ClientDBusTransitional.__new__

2264

(ClientDBusTransitional))

2265

tcp_server.clients[client_name] = new_client

2266

new_client.bus = bus

2267

for name, value in client.iteritems():

2268

setattr(new_client, name, value)

2269

client_object_name = unicode(client_name).translate(

2270

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

2271

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

2272

new_client.dbus_object_path = (dbus.ObjectPath

2273

("/clients/"

2274

+ client_object_name))

2275

DBusObjectWithProperties.__init__(new_client,

2276

new_client.bus,

2277

new_client

2278

.dbus_object_path)

2279

else:

2280

tcp_server.clients[client_name] = (Client.__new__

2281

(Client))

2282

for name, value in client.iteritems():

2283

setattr(tcp_server.clients[client_name],

2284

name, value)

2285

2469

logger.debug("Last checker succeeded,"

2470

" keeping {0} enabled"

2471

.format(client_name))

2286

2472

try:

2287

tcp_server.clients[client_name].secret = (

2288

pgp.decrypt(tcp_server.clients[client_name]

2289

.encrypted_secret,

2473

client["secret"] = (

2474

pgp.decrypt(client["encrypted_secret"],

2290

2475

client_settings[client_name]

2291

2476

["secret"]))

2292

2477

except PGPError:

2293

2478

# If decryption fails, we use secret from new settings

2294

2479

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

2295

2480

.format(client_name))

2296

tcp_server.clients[client_name].secret = (

2481

client["secret"] = (

2297

2482

client_settings[client_name]["secret"])

2298

2483

2299

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

2300

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

2301

del tcp_server.clients[clientname]

2302

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

2303

tcp_server.clients[clientname] = (client_class(name

2304

= clientname,

2305

config =

2306

client_settings

2307

[clientname]))

2484

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

2485

for client_name in (set(old_client_settings)

2486

- set(client_settings)):

2487

del clients_data[client_name]

2488

for client_name in (set(client_settings)

2489

- set(old_client_settings)):

2490

clients_data[client_name] = client_settings[client_name]

2491

2492

# Create all client objects

2493

for client_name, client in clients_data.iteritems():

2494

tcp_server.clients[client_name] = client_class(

2495

name = client_name, settings = client)

2308

2496

2309

2497

if not tcp_server.clients:

2310

2498

logger.warning("No clients defined")

2311

2499

2312

2500

if not debug:

2313

2501

try:

2314

2502

with pidfile:

2322

2510

# "pidfile" was never created

2323

2511

pass

2324

2512

del pidfilename

2325

2326

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

2327

2513

2328

2514

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

2329

2515

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

2330

2516

2331

2517

if use_dbus:

2332

class MandosDBusService(dbus.service.Object):

2518

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

2519

"se.bsnet.fukt.Mandos"})

2520

class MandosDBusService(DBusObjectWithProperties):

2333

2521

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

2334

2522

def __init__(self):

2335

2523

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

2336

2524

_interface = "se.recompile.Mandos"

2337

2525

2526

@dbus_interface_annotations(_interface)

2527

def _foo(self):

2528

return { "org.freedesktop.DBus.Property"

2529

".EmitsChangedSignal":

2530

"false"}

2531

2338

2532

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

2339

2533

def ClientAdded(self, objpath):

2340

2534

"D-Bus signal"

2382

2576

2383

2577

del _interface

2384

2578

2385

class MandosDBusServiceTransitional(MandosDBusService):

2386

__metaclass__ = AlternateDBusNamesMetaclass

2387

mandos_dbus_service = MandosDBusServiceTransitional()

2579

mandos_dbus_service = MandosDBusService()

2388

2580

2389

2581

def cleanup():

2390

2582

"Cleanup function; run on exit"

2397

2589

# Store client before exiting. Secrets are encrypted with key

2398

2590

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

2399

2591

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

2400

clients = []

2592

clients = {}

2401

2593

with PGPEngine() as pgp:

2402

2594

for client in tcp_server.clients.itervalues():

2403

2595

key = client_settings[client.name]["secret"]

2405

2597

key)

2406

2598

client_dict = {}

2407

2599

2408

# A list of attributes that will not be stored when

2409

# shutting down.

2410

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

2600

# A list of attributes that can not be pickled

2601

# + secret.

2602

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

2603

"checker"))

2411

2604

for name, typ in (inspect.getmembers

2412

2605

(dbus.service.Object)):

2413

2606

exclude.add(name)

2418

2611

if attr not in exclude:

2419

2612

client_dict[attr] = getattr(client, attr)

2420

2613

2421

clients.append(client_dict)

2614

clients[client.name] = client_dict

2422

2615

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

2423

2616

2424

2617

try:

2425

with os.fdopen(os.open(stored_state_path,

2426

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

2427

0600), "wb") as stored_state:

2618

with (tempfile.NamedTemporaryFile

2619

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

2620

dir=os.path.dirname(stored_state_path),

2621

delete=False)) as stored_state:

2428

2622

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

2623

tempname=stored_state.name

2624

os.rename(tempname, stored_state_path)

2429

2625

except (IOError, OSError) as e:

2430

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

2431

.format(e))

2432

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

2433

raise

2626

if not debug:

2627

try:

2628

os.remove(tempname)

2629

except NameError:

2630

pass

2631

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

2632

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

2633

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

2634

else:

2635

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

2636

exc_info=e)

2637

raise e

2434

2638

2435

2639

# Delete all clients, and settings from config

2436

2640

while tcp_server.clients:

2463

2667

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

2464

2668

if use_ipv6:

2465

2669

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

2466

" flowinfo %d, scope_id %d"

2467

% tcp_server.socket.getsockname())

2670

" flowinfo %d, scope_id %d",

2671

*tcp_server.socket.getsockname())

2468

2672

else: # IPv4

2469

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

2470

% tcp_server.socket.getsockname())

2673

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

2674

*tcp_server.socket.getsockname())

2471

2675

2472

2676

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

2473

2677

2476

2680

try:

2477

2681

service.activate()

2478

2682

except dbus.exceptions.DBusException as error:

2479

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

2683

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

2480

2684

cleanup()

2481

2685

sys.exit(1)

2482

2686

# End of Avahi example code

2489

2693

logger.debug("Starting main loop")

2490

2694

main_loop.run()

2491

2695

except AvahiError as error:

2492

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

2696

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

2493

2697

cleanup()

2494

2698

sys.exit(1)

2495

2699

except KeyboardInterrupt:

2500

2704

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

2501

2705

cleanup()

2502

2706

2503

2504

2707

if __name__ == '__main__':

2505

2708

main()