/mandos/trunk : revision 1307

1

#!/usr/bin/python3 -bI

2

# -*- mode: python; after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-

2

# -*- coding: utf-8; lexical-binding: t -*-

3

#

4

# Mandos server - give out binary blobs to connecting clients.

5

#

11

# "AvahiService" class, and some lines in "main".

12

#

13

# Everything else is

14

15

14

15

16

#

17

# This file is part of Mandos.

18

#

31

#

32

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

33

#

34

35

34

from __future__ import (division, absolute_import, print_function,

36

35

unicode_literals)

37

36

40

39

except ImportError:

41

40

pass

42

41

42

import sys

43

import unittest

44

import argparse

45

import logging

46

import os

43

47

try:

44

48

import SocketServer as socketserver

45

49

except ImportError:

46

50

import socketserver

47

51

import socket

48

import argparse

49

52

import datetime

50

53

import errno

51

54

try:

52

55

import ConfigParser as configparser

53

56

except ImportError:

54

57

import configparser

55

import sys

56

58

import re

57

import os

58

59

import signal

59

60

import subprocess

60

61

import atexit

61

62

import stat

62

import logging

63

import logging.handlers

64

import pwd

65

import contextlib

77

import itertools

78

import collections

79

import codecs

80

import unittest

81

80

import random

82

81

import shlex

83

82

94

93

if sys.version_info.major == 2:

95

94

__metaclass__ = type

96

95

str = unicode

96

input = raw_input

97

98

# Add collections.abc.Callable if it does not exist

99

try:

143

if sys.version_info < (3, 2):

144

configparser.Configparser = configparser.SafeConfigParser

145

146

version = "1.8.14"

146

version = "1.8.17"

147

stored_state_file = "clients.pickle"

148

149

logger = logging.getLogger()

149

log = logging.getLogger(os.path.basename(sys.argv[0]))

150

logging.captureWarnings(True) # Show warnings via the logging system

151

syslogger = None

152

189

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

190

address="/dev/log"))

191

syslogger.setFormatter(logging.Formatter

192

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

193

' %(message)s'))

194

logger.addHandler(syslogger)

192

("Mandos [%(process)d]: %(levelname)s:"

193

" %(message)s"))

194

log.addHandler(syslogger)

195

196

if debug:

197

console = logging.StreamHandler()

198

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

199

' [%(process)d]:'

200

' %(levelname)s:'

201

' %(message)s'))

202

logger.addHandler(console)

203

logger.setLevel(level)

198

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

199

" [%(process)d]:"

200

" %(levelname)s:"

201

" %(message)s"))

202

log.addHandler(console)

203

log.setLevel(level)

204

205

206

class PGPError(Exception):

224

except OSError as e:

225

if e.errno != errno.ENOENT:

226

raise

227

self.gnupgargs = ['--batch',

228

'--homedir', self.tempdir,

229

'--force-mdc',

230

'--quiet']

227

self.gnupgargs = ["--batch",

228

"--homedir", self.tempdir,

229

"--force-mdc",

230

"--quiet"]

231

# Only GPG version 1 has the --no-use-agent option.

232

if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):

233

self.gnupgargs.append("--no-use-agent")

272

dir=self.tempdir) as passfile:

273

passfile.write(passphrase)

274

passfile.flush()

275

proc = subprocess.Popen([self.gpg, '--symmetric',

276

'--passphrase-file',

275

proc = subprocess.Popen([self.gpg, "--symmetric",

276

"--passphrase-file",

277

passfile.name]

278

+ self.gnupgargs,

279

stdin=subprocess.PIPE,

290

dir=self.tempdir) as passfile:

291

passfile.write(passphrase)

292

passfile.flush()

293

proc = subprocess.Popen([self.gpg, '--decrypt',

294

'--passphrase-file',

293

proc = subprocess.Popen([self.gpg, "--decrypt",

294

"--passphrase-file",

295

passfile.name]

296

+ self.gnupgargs,

297

stdin=subprocess.PIPE,

350

Attributes:

351

interface: integer; avahi.IF_UNSPEC or an interface index.

352

Used to optionally bind to the specified interface.

353

name: string; Example: 'Mandos'

354

type: string; Example: '_mandos._tcp'.

353

name: string; Example: "Mandos"

354

type: string; Example: "_mandos._tcp".

355

See <https://www.iana.org/assignments/service-names-port-numbers>

356

port: integer; what port to announce

357

TXT: list of strings; TXT record for the service

394

def rename(self, remove=True):

395

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

396

if self.rename_count >= self.max_renames:

397

logger.critical("No suitable Zeroconf service name found"

398

" after %i retries, exiting.",

399

self.rename_count)

397

log.critical("No suitable Zeroconf service name found"

398

" after %i retries, exiting.",

399

self.rename_count)

400

raise AvahiServiceError("Too many renames")

401

self.name = str(

402

self.server.GetAlternativeServiceName(self.name))

403

self.rename_count += 1

404

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

405

self.name)

404

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

405

self.name)

406

if remove:

407

self.remove()

408

try:

410

except dbus.exceptions.DBusException as error:

411

if (error.get_dbus_name()

412

== "org.freedesktop.Avahi.CollisionError"):

413

logger.info("Local Zeroconf service name collision.")

413

log.info("Local Zeroconf service name collision.")

414

return self.rename(remove=False)

415

else:

416

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

416

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

417

self.cleanup()

418

os._exit(1)

419

435

avahi.DBUS_INTERFACE_ENTRY_GROUP)

436

self.entry_group_state_changed_match = (

437

self.group.connect_to_signal(

438

'StateChanged', self.entry_group_state_changed))

439

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

440

self.name, self.type)

438

"StateChanged", self.entry_group_state_changed))

439

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

440

self.name, self.type)

441

self.group.AddService(

442

self.interface,

443

self.protocol,

450

451

def entry_group_state_changed(self, state, error):

452

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

453

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

453

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

454

455

if state == avahi.ENTRY_GROUP_ESTABLISHED:

456

logger.debug("Zeroconf service established.")

456

log.debug("Zeroconf service established.")

457

elif state == avahi.ENTRY_GROUP_COLLISION:

458

logger.info("Zeroconf service name collision.")

458

log.info("Zeroconf service name collision.")

459

self.rename()

460

elif state == avahi.ENTRY_GROUP_FAILURE:

461

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

462

str(error))

461

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

462

str(error))

463

raise AvahiGroupError("State changed: {!s}".format(error))

464

465

def cleanup(self):

475

476

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

477

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

478

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

478

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

479

bad_states = {

480

avahi.SERVER_INVALID: "Zeroconf server invalid",

481

avahi.SERVER_REGISTERING: None,

485

if state in bad_states:

486

if bad_states[state] is not None:

487

if error is None:

488

logger.error(bad_states[state])

488

log.error(bad_states[state])

489

else:

490

logger.error(bad_states[state] + ": %r", error)

490

log.error(bad_states[state] + ": %r", error)

491

self.cleanup()

492

elif state == avahi.SERVER_RUNNING:

493

try:

495

except dbus.exceptions.DBusException as error:

496

if (error.get_dbus_name()

497

== "org.freedesktop.Avahi.CollisionError"):

498

logger.info("Local Zeroconf service name"

499

" collision.")

498

log.info("Local Zeroconf service name collision.")

500

499

return self.rename(remove=False)

501

500

else:

502

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

501

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

503

502

self.cleanup()

504

503

os._exit(1)

505

504

else:

506

505

if error is None:

507

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

506

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

508

507

else:

509

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

508

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

510

509

511

510

def activate(self):

512

511

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

527

526

ret = super(AvahiServiceToSyslog, self).rename(*args,

528

527

**kwargs)

529

528

syslogger.setFormatter(logging.Formatter(

530

'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'

529

"Mandos ({}) [%(process)d]: %(levelname)s: %(message)s"

531

530

.format(self.name)))

532

531

return ret

533

532

563

562

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

564

563

565

564

# Types

566

class session_int(ctypes.Structure):

565

class _session_int(ctypes.Structure):

567

566

_fields_ = []

568

session_t = ctypes.POINTER(session_int)

567

session_t = ctypes.POINTER(_session_int)

569

568

570

569

class certificate_credentials_st(ctypes.Structure):

571

570

_fields_ = []

574

573

certificate_type_t = ctypes.c_int

575

574

576

575

class datum_t(ctypes.Structure):

577

_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),

578

('size', ctypes.c_uint)]

576

_fields_ = [("data", ctypes.POINTER(ctypes.c_ubyte)),

577

("size", ctypes.c_uint)]

579

578

580

class openpgp_crt_int(ctypes.Structure):

579

class _openpgp_crt_int(ctypes.Structure):

581

580

_fields_ = []

582

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

581

openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)

583

582

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

584

583

log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)

585

584

credentials_type_t = ctypes.c_int

594

593

# gnutls.strerror()

595

594

self.code = code

596

595

if message is None and code is not None:

597

message = gnutls.strerror(code)

596

message = gnutls.strerror(code).decode(

597

"utf-8", errors="replace")

598

return super(gnutls.Error, self).__init__(

599

message, *args)

600

601

class CertificateSecurityError(Error):

602

pass

603

604

class PointerTo:

605

def __init__(self, cls):

606

self.cls = cls

607

608

def from_param(self, obj):

609

if not isinstance(obj, self.cls):

610

raise TypeError("Not of type {}: {!r}"

611

.format(self.cls.__name__, obj))

612

return ctypes.byref(obj.from_param(obj))

613

614

class CastToVoidPointer:

615

def __init__(self, cls):

616

self.cls = cls

617

618

def from_param(self, obj):

619

if not isinstance(obj, self.cls):

620

raise TypeError("Not of type {}: {!r}"

621

.format(self.cls.__name__, obj))

622

return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)

623

624

class With_from_param:

625

@classmethod

626

def from_param(cls, obj):

627

return obj._as_parameter_

628

604

629

# Classes

605

class Credentials:

630

class Credentials(With_from_param):

606

631

def __init__(self):

607

self._c_object = gnutls.certificate_credentials_t()

608

gnutls.certificate_allocate_credentials(

609

ctypes.byref(self._c_object))

632

self._as_parameter_ = gnutls.certificate_credentials_t()

633

gnutls.certificate_allocate_credentials(self)

610

634

self.type = gnutls.CRD_CERTIFICATE

611

635

612

636

def __del__(self):

613

gnutls.certificate_free_credentials(self._c_object)

637

gnutls.certificate_free_credentials(self)

614

638

615

class ClientSession:

639

class ClientSession(With_from_param):

616

640

def __init__(self, socket, credentials=None):

617

self._c_object = gnutls.session_t()

641

self._as_parameter_ = gnutls.session_t()

618

642

gnutls_flags = gnutls.CLIENT

619

643

if gnutls.check_version(b"3.5.6"):

620

644

gnutls_flags |= gnutls.NO_TICKETS

621

645

if gnutls.has_rawpk:

622

646

gnutls_flags |= gnutls.ENABLE_RAWPK

623

gnutls.init(ctypes.byref(self._c_object), gnutls_flags)

647

gnutls.init(self, gnutls_flags)

624

648

del gnutls_flags

625

gnutls.set_default_priority(self._c_object)

626

gnutls.transport_set_ptr(self._c_object, socket.fileno())

627

gnutls.handshake_set_private_extensions(self._c_object,

628

True)

649

gnutls.set_default_priority(self)

650

gnutls.transport_set_ptr(self, socket.fileno())

651

gnutls.handshake_set_private_extensions(self, True)

629

652

self.socket = socket

630

653

if credentials is None:

631

654

credentials = gnutls.Credentials()

632

gnutls.credentials_set(self._c_object, credentials.type,

633

ctypes.cast(credentials._c_object,

634

ctypes.c_void_p))

655

gnutls.credentials_set(self, credentials.type,

656

credentials)

635

657

self.credentials = credentials

636

658

637

659

def __del__(self):

638

gnutls.deinit(self._c_object)

660

gnutls.deinit(self)

639

661

640

662

def handshake(self):

641

return gnutls.handshake(self._c_object)

663

return gnutls.handshake(self)

642

664

643

665

def send(self, data):

644

666

data = bytes(data)

645

667

data_len = len(data)

646

668

while data_len > 0:

647

data_len -= gnutls.record_send(self._c_object,

648

data[-data_len:],

669

data_len -= gnutls.record_send(self, data[-data_len:],

649

670

data_len)

650

671

651

672

def bye(self):

652

return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)

673

return gnutls.bye(self, gnutls.SHUT_RDWR)

653

674

654

675

# Error handling functions

655

676

def _error_code(result):

656

677

"""A function to raise exceptions on errors, suitable

657

for the 'restype' attribute on ctypes functions"""

658

if result >= 0:

678

for the "restype" attribute on ctypes functions"""

679

if result >= gnutls.E_SUCCESS:

659

680

return result

660

681

if result == gnutls.E_NO_CERTIFICATE_FOUND:

661

682

raise gnutls.CertificateSecurityError(code=result)

662

683

raise gnutls.Error(code=result)

663

684

664

def _retry_on_error(result, func, arguments):

685

def _retry_on_error(result, func, arguments,

686

_error_code=_error_code):

665

687

"""A function to retry on some errors, suitable

666

for the 'errcheck' attribute on ctypes functions"""

667

while result < 0:

688

for the "errcheck" attribute on ctypes functions"""

689

while result < gnutls.E_SUCCESS:

668

690

if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):

669

691

return _error_code(result)

670

692

result = func(*arguments)

675

697

676

698

# Functions

677

699

priority_set_direct = _library.gnutls_priority_set_direct

678

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

700

priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,

679

701

ctypes.POINTER(ctypes.c_char_p)]

680

702

priority_set_direct.restype = _error_code

681

703

682

704

init = _library.gnutls_init

683

init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]

705

init.argtypes = [PointerTo(ClientSession), ctypes.c_int]

684

706

init.restype = _error_code

685

707

686

708

set_default_priority = _library.gnutls_set_default_priority

687

set_default_priority.argtypes = [session_t]

709

set_default_priority.argtypes = [ClientSession]

688

710

set_default_priority.restype = _error_code

689

711

690

712

record_send = _library.gnutls_record_send

691

record_send.argtypes = [session_t, ctypes.c_void_p,

713

record_send.argtypes = [ClientSession, ctypes.c_void_p,

692

714

ctypes.c_size_t]

693

715

record_send.restype = ctypes.c_ssize_t

694

716

record_send.errcheck = _retry_on_error

696

718

certificate_allocate_credentials = (

697

719

_library.gnutls_certificate_allocate_credentials)

698

720

certificate_allocate_credentials.argtypes = [

699

ctypes.POINTER(certificate_credentials_t)]

721

PointerTo(Credentials)]

700

722

certificate_allocate_credentials.restype = _error_code

701

723

702

724

certificate_free_credentials = (

703

725

_library.gnutls_certificate_free_credentials)

704

certificate_free_credentials.argtypes = [

705

certificate_credentials_t]

726

certificate_free_credentials.argtypes = [Credentials]

706

727

certificate_free_credentials.restype = None

707

728

708

729

handshake_set_private_extensions = (

709

730

_library.gnutls_handshake_set_private_extensions)

710

handshake_set_private_extensions.argtypes = [session_t,

731

handshake_set_private_extensions.argtypes = [ClientSession,

711

732

ctypes.c_int]

712

733

handshake_set_private_extensions.restype = None

713

734

714

735

credentials_set = _library.gnutls_credentials_set

715

credentials_set.argtypes = [session_t, credentials_type_t,

716

ctypes.c_void_p]

736

credentials_set.argtypes = [ClientSession, credentials_type_t,

737

CastToVoidPointer(Credentials)]

717

738

credentials_set.restype = _error_code

718

739

719

740

strerror = _library.gnutls_strerror

721

742

strerror.restype = ctypes.c_char_p

722

743

723

744

certificate_type_get = _library.gnutls_certificate_type_get

724

certificate_type_get.argtypes = [session_t]

745

certificate_type_get.argtypes = [ClientSession]

725

746

certificate_type_get.restype = _error_code

726

747

727

748

certificate_get_peers = _library.gnutls_certificate_get_peers

728

certificate_get_peers.argtypes = [session_t,

749

certificate_get_peers.argtypes = [ClientSession,

729

750

ctypes.POINTER(ctypes.c_uint)]

730

751

certificate_get_peers.restype = ctypes.POINTER(datum_t)

731

752

738

759

global_set_log_function.restype = None

739

760

740

761

deinit = _library.gnutls_deinit

741

deinit.argtypes = [session_t]

762

deinit.argtypes = [ClientSession]

742

763

deinit.restype = None

743

764

744

765

handshake = _library.gnutls_handshake

745

handshake.argtypes = [session_t]

746

handshake.restype = _error_code

766

handshake.argtypes = [ClientSession]

767

handshake.restype = ctypes.c_int

747

768

handshake.errcheck = _retry_on_error

748

769

749

770

transport_set_ptr = _library.gnutls_transport_set_ptr

750

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

771

transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]

751

772

transport_set_ptr.restype = None

752

773

753

774

bye = _library.gnutls_bye

754

bye.argtypes = [session_t, close_request_t]

755

bye.restype = _error_code

775

bye.argtypes = [ClientSession, close_request_t]

776

bye.restype = ctypes.c_int

756

777

bye.errcheck = _retry_on_error

757

778

758

779

check_version = _library.gnutls_check_version

832

853

833

854

if check_version(b"3.6.4"):

834

855

certificate_type_get2 = _library.gnutls_certificate_type_get2

835

certificate_type_get2.argtypes = [session_t, ctypes.c_int]

856

certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]

836

857

certificate_type_get2.restype = _error_code

837

858

838

859

# Remove non-public functions

854

875

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

855

876

856

877

Attributes:

857

approved: bool(); 'None' if not yet approved/disapproved

878

approved: bool(); None if not yet approved/disapproved

858

879

approval_delay: datetime.timedelta(); Time to wait for approval

859

880

approval_duration: datetime.timedelta(); Duration of one approval

860

881

checker: multiprocessing.Process(); a running checker process used

861

to see if the client lives. 'None' if no process is

882

to see if the client lives. None if no process is

862

883

running.

863

884

checker_callback_tag: a GLib event source tag, or None

864

885

checker_command: string; External command which is run to check

940

961

# key_id() and fingerprint() functions

941

962

client["key_id"] = (section.get("key_id", "").upper()

942

963

.replace(" ", ""))

943

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

964

client["fingerprint"] = (section.get("fingerprint",

965

"").upper()

944

966

.replace(" ", ""))

967

if not (client["key_id"] or client["fingerprint"]):

968

log.error("Skipping client %s without key_id or"

969

" fingerprint", client_name)

970

del settings[client_name]

971

continue

945

972

if "secret" in section:

946

973

client["secret"] = codecs.decode(section["secret"]

947

974

.encode("utf-8"),

988

1015

self.last_enabled = None

989

1016

self.expires = None

990

1017

991

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

992

logger.debug(" Key ID: %s", self.key_id)

993

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

1018

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

1019

log.debug(" Key ID: %s", self.key_id)

1020

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

994

1021

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

995

1022

datetime.datetime.utcnow())

996

1023

1024

1051

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

1025

1052

# Already enabled

1026

1053

return

1027

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

1028

1054

self.enabled = True

1029

1055

self.last_enabled = datetime.datetime.utcnow()

1030

1056

self.init_checker()

1035

1061

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

1036

1062

return False

1037

1063

if not quiet:

1038

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

1064

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

1039

1065

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

1040

1066

GLib.source_remove(self.disable_initiator_tag)

1041

1067

self.disable_initiator_tag = None

1053

1079

def __del__(self):

1054

1080

self.disable()

1055

1081

1056

def init_checker(self):

1057

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

1058

# and every interval from then on.

1082

def init_checker(self, randomize_start=False):

1083

# Schedule a new checker to be started a randomly selected

1084

# time (a fraction of 'interval') from now. This spreads out

1085

# the startup of checkers over time when the server is

1086

# started.

1059

1087

if self.checker_initiator_tag is not None:

1060

1088

GLib.source_remove(self.checker_initiator_tag)

1089

interval_milliseconds = int(self.interval.total_seconds()

1090

* 1000)

1091

if randomize_start:

1092

delay_milliseconds = random.randrange(

1093

interval_milliseconds + 1)

1094

else:

1095

delay_milliseconds = interval_milliseconds

1061

1096

self.checker_initiator_tag = GLib.timeout_add(

1062

random.randrange(int(self.interval.total_seconds() * 1000

1063

+ 1)),

1064

self.start_checker)

1065

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

1097

delay_milliseconds, self.start_checker, randomize_start)

1098

delay = datetime.timedelta(0, 0, 0, delay_milliseconds)

1099

# A checker might take up to an 'interval' of time, so we can

1100

# expire at the soonest one interval after a checker was

1101

# started. Since the initial checker is delayed, the expire

1102

# time might have to be extended.

1103

now = datetime.datetime.utcnow()

1104

self.expires = now + delay + self.interval

1105

# Schedule a disable() at expire time

1066

1106

if self.disable_initiator_tag is not None:

1067

1107

GLib.source_remove(self.disable_initiator_tag)

1068

1108

self.disable_initiator_tag = GLib.timeout_add(

1069

int(self.timeout.total_seconds() * 1000), self.disable)

1070

# Also start a new checker *right now*.

1071

self.start_checker()

1109

int((self.expires - now).total_seconds() * 1000),

1110

self.disable)

1072

1111

1073

1112

def checker_callback(self, source, condition, connection,

1074

1113

command):

1085

1124

self.last_checker_status = returncode

1086

1125

self.last_checker_signal = None

1087

1126

if self.last_checker_status == 0:

1088

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

1089

vars(self))

1127

log.info("Checker for %(name)s succeeded", vars(self))

1090

1128

self.checked_ok()

1091

1129

else:

1092

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

1130

log.info("Checker for %(name)s failed", vars(self))

1093

1131

else:

1094

1132

self.last_checker_status = -1

1095

1133

self.last_checker_signal = -returncode

1096

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

1097

vars(self))

1134

log.warning("Checker for %(name)s crashed?", vars(self))

1098

1135

return False

1099

1136

1100

1137

def checked_ok(self):

1119

1156

def need_approval(self):

1120

1157

self.last_approval_request = datetime.datetime.utcnow()

1121

1158

1122

def start_checker(self):

1159

def start_checker(self, start_was_randomized=False):

1123

1160

"""Start a new checker subprocess if one is not running.

1124

1161

1125

1162

If a checker already exists, leave it running and do

1134

1171

# should be.

1135

1172

1136

1173

if self.checker is not None and not self.checker.is_alive():

1137

logger.warning("Checker was not alive; joining")

1174

log.warning("Checker was not alive; joining")

1138

1175

self.checker.join()

1139

1176

self.checker = None

1140

1177

# Start a new checker if needed

1146

1183

try:

1147

1184

command = self.checker_command % escaped_attrs

1148

1185

except TypeError as error:

1149

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

1150

self.checker_command,

1151

exc_info=error)

1186

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

1187

self.checker_command, exc_info=error)

1152

1188

return True # Try again later

1153

1189

self.current_checker_command = command

1154

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

1155

self.name)

1190

log.info("Starting checker %r for %s", command, self.name)

1156

1191

# We don't need to redirect stdout and stderr, since

1157

1192

# in normal mode, that is already done by daemon(),

1158

1193

# and in debug mode we don't want to. (Stdin is

1177

1212

GLib.IOChannel.unix_new(pipe[0].fileno()),

1178

1213

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

1179

1214

self.checker_callback, pipe[0], command)

1215

if start_was_randomized:

1216

# We were started after a random delay; Schedule a new

1217

# checker to be started an 'interval' from now, and every

1218

# interval from then on.

1219

now = datetime.datetime.utcnow()

1220

self.checker_initiator_tag = GLib.timeout_add(

1221

int(self.interval.total_seconds() * 1000),

1222

self.start_checker)

1223

self.expires = max(self.expires, now + self.interval)

1224

# Don't start a new checker again after same random delay

1225

return False

1180

1226

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

1181

1227

return True

1182

1228

1187

1233

self.checker_callback_tag = None

1188

1234

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

1189

1235

return

1190

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

1236

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

1191

1237

self.checker.terminate()

1192

1238

self.checker = None

1193

1239

1220

1266

func._dbus_name = func.__name__

1221

1267

if func._dbus_name.endswith("_dbus_property"):

1222

1268

func._dbus_name = func._dbus_name[:-14]

1223

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

1269

func._dbus_get_args_options = {"byte_arrays": byte_arrays}

1224

1270

return func

1225

1271

1226

1272

return decorator

1315

1361

1316

1362

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1317

1363

out_signature="s",

1318

path_keyword='object_path',

1319

connection_keyword='connection')

1364

path_keyword="object_path",

1365

connection_keyword="connection")

1320

1366

def Introspect(self, object_path, connection):

1321

1367

"""Overloading of standard D-Bus method.

1322

1368

1371

1417

document.unlink()

1372

1418

except (AttributeError, xml.dom.DOMException,

1373

1419

xml.parsers.expat.ExpatError) as error:

1374

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

1375

exc_info=error)

1420

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

1421

exc_info=error)

1376

1422

return xmlstring

1377

1423

1378

1424

1475

1521

1476

1522

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1477

1523

out_signature="s",

1478

path_keyword='object_path',

1479

connection_keyword='connection')

1524

path_keyword="object_path",

1525

connection_keyword="connection")

1480

1526

def Introspect(self, object_path, connection):

1481

1527

"""Overloading of standard D-Bus method.

1482

1528

1538

1584

document.unlink()

1539

1585

except (AttributeError, xml.dom.DOMException,

1540

1586

xml.parsers.expat.ExpatError) as error:

1541

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

1542

exc_info=error)

1587

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

1588

exc_info=error)

1543

1589

return xmlstring

1544

1590

1545

1591

1577

1623

1578

1624

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1579

1625

out_signature="s",

1580

path_keyword='object_path',

1581

connection_keyword='connection')

1626

path_keyword="object_path",

1627

connection_keyword="connection")

1582

1628

def Introspect(self, object_path, connection):

1583

1629

"""Overloading of standard D-Bus method.

1584

1630

1609

1655

document.unlink()

1610

1656

except (AttributeError, xml.dom.DOMException,

1611

1657

xml.parsers.expat.ExpatError) as error:

1612

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

1613

exc_info=error)

1658

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

1659

exc_info=error)

1614

1660

return xmlstring

1615

1661

1616

1662

2250

2296

class ProxyClient:

2251

2297

def __init__(self, child_pipe, key_id, fpr, address):

2252

2298

self._pipe = child_pipe

2253

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

2299

self._pipe.send(("init", key_id, fpr, address))

2254

2300

if not self._pipe.recv():

2255

2301

raise KeyError(key_id or fpr)

2256

2302

2257

2303

def __getattribute__(self, name):

2258

if name == '_pipe':

2304

if name == "_pipe":

2259

2305

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

2260

self._pipe.send(('getattr', name))

2306

self._pipe.send(("getattr", name))

2261

2307

data = self._pipe.recv()

2262

if data[0] == 'data':

2308

if data[0] == "data":

2263

2309

return data[1]

2264

if data[0] == 'function':

2310

if data[0] == "function":

2265

2311

2266

2312

def func(*args, **kwargs):

2267

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

2313

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

2268

2314

return self._pipe.recv()[1]

2269

2315

2270

2316

return func

2271

2317

2272

2318

def __setattr__(self, name, value):

2273

if name == '_pipe':

2319

if name == "_pipe":

2274

2320

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

2275

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

2321

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

2276

2322

2277

2323

2278

2324

class ClientHandler(socketserver.BaseRequestHandler, object):

2283

2329

2284

2330

def handle(self):

2285

2331

with contextlib.closing(self.server.child_pipe) as child_pipe:

2286

logger.info("TCP connection from: %s",

2287

str(self.client_address))

2288

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

2289

self.server.child_pipe.fileno())

2332

log.info("TCP connection from: %s",

2333

str(self.client_address))

2334

log.debug("Pipe FD: %d", self.server.child_pipe.fileno())

2290

2335

2291

2336

session = gnutls.ClientSession(self.request)

2292

2337

2293

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

2338

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

2294

2339

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

2295

2340

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

2296

2341

# "+DHE-DSS"))

2298

2343

priority = self.server.gnutls_priority

2299

2344

if priority is None:

2300

2345

priority = "NORMAL"

2301

gnutls.priority_set_direct(session._c_object,

2302

priority.encode("utf-8"),

2303

None)

2346

gnutls.priority_set_direct(session,

2347

priority.encode("utf-8"), None)

2304

2348

2305

2349

# Start communication using the Mandos protocol

2306

2350

# Get protocol number

2307

2351

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

2308

logger.debug("Protocol version: %r", line)

2352

log.debug("Protocol version: %r", line)

2309

2353

try:

2310

2354

if int(line.strip().split()[0]) > 1:

2311

2355

raise RuntimeError(line)

2312

2356

except (ValueError, IndexError, RuntimeError) as error:

2313

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

2357

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

2314

2358

return

2315

2359

2316

2360

# Start GnuTLS connection

2317

2361

try:

2318

2362

session.handshake()

2319

2363

except gnutls.Error as error:

2320

logger.warning("Handshake failed: %s", error)

2364

log.warning("Handshake failed: %s", error)

2321

2365

# Do not run session.bye() here: the session is not

2322

2366

# established. Just abandon the request.

2323

2367

return

2324

logger.debug("Handshake succeeded")

2368

log.debug("Handshake succeeded")

2325

2369

2326

2370

approval_required = False

2327

2371

try:

2331

2375

key_id = self.key_id(

2332

2376

self.peer_certificate(session))

2333

2377

except (TypeError, gnutls.Error) as error:

2334

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

2378

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

2335

2379

return

2336

logger.debug("Key ID: %s", key_id)

2380

log.debug("Key ID: %s",

2381

key_id.decode("utf-8",

2382

errors="replace"))

2337

2383

2338

2384

else:

2339

2385

key_id = b""

2341

2387

fpr = self.fingerprint(

2342

2388

self.peer_certificate(session))

2343

2389

except (TypeError, gnutls.Error) as error:

2344

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

2390

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

2345

2391

return

2346

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

2392

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

2347

2393

2348

2394

try:

2349

2395

client = ProxyClient(child_pipe, key_id, fpr,

2358

2404

2359

2405

while True:

2360

2406

if not client.enabled:

2361

logger.info("Client %s is disabled",

2362

client.name)

2407

log.info("Client %s is disabled", client.name)

2363

2408

if self.server.use_dbus:

2364

2409

# Emit D-Bus signal

2365

2410

client.Rejected("Disabled")

2369

2414

# We are approved or approval is disabled

2370

2415

break

2371

2416

elif client.approved is None:

2372

logger.info("Client %s needs approval",

2373

client.name)

2417

log.info("Client %s needs approval",

2418

client.name)

2374

2419

if self.server.use_dbus:

2375

2420

# Emit D-Bus signal

2376

2421

client.NeedApproval(

2377

2422

client.approval_delay.total_seconds()

2378

2423

* 1000, client.approved_by_default)

2379

2424

else:

2380

logger.warning("Client %s was not approved",

2381

client.name)

2425

log.warning("Client %s was not approved",

2426

client.name)

2382

2427

if self.server.use_dbus:

2383

2428

# Emit D-Bus signal

2384

2429

client.Rejected("Denied")

2392

2437

time2 = datetime.datetime.now()

2393

2438

if (time2 - time) >= delay:

2394

2439

if not client.approved_by_default:

2395

logger.warning("Client %s timed out while"

2396

" waiting for approval",

2397

client.name)

2440

log.warning("Client %s timed out while"

2441

" waiting for approval",

2442

client.name)

2398

2443

if self.server.use_dbus:

2399

2444

# Emit D-Bus signal

2400

2445

client.Rejected("Approval timed out")

2407

2452

try:

2408

2453

session.send(client.secret)

2409

2454

except gnutls.Error as error:

2410

logger.warning("gnutls send failed",

2411

exc_info=error)

2455

log.warning("gnutls send failed", exc_info=error)

2412

2456

return

2413

2457

2414

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

2458

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

2415

2459

# bump the timeout using extended_timeout

2416

2460

client.bump_timeout(client.extended_timeout)

2417

2461

if self.server.use_dbus:

2424

2468

try:

2425

2469

session.bye()

2426

2470

except gnutls.Error as error:

2427

logger.warning("GnuTLS bye failed",

2428

exc_info=error)

2471

log.warning("GnuTLS bye failed", exc_info=error)

2429

2472

2430

2473

@staticmethod

2431

2474

def peer_certificate(session):

2432

2475

"Return the peer's certificate as a bytestring"

2433

2476

try:

2434

cert_type = gnutls.certificate_type_get2(session._c_object,

2435

gnutls.CTYPE_PEERS)

2477

cert_type = gnutls.certificate_type_get2(

2478

session, gnutls.CTYPE_PEERS)

2436

2479

except AttributeError:

2437

cert_type = gnutls.certificate_type_get(session._c_object)

2480

cert_type = gnutls.certificate_type_get(session)

2438

2481

if gnutls.has_rawpk:

2439

2482

valid_cert_types = frozenset((gnutls.CRT_RAWPK,))

2440

2483

else:

2441

2484

valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))

2442

2485

# If not a valid certificate type...

2443

2486

if cert_type not in valid_cert_types:

2444

logger.info("Cert type %r not in %r", cert_type,

2445

valid_cert_types)

2487

log.info("Cert type %r not in %r", cert_type,

2488

valid_cert_types)

2446

2489

# ...return invalid data

2447

2490

return b""

2448

2491

list_size = ctypes.c_uint(1)

2449

2492

cert_list = (gnutls.certificate_get_peers

2450

(session._c_object, ctypes.byref(list_size)))

2493

(session, ctypes.byref(list_size)))

2451

2494

if not bool(cert_list) and list_size.value != 0:

2452

2495

raise gnutls.Error("error getting peer certificate")

2453

2496

if list_size.value == 0:

2567

2610

2568

2611

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2569

2612

socketserver.TCPServer):

2570

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

2613

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

2571

2614

2572

2615

Attributes:

2573

2616

enabled: Boolean; whether this server is activated yet

2624

2667

if SO_BINDTODEVICE is None:

2625

2668

# Fall back to a hard-coded value which seems to be

2626

2669

# common enough.

2627

logger.warning("SO_BINDTODEVICE not found, trying 25")

2670

log.warning("SO_BINDTODEVICE not found, trying 25")

2628

2671

SO_BINDTODEVICE = 25

2629

2672

try:

2630

2673

self.socket.setsockopt(

2632

2675

(self.interface + "\0").encode("utf-8"))

2633

2676

except socket.error as error:

2634

2677

if error.errno == errno.EPERM:

2635

logger.error("No permission to bind to"

2636

" interface %s", self.interface)

2678

log.error("No permission to bind to interface %s",

2679

self.interface)

2637

2680

elif error.errno == errno.ENOPROTOOPT:

2638

logger.error("SO_BINDTODEVICE not available;"

2639

" cannot bind to interface %s",

2640

self.interface)

2681

log.error("SO_BINDTODEVICE not available; cannot"

2682

" bind to interface %s", self.interface)

2641

2683

elif error.errno == errno.ENODEV:

2642

logger.error("Interface %s does not exist,"

2643

" cannot bind", self.interface)

2684

log.error("Interface %s does not exist, cannot"

2685

" bind", self.interface)

2644

2686

else:

2645

2687

raise

2646

2688

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

2725

2767

request = parent_pipe.recv()

2726

2768

command = request[0]

2727

2769

2728

if command == 'init':

2770

if command == "init":

2729

2771

key_id = request[1].decode("ascii")

2730

2772

fpr = request[2].decode("ascii")

2731

2773

address = request[3]

2741

2783

client = c

2742

2784

break

2743

2785

else:

2744

logger.info("Client not found for key ID: %s, address"

2745

": %s", key_id or fpr, address)

2786

log.info("Client not found for key ID: %s, address:"

2787

" %s", key_id or fpr, address)

2746

2788

if self.use_dbus:

2747

2789

# Emit D-Bus signal

2748

2790

mandos_dbus_service.ClientNotFound(key_id or fpr,

2761

2803

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

2762

2804

# same fileno

2763

2805

return False

2764

if command == 'funcall':

2806

if command == "funcall":

2765

2807

funcname = request[1]

2766

2808

args = request[2]

2767

2809

kwargs = request[3]

2768

2810

2769

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

2811

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

2770

2812

funcname)(*args,

2771

2813

**kwargs)))

2772

2814

2773

if command == 'getattr':

2815

if command == "getattr":

2774

2816

attrname = request[1]

2775

2817

if isinstance(client_object.__getattribute__(attrname),

2776

2818

collections.abc.Callable):

2777

parent_pipe.send(('function', ))

2819

parent_pipe.send(("function", ))

2778

2820

else:

2779

2821

parent_pipe.send((

2780

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

2822

"data", client_object.__getattribute__(attrname)))

2781

2823

2782

if command == 'setattr':

2824

if command == "setattr":

2783

2825

attrname = request[1]

2784

2826

value = request[2]

2785

2827

setattr(client_object, attrname, value)

2891

2933

def string_to_delta(interval):

2892

2934

"""Parse a string and return a datetime.timedelta

2893

2935

2894

>>> string_to_delta('7d') == datetime.timedelta(7)

2895

True

2896

>>> string_to_delta('60s') == datetime.timedelta(0, 60)

2897

True

2898

>>> string_to_delta('60m') == datetime.timedelta(0, 3600)

2899

True

2900

>>> string_to_delta('24h') == datetime.timedelta(1)

2901

True

2902

>>> string_to_delta('1w') == datetime.timedelta(7)

2903

True

2904

>>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)

2936

>>> string_to_delta("7d") == datetime.timedelta(7)

2937

True

2938

>>> string_to_delta("60s") == datetime.timedelta(0, 60)

2939

True

2940

>>> string_to_delta("60m") == datetime.timedelta(0, 3600)

2941

True

2942

>>> string_to_delta("24h") == datetime.timedelta(1)

2943

True

2944

>>> string_to_delta("1w") == datetime.timedelta(7)

2945

True

2946

>>> string_to_delta("5m 30s") == datetime.timedelta(0, 330)

2905

2947

True

2906

2948

"""

2907

2949

3111

3153

3112

3154

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

3113

3155

syslogger.setFormatter(

3114

logging.Formatter('Mandos ({}) [%(process)d]:'

3115

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

3156

logging.Formatter("Mandos ({}) [%(process)d]:"

3157

" %(levelname)s: %(message)s".format(

3116

3158

server_settings["servicename"])))

3117

3159

3118

3160

# Parse config file with clients

3142

3184

try:

3143

3185

pidfile = codecs.open(pidfilename, "w", encoding="utf-8")

3144

3186

except IOError as e:

3145

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

3146

exc_info=e)

3187

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

3188

exc_info=e)

3147

3189

3148

3190

for name, group in (("_mandos", "_mandos"),

3149

3191

("mandos", "mandos"),

3160

3202

try:

3161

3203

os.setgid(gid)

3162

3204

os.setuid(uid)

3163

if debug:

3164

logger.debug("Did setuid/setgid to {}:{}".format(uid,

3165

gid))

3205

log.debug("Did setuid/setgid to %s:%s", uid, gid)

3166

3206

except OSError as error:

3167

logger.warning("Failed to setuid/setgid to {}:{}: {}"

3168

.format(uid, gid, os.strerror(error.errno)))

3207

log.warning("Failed to setuid/setgid to %s:%s: %s", uid, gid,

3208

os.strerror(error.errno))

3169

3209

if error.errno != errno.EPERM:

3170

3210

raise

3171

3211

3178

3218

3179

3219

@gnutls.log_func

3180

3220

def debug_gnutls(level, string):

3181

logger.debug("GnuTLS: %s", string[:-1])

3221

log.debug("GnuTLS: %s",

3222

string[:-1].decode("utf-8", errors="replace"))

3182

3223

3183

3224

gnutls.global_set_log_function(debug_gnutls)

3184

3225

3202

3243

# From the Avahi example code

3203

3244

DBusGMainLoop(set_as_default=True)

3204

3245

main_loop = GLib.MainLoop()

3205

bus = dbus.SystemBus()

3246

if use_dbus or zeroconf:

3247

bus = dbus.SystemBus()

3206

3248

# End of Avahi example code

3207

3249

if use_dbus:

3208

3250

try:

3213

3255

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

3214

3256

do_not_queue=True)

3215

3257

except dbus.exceptions.DBusException as e:

3216

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

3258

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

3217

3259

use_dbus = False

3218

3260

server_settings["use_dbus"] = False

3219

3261

tcp_server.use_dbus = False

3304

3346

os.remove(stored_state_path)

3305

3347

except IOError as e:

3306

3348

if e.errno == errno.ENOENT:

3307

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

3308

" {}".format(os.strerror(e.errno)))

3349

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

3350

" %s", os.strerror(e.errno))

3309

3351

else:

3310

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

3311

exc_info=e)

3352

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

3353

exc_info=e)

3312

3354

raise

3313

3355

except EOFError as e:

3314

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

3315

"EOFError:",

3316

exc_info=e)

3356

log.warning("Could not load persistent state: EOFError:",

3357

exc_info=e)

3317

3358

3318

3359

with PGPEngine() as pgp:

3319

3360

for client_name, client in clients_data.items():

3346

3387

if client["enabled"]:

3347

3388

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

3348

3389

if not client["last_checked_ok"]:

3349

logger.warning(

3350

"disabling client {} - Client never "

3351

"performed a successful checker".format(

3352

client_name))

3390

log.warning("disabling client %s - Client"

3391

" never performed a successful"

3392

" checker", client_name)

3353

3393

client["enabled"] = False

3354

3394

elif client["last_checker_status"] != 0:

3355

logger.warning(

3356

"disabling client {} - Client last"

3357

" checker failed with error code"

3358

" {}".format(

3359

client_name,

3360

client["last_checker_status"]))

3395

log.warning("disabling client %s - Client"

3396

" last checker failed with error"

3397

" code %s", client_name,

3398

client["last_checker_status"])

3361

3399

client["enabled"] = False

3362

3400

else:

3363

3401

client["expires"] = (

3364

3402

datetime.datetime.utcnow()

3365

3403

+ client["timeout"])

3366

logger.debug("Last checker succeeded,"

3367

" keeping {} enabled".format(

3368

client_name))

3404

log.debug("Last checker succeeded, keeping %s"

3405

" enabled", client_name)

3369

3406

try:

3370

3407

client["secret"] = pgp.decrypt(

3371

3408

client["encrypted_secret"],

3372

3409

client_settings[client_name]["secret"])

3373

3410

except PGPError:

3374

3411

# If decryption fails, we use secret from new settings

3375

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

3376

client_name))

3412

log.debug("Failed to decrypt %s old secret",

3413

client_name)

3377

3414

client["secret"] = (client_settings[client_name]

3378

3415

["secret"])

3379

3416

3393

3430

server_settings=server_settings)

3394

3431

3395

3432

if not tcp_server.clients:

3396

logger.warning("No clients defined")

3433

log.warning("No clients defined")

3397

3434

3398

3435

if not foreground:

3399

3436

if pidfile is not None:

3402

3439

with pidfile:

3403

3440

print(pid, file=pidfile)

3404

3441

except IOError:

3405

logger.error("Could not write to file %r with PID %d",

3406

pidfilename, pid)

3442

log.error("Could not write to file %r with PID %d",

3443

pidfilename, pid)

3407

3444

del pidfile

3408

3445

del pidfilename

3409

3446

3559

3596

3560

3597

try:

3561

3598

with tempfile.NamedTemporaryFile(

3562

mode='wb',

3599

mode="wb",

3563

3600

suffix=".pickle",

3564

prefix='clients-',

3601

prefix="clients-",

3565

3602

dir=os.path.dirname(stored_state_path),

3566

3603

delete=False) as stored_state:

3567

3604

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

3575

3612

except NameError:

3576

3613

pass

3577

3614

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

3578

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

3579

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

3615

log.warning("Could not save persistent state: %s",

3616

os.strerror(e.errno))

3580

3617

else:

3581

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

3582

exc_info=e)

3618

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

3619

exc_info=e)

3583

3620

raise

3584

3621

3585

3622

# Delete all clients, and settings from config

3602

3639

mandos_dbus_service.client_added_signal(client)

3603

3640

# Need to initiate checking of clients

3604

3641

if client.enabled:

3605

client.init_checker()

3642

client.init_checker(randomize_start=True)

3606

3643

3607

3644

tcp_server.enable()

3608

3645

tcp_server.server_activate()

3611

3648

if zeroconf:

3612

3649

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

3613

3650

if use_ipv6:

3614

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

3615

" flowinfo %d, scope_id %d",

3616

*tcp_server.socket.getsockname())

3651

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

3652

" scope_id %d", *tcp_server.socket.getsockname())

3617

3653

else: # IPv4

3618

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

3619

*tcp_server.socket.getsockname())

3654

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

3655

*tcp_server.socket.getsockname())

3620

3656

3621

3657

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

3622

3658

3626

3662

try:

3627

3663

service.activate()

3628

3664

except dbus.exceptions.DBusException as error:

3629

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

3665

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

3630

3666

cleanup()

3631

3667

sys.exit(1)

3632

3668

# End of Avahi example code

3637

3673

lambda *args, **kwargs: (tcp_server.handle_request

3638

3674

(*args[2:], **kwargs) or True))

3639

3675

3640

logger.debug("Starting main loop")

3676

log.debug("Starting main loop")

3641

3677

main_loop.run()

3642

3678

except AvahiError as error:

3643

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

3679

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

3644

3680

cleanup()

3645

3681

sys.exit(1)

3646

3682

except KeyboardInterrupt:

3647

3683

if debug:

3648

3684

print("", file=sys.stderr)

3649

logger.debug("Server received KeyboardInterrupt")

3650

logger.debug("Server exiting")

3685

log.debug("Server received KeyboardInterrupt")

3686

log.debug("Server exiting")

3651

3687

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

3652

3688

cleanup()

3653

3689

3654

3690

3655

def should_only_run_tests():

3691

def parse_test_args():

3692

# type: () -> argparse.Namespace

3656

3693

parser = argparse.ArgumentParser(add_help=False)

3657

parser.add_argument("--check", action='store_true')

3694

parser.add_argument("--check", action="store_true")

3695

parser.add_argument("--prefix", )

3658

3696

args, unknown_args = parser.parse_known_args()

3659

run_tests = args.check

3660

if run_tests:

3661

# Remove --check argument from sys.argv

3697

if args.check:

3698

# Remove test options from sys.argv

3662

3699

sys.argv[1:] = unknown_args

3663

return run_tests

3700

return args

3664

3701

3665

3702

# Add all tests from doctest strings

3666

3703

def load_tests(loader, tests, none):

3668

3705

tests.addTests(doctest.DocTestSuite())

3669

3706

return tests

3670

3707

3671

if __name__ == '__main__':

3708

if __name__ == "__main__":

3709

options = parse_test_args()

3672

3710

try:

3673

if should_only_run_tests():

3674

# Call using ./mandos --check [--verbose]

3675

unittest.main()

3711

if options.check:

3712

extra_test_prefix = options.prefix

3713

if extra_test_prefix is not None:

3714

if not (unittest.main(argv=[""], exit=False)

3715

.result.wasSuccessful()):

3716

sys.exit(1)

3717

class ExtraTestLoader(unittest.TestLoader):

3718

testMethodPrefix = extra_test_prefix

3719

# Call using ./scriptname --test [--verbose]

3720

unittest.main(argv=[""], testLoader=ExtraTestLoader())

3721

else:

3722

unittest.main(argv=[""])

3676

3723

else:

3677

3724

main()

3678

3725

finally:

3679

3726

logging.shutdown()

3727

3728

# Local Variables:

3729

# run-tests:

3730

# (lambda (&optional extra)

3731

# (if (not (funcall run-tests-in-test-buffer default-directory

3732

# extra))

3733

# (funcall show-test-buffer-in-test-window)

3734

# (funcall remove-test-window)

3735

# (if extra (message "Extra tests run successfully!"))))

3736

# run-tests-in-test-buffer:

3737

# (lambda (dir &optional extra)

3738

# (with-current-buffer (get-buffer-create "*Test*")

3739

# (setq buffer-read-only nil

3740

# default-directory dir)

3741

# (erase-buffer)

3742

# (compilation-mode))

3743

# (let ((process-result

3744

# (let ((inhibit-read-only t))

3745

# (process-file-shell-command

3746

# (funcall get-command-line extra) nil "*Test*"))))

3747

# (and (numberp process-result)

3748

# (= process-result 0))))

3749

# get-command-line:

3750

# (lambda (&optional extra)

3751

# (let ((quoted-script

3752

# (shell-quote-argument (funcall get-script-name))))

3753

# (format

3754

# (concat "%s --check" (if extra " --prefix=atest" ""))

3755

# quoted-script)))

3756

# get-script-name:

3757

# (lambda ()

3758

# (if (fboundp 'file-local-name)

3759

# (file-local-name (buffer-file-name))

3760

# (or (file-remote-p (buffer-file-name) 'localname)

3761

# (buffer-file-name))))

3762

# remove-test-window:

3763

# (lambda ()

3764

# (let ((test-window (get-buffer-window "*Test*")))

3765

# (if test-window (delete-window test-window))))

3766

# show-test-buffer-in-test-window:

3767

# (lambda ()

3768

# (when (not (get-buffer-window-list "*Test*"))

3769

# (setq next-error-last-buffer (get-buffer "*Test*"))

3770

# (let* ((side (if (>= (window-width) 146) 'right 'bottom))

3771

# (display-buffer-overriding-action

3772

# `((display-buffer-in-side-window) (side . ,side)

3773

# (window-height . fit-window-to-buffer)

3774

# (window-width . fit-window-to-buffer))))

3775

# (display-buffer "*Test*"))))

3776

# eval:

3777

# (progn

3778

# (let* ((run-extra-tests (lambda () (interactive)

3779

# (funcall run-tests t)))

3780

# (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t

3781

# (outer-keymap `(keymap (3 . ,inner-keymap)))) ; C-c

3782

# (setq minor-mode-overriding-map-alist

3783

# (cons `(run-tests . ,outer-keymap)

3784

# minor-mode-overriding-map-alist)))

3785

# (add-hook 'after-save-hook run-tests 90 t))

3786

# End: