/mandos/trunk : revision 237.4.80

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

#

3

#

4

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

5

#

5

#

6

# This program is partly derived from an example program for an Avahi

7

# service publisher, downloaded from

8

# <http://avahi.org/wiki/PythonPublishExample>. This includes the

9

# methods "add", "remove", "server_state_changed",

10

# "entry_group_state_changed", "cleanup", and "activate" in the

11

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

12

#

12

#

13

# Everything else is

14

15

16

#

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

19

# the Free Software Foundation, either version 3 of the License, or

23

# but WITHOUT ANY WARRANTY; without even the implied warranty of

24

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

25

# GNU General Public License for more details.

26

#

26

#

27

# You should have received a copy of the GNU General Public License

28

# along with this program. If not, see

29

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

30

#

30

#

31

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

32

#

32

#

33

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

114

if sys.version_info.major == 2:

115

str = unicode

116

117

version = "1.7.15"

117

version = "1.7.10"

118

stored_state_file = "clients.pickle"

119

120

logger = logging.getLogger()

124

if_nametoindex = ctypes.cdll.LoadLibrary(

125

ctypes.util.find_library("c")).if_nametoindex

126

except (OSError, AttributeError):

127

128

def if_nametoindex(interface):

129

"Get an interface index the hard way, i.e. using fcntl()"

130

SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h

153

154

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

155

"""init logger and add loglevel"""

156

157

global syslogger

158

syslogger = (logging.handlers.SysLogHandler(

159

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

160

address="/dev/log"))

159

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

160

address = "/dev/log"))

161

syslogger.setFormatter(logging.Formatter

162

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

163

' %(message)s'))

164

logger.addHandler(syslogger)

165

166

if debug:

167

console = logging.StreamHandler()

168

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

180

181

class PGPEngine(object):

182

"""A simple class for OpenPGP symmetric encryption & decryption"""

183

184

def __init__(self):

185

self.tempdir = tempfile.mkdtemp(prefix="mandos-")

186

self.gpg = "gpg"

201

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

202

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

203

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

204

205

def __enter__(self):

206

return self

207

208

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

209

self._cleanup()

210

return False

211

212

def __del__(self):

213

self._cleanup()

214

215

def _cleanup(self):

216

if self.tempdir is not None:

217

# Delete contents of tempdir

218

for root, dirs, files in os.walk(self.tempdir,

219

topdown=False):

219

topdown = False):

220

for filename in files:

221

os.remove(os.path.join(root, filename))

222

for dirname in dirs:

224

# Remove tempdir

225

os.rmdir(self.tempdir)

226

self.tempdir = None

227

228

def password_encode(self, password):

229

# Passphrase can not be empty and can not contain newlines or

230

# NUL bytes. So we prefix it and hex encode it.

235

.replace(b"\n", b"\\n")

236

.replace(b"\0", b"\\x00"))

237

return encoded

238

239

def encrypt(self, data, password):

240

passphrase = self.password_encode(password)

241

with tempfile.NamedTemporaryFile(

246

'--passphrase-file',

247

passfile.name]

248

+ self.gnupgargs,

249

stdin=subprocess.PIPE,

250

stdout=subprocess.PIPE,

251

stderr=subprocess.PIPE)

252

ciphertext, err = proc.communicate(input=data)

249

stdin = subprocess.PIPE,

250

stdout = subprocess.PIPE,

251

stderr = subprocess.PIPE)

252

ciphertext, err = proc.communicate(input = data)

253

if proc.returncode != 0:

254

raise PGPError(err)

255

return ciphertext

256

257

def decrypt(self, data, password):

258

passphrase = self.password_encode(password)

259

with tempfile.NamedTemporaryFile(

260

dir=self.tempdir) as passfile:

260

dir = self.tempdir) as passfile:

261

passfile.write(passphrase)

262

passfile.flush()

263

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

264

'--passphrase-file',

265

passfile.name]

266

+ self.gnupgargs,

267

stdin=subprocess.PIPE,

268

stdout=subprocess.PIPE,

269

stderr=subprocess.PIPE)

270

decrypted_plaintext, err = proc.communicate(input=data)

267

stdin = subprocess.PIPE,

268

stdout = subprocess.PIPE,

269

stderr = subprocess.PIPE)

270

decrypted_plaintext, err = proc.communicate(input = data)

271

if proc.returncode != 0:

272

raise PGPError(err)

273

return decrypted_plaintext

274

275

276

275

# Pretend that we have an Avahi module

277

276

class Avahi(object):

278

277

"""This isn't so much a class as it is a module-like namespace.

279

278

It is instantiated once, and simulates having an Avahi module."""

280

IF_UNSPEC = -1 # avahi-common/address.h

281

PROTO_UNSPEC = -1 # avahi-common/address.h

282

PROTO_INET = 0 # avahi-common/address.h

283

PROTO_INET6 = 1 # avahi-common/address.h

279

IF_UNSPEC = -1 # avahi-common/address.h

280

PROTO_UNSPEC = -1 # avahi-common/address.h

281

PROTO_INET = 0 # avahi-common/address.h

282

PROTO_INET6 = 1 # avahi-common/address.h

284

283

DBUS_NAME = "org.freedesktop.Avahi"

285

284

DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"

286

285

DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"

287

286

DBUS_PATH_SERVER = "/"

288

289

287

def string_array_to_txt_array(self, t):

290

288

return dbus.Array((dbus.ByteArray(s.encode("utf-8"))

291

289

for s in t), signature="ay")

292

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

293

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

294

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

295

SERVER_INVALID = 0 # avahi-common/defs.h

296

SERVER_REGISTERING = 1 # avahi-common/defs.h

297

SERVER_RUNNING = 2 # avahi-common/defs.h

298

SERVER_COLLISION = 3 # avahi-common/defs.h

299

SERVER_FAILURE = 4 # avahi-common/defs.h

290

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

291

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

292

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

293

SERVER_INVALID = 0 # avahi-common/defs.h

294

SERVER_REGISTERING = 1 # avahi-common/defs.h

295

SERVER_RUNNING = 2 # avahi-common/defs.h

296

SERVER_COLLISION = 3 # avahi-common/defs.h

297

SERVER_FAILURE = 4 # avahi-common/defs.h

300

298

avahi = Avahi()

301

299

302

303

300

class AvahiError(Exception):

304

301

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

305

302

self.value = value

317

314

318

315

class AvahiService(object):

319

316

"""An Avahi (Zeroconf) service.

320

317

321

318

Attributes:

322

319

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

323

320

Used to optionally bind to the specified interface.

335

332

server: D-Bus Server

336

333

bus: dbus.SystemBus()

337

334

"""

338

335

339

336

def __init__(self,

340

interface=avahi.IF_UNSPEC,

341

name=None,

342

servicetype=None,

343

port=None,

344

TXT=None,

345

domain="",

346

host="",

347

max_renames=32768,

348

protocol=avahi.PROTO_UNSPEC,

349

bus=None):

337

interface = avahi.IF_UNSPEC,

338

name = None,

339

servicetype = None,

340

port = None,

341

TXT = None,

342

domain = "",

343

host = "",

344

max_renames = 32768,

345

protocol = avahi.PROTO_UNSPEC,

346

bus = None):

350

347

self.interface = interface

351

348

self.name = name

352

349

self.type = servicetype

361

358

self.server = None

362

359

self.bus = bus

363

360

self.entry_group_state_changed_match = None

364

361

365

362

def rename(self, remove=True):

366

363

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

367

364

if self.rename_count >= self.max_renames:

387

384

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

388

385

self.cleanup()

389

386

os._exit(1)

390

387

391

388

def remove(self):

392

389

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

393

390

if self.entry_group_state_changed_match is not None:

395

392

self.entry_group_state_changed_match = None

396

393

if self.group is not None:

397

394

self.group.Reset()

398

395

399

396

def add(self):

400

397

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

401

398

self.remove()

418

415

dbus.UInt16(self.port),

419

416

avahi.string_array_to_txt_array(self.TXT))

420

417

self.group.Commit()

421

418

422

419

def entry_group_state_changed(self, state, error):

423

420

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

424

421

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

425

422

426

423

if state == avahi.ENTRY_GROUP_ESTABLISHED:

427

424

logger.debug("Zeroconf service established.")

428

425

elif state == avahi.ENTRY_GROUP_COLLISION:

432

429

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

433

430

str(error))

434

431

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

435

432

436

433

def cleanup(self):

437

434

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

438

435

if self.group is not None:

443

440

pass

444

441

self.group = None

445

442

self.remove()

446

443

447

444

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

448

445

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

449

446

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

478

475

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

479

476

else:

480

477

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

481

478

482

479

def activate(self):

483

480

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

484

481

if self.server is None:

501

498

.format(self.name)))

502

499

return ret

503

500

504

505

501

# Pretend that we have a GnuTLS module

506

502

class GnuTLS(object):

507

503

"""This isn't so much a class as it is a module-like namespace.

508

504

It is instantiated once, and simulates having a GnuTLS module."""

509

510

library = ctypes.util.find_library("gnutls")

511

if library is None:

512

library = ctypes.util.find_library("gnutls-deb0")

513

_library = ctypes.cdll.LoadLibrary(library)

514

del library

505

506

_library = ctypes.cdll.LoadLibrary(

507

ctypes.util.find_library("gnutls"))

515

508

_need_version = b"3.3.0"

516

517

509

def __init__(self):

518

# Need to use "self" here, since this method is called before

519

# the assignment to the "gnutls" global variable happens.

520

if self.check_version(self._need_version) is None:

521

raise self.Error("Needs GnuTLS {} or later"

522

.format(self._need_version))

523

510

# Need to use class name "GnuTLS" here, since this method is

511

# called before the assignment to the "gnutls" global variable

512

# happens.

513

if GnuTLS.check_version(self._need_version) is None:

514

raise GnuTLS.Error("Needs GnuTLS {} or later"

515

.format(self._need_version))

516

524

517

# Unless otherwise indicated, the constants and types below are

525

518

# all from the gnutls/gnutls.h C header file.

526

519

527

520

# Constants

528

521

E_SUCCESS = 0

529

522

E_INTERRUPTED = -52

534

527

CRD_CERTIFICATE = 1

535

528

E_NO_CERTIFICATE_FOUND = -49

536

529

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

537

530

538

531

# Types

539

532

class session_int(ctypes.Structure):

540

533

_fields_ = []

541

534

session_t = ctypes.POINTER(session_int)

542

543

535

class certificate_credentials_st(ctypes.Structure):

544

536

_fields_ = []

545

537

certificate_credentials_t = ctypes.POINTER(

546

538

certificate_credentials_st)

547

539

certificate_type_t = ctypes.c_int

548

549

540

class datum_t(ctypes.Structure):

550

541

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

551

542

('size', ctypes.c_uint)]

552

553

543

class openpgp_crt_int(ctypes.Structure):

554

544

_fields_ = []

555

545

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

556

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

546

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

557

547

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

558

548

credentials_type_t = ctypes.c_int

559

549

transport_ptr_t = ctypes.c_void_p

560

550

close_request_t = ctypes.c_int

561

551

562

552

# Exceptions

563

553

class Error(Exception):

564

554

# We need to use the class name "GnuTLS" here, since this

565

555

# exception might be raised from within GnuTLS.__init__,

566

556

# which is called before the assignment to the "gnutls"

567

557

# global variable has happened.

568

def __init__(self, message=None, code=None, args=()):

558

def __init__(self, message = None, code = None, args=()):

569

559

# Default usage is by a message string, but if a return

570

560

# code is passed, convert it to a string with

571

561

# gnutls.strerror()

574

564

message = GnuTLS.strerror(code)

575

565

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

576

566

message, *args)

577

567

578

568

class CertificateSecurityError(Error):

579

569

pass

580

570

581

571

# Classes

582

572

class Credentials(object):

583

573

def __init__(self):

585

575

gnutls.certificate_allocate_credentials(

586

576

ctypes.byref(self._c_object))

587

577

self.type = gnutls.CRD_CERTIFICATE

588

578

589

579

def __del__(self):

590

580

gnutls.certificate_free_credentials(self._c_object)

591

581

592

582

class ClientSession(object):

593

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

583

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

594

584

self._c_object = gnutls.session_t()

595

585

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

596

586

gnutls.set_default_priority(self._c_object)

604

594

ctypes.cast(credentials._c_object,

605

595

ctypes.c_void_p))

606

596

self.credentials = credentials

607

597

608

598

def __del__(self):

609

599

gnutls.deinit(self._c_object)

610

600

611

601

def handshake(self):

612

602

return gnutls.handshake(self._c_object)

613

603

614

604

def send(self, data):

615

605

data = bytes(data)

616

606

data_len = len(data)

618

608

data_len -= gnutls.record_send(self._c_object,

619

609

data[-data_len:],

620

610

data_len)

621

611

622

612

def bye(self):

623

613

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

624

614

625

615

# Error handling functions

626

616

def _error_code(result):

627

617

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

629

619

if result >= 0:

630

620

return result

631

621

if result == gnutls.E_NO_CERTIFICATE_FOUND:

632

raise gnutls.CertificateSecurityError(code=result)

633

raise gnutls.Error(code=result)

634

622

raise gnutls.CertificateSecurityError(code = result)

623

raise gnutls.Error(code = result)

624

635

625

def _retry_on_error(result, func, arguments):

636

626

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

637

627

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

640

630

return _error_code(result)

641

631

result = func(*arguments)

642

632

return result

643

633

644

634

# Unless otherwise indicated, the function declarations below are

645

635

# all from the gnutls/gnutls.h C header file.

646

636

647

637

# Functions

648

638

priority_set_direct = _library.gnutls_priority_set_direct

649

639

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

650

640

ctypes.POINTER(ctypes.c_char_p)]

651

641

priority_set_direct.restype = _error_code

652

642

653

643

init = _library.gnutls_init

654

644

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

655

645

init.restype = _error_code

656

646

657

647

set_default_priority = _library.gnutls_set_default_priority

658

648

set_default_priority.argtypes = [session_t]

659

649

set_default_priority.restype = _error_code

660

650

661

651

record_send = _library.gnutls_record_send

662

652

record_send.argtypes = [session_t, ctypes.c_void_p,

663

653

ctypes.c_size_t]

664

654

record_send.restype = ctypes.c_ssize_t

665

655

record_send.errcheck = _retry_on_error

666

656

667

657

certificate_allocate_credentials = (

668

658

_library.gnutls_certificate_allocate_credentials)

669

659

certificate_allocate_credentials.argtypes = [

670

660

ctypes.POINTER(certificate_credentials_t)]

671

661

certificate_allocate_credentials.restype = _error_code

672

662

673

663

certificate_free_credentials = (

674

664

_library.gnutls_certificate_free_credentials)

675

certificate_free_credentials.argtypes = [

676

certificate_credentials_t]

665

certificate_free_credentials.argtypes = [certificate_credentials_t]

677

666

certificate_free_credentials.restype = None

678

667

679

668

handshake_set_private_extensions = (

680

669

_library.gnutls_handshake_set_private_extensions)

681

670

handshake_set_private_extensions.argtypes = [session_t,

682

671

ctypes.c_int]

683

672

handshake_set_private_extensions.restype = None

684

673

685

674

credentials_set = _library.gnutls_credentials_set

686

675

credentials_set.argtypes = [session_t, credentials_type_t,

687

676

ctypes.c_void_p]

688

677

credentials_set.restype = _error_code

689

678

690

679

strerror = _library.gnutls_strerror

691

680

strerror.argtypes = [ctypes.c_int]

692

681

strerror.restype = ctypes.c_char_p

693

682

694

683

certificate_type_get = _library.gnutls_certificate_type_get

695

684

certificate_type_get.argtypes = [session_t]

696

685

certificate_type_get.restype = _error_code

697

686

698

687

certificate_get_peers = _library.gnutls_certificate_get_peers

699

688

certificate_get_peers.argtypes = [session_t,

700

689

ctypes.POINTER(ctypes.c_uint)]

701

690

certificate_get_peers.restype = ctypes.POINTER(datum_t)

702

691

703

692

global_set_log_level = _library.gnutls_global_set_log_level

704

693

global_set_log_level.argtypes = [ctypes.c_int]

705

694

global_set_log_level.restype = None

706

695

707

696

global_set_log_function = _library.gnutls_global_set_log_function

708

697

global_set_log_function.argtypes = [log_func]

709

698

global_set_log_function.restype = None

710

699

711

700

deinit = _library.gnutls_deinit

712

701

deinit.argtypes = [session_t]

713

702

deinit.restype = None

714

703

715

704

handshake = _library.gnutls_handshake

716

705

handshake.argtypes = [session_t]

717

706

handshake.restype = _error_code

718

707

handshake.errcheck = _retry_on_error

719

708

720

709

transport_set_ptr = _library.gnutls_transport_set_ptr

721

710

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

722

711

transport_set_ptr.restype = None

723

712

724

713

bye = _library.gnutls_bye

725

714

bye.argtypes = [session_t, close_request_t]

726

715

bye.restype = _error_code

727

716

bye.errcheck = _retry_on_error

728

717

729

718

check_version = _library.gnutls_check_version

730

719

check_version.argtypes = [ctypes.c_char_p]

731

720

check_version.restype = ctypes.c_char_p

732

721

733

722

# All the function declarations below are from gnutls/openpgp.h

734

723

735

724

openpgp_crt_init = _library.gnutls_openpgp_crt_init

736

725

openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]

737

726

openpgp_crt_init.restype = _error_code

738

727

739

728

openpgp_crt_import = _library.gnutls_openpgp_crt_import

740

729

openpgp_crt_import.argtypes = [openpgp_crt_t,

741

730

ctypes.POINTER(datum_t),

742

731

openpgp_crt_fmt_t]

743

732

openpgp_crt_import.restype = _error_code

744

733

745

734

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

746

735

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

747

736

ctypes.POINTER(ctypes.c_uint)]

748

737

openpgp_crt_verify_self.restype = _error_code

749

738

750

739

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

751

740

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

752

741

openpgp_crt_deinit.restype = None

753

742

754

743

openpgp_crt_get_fingerprint = (

755

744

_library.gnutls_openpgp_crt_get_fingerprint)

756

745

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

758

747

ctypes.POINTER(

759

748

ctypes.c_size_t)]

760

749

openpgp_crt_get_fingerprint.restype = _error_code

761

750

762

751

# Remove non-public functions

763

752

del _error_code, _retry_on_error

764

753

# Create the global "gnutls" object, simulating a module

765

754

gnutls = GnuTLS()

766

755

767

768

756

def call_pipe(connection, # : multiprocessing.Connection

769

757

func, *args, **kwargs):

770

758

"""This function is meant to be called by multiprocessing.Process

771

759

772

760

This function runs func(*args, **kwargs), and writes the resulting

773

761

return value on the provided multiprocessing.Connection.

774

762

"""

775

763

connection.send(func(*args, **kwargs))

776

764

connection.close()

777

765

778

779

766

class Client(object):

780

767

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

781

768

782

769

Attributes:

783

770

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

784

771

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

821

808

disabled, or None

822

809

server_settings: The server_settings dict from main()

823

810

"""

824

811

825

812

runtime_expansions = ("approval_delay", "approval_duration",

826

813

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

827

814

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

838

825

"approved_by_default": "True",

839

826

"enabled": "True",

840

827

}

841

828

842

829

@staticmethod

843

830

def config_parser(config):

844

831

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

851

838

for client_name in config.sections():

852

839

section = dict(config.items(client_name))

853

840

client = settings[client_name] = {}

854

841

855

842

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

856

843

# Reformat values from string types to Python types

857

844

client["approved_by_default"] = config.getboolean(

858

845

client_name, "approved_by_default")

859

846

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

860

847

"enabled")

861

848

862

849

# Uppercase and remove spaces from fingerprint for later

863

850

# comparison purposes with return value from the

864

851

# fingerprint() function

888

875

client["last_approval_request"] = None

889

876

client["last_checked_ok"] = None

890

877

client["last_checker_status"] = -2

891

878

892

879

return settings

893

894

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

880

881

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

895

882

self.name = name

896

883

if server_settings is None:

897

884

server_settings = {}

899

886

# adding all client settings

900

887

for setting, value in settings.items():

901

888

setattr(self, setting, value)

902

889

903

890

if self.enabled:

904

891

if not hasattr(self, "last_enabled"):

905

892

self.last_enabled = datetime.datetime.utcnow()

909

896

else:

910

897

self.last_enabled = None

911

898

self.expires = None

912

899

913

900

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

914

901

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

915

902

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

916

903

datetime.datetime.utcnow())

917

904

918

905

# attributes specific for this server instance

919

906

self.checker = None

920

907

self.checker_initiator_tag = None

929

916

for attr in self.__dict__.keys()

930

917

if not attr.startswith("_")]

931

918

self.client_structure.append("client_structure")

932

919

933

920

for name, t in inspect.getmembers(

934

921

type(self), lambda obj: isinstance(obj, property)):

935

922

if not name.startswith("_"):

936

923

self.client_structure.append(name)

937

924

938

925

# Send notice to process children that client state has changed

939

926

def send_changedstate(self):

940

927

with self.changedstate:

941

928

self.changedstate.notify_all()

942

929

943

930

def enable(self):

944

931

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

945

932

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

950

937

self.last_enabled = datetime.datetime.utcnow()

951

938

self.init_checker()

952

939

self.send_changedstate()

953

940

954

941

def disable(self, quiet=True):

955

942

"""Disable this client."""

956

943

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

970

957

self.send_changedstate()

971

958

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

972

959

return False

973

960

974

961

def __del__(self):

975

962

self.disable()

976

963

977

964

def init_checker(self):

978

965

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

979

966

# and every interval from then on.

989

976

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

990

977

# Also start a new checker *right now*.

991

978

self.start_checker()

992

979

993

980

def checker_callback(self, source, condition, connection,

994

981

command):

995

982

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

998

985

# Read return code from connection (see call_pipe)

999

986

returncode = connection.recv()

1000

987

connection.close()

1001

988

1002

989

if returncode >= 0:

1003

990

self.last_checker_status = returncode

1004

991

self.last_checker_signal = None

1014

1001

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

1015

1002

vars(self))

1016

1003

return False

1017

1004

1018

1005

def checked_ok(self):

1019

1006

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

1020

1007

self.last_checked_ok = datetime.datetime.utcnow()

1021

1008

self.last_checker_status = 0

1022

1009

self.last_checker_signal = None

1023

1010

self.bump_timeout()

1024

1011

1025

1012

def bump_timeout(self, timeout=None):

1026

1013

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

1027

1014

if timeout is None:

1033

1020

self.disable_initiator_tag = GLib.timeout_add(

1034

1021

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

1035

1022

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

1036

1023

1037

1024

def need_approval(self):

1038

1025

self.last_approval_request = datetime.datetime.utcnow()

1039

1026

1040

1027

def start_checker(self):

1041

1028

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

1042

1029

1043

1030

If a checker already exists, leave it running and do

1044

1031

nothing."""

1045

1032

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

1050

1037

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

1051

1038

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

1052

1039

# should be.

1053

1040

1054

1041

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

1055

1042

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

1056

1043

self.checker.join()

1060

1047

# Escape attributes for the shell

1061

1048

escaped_attrs = {

1062

1049

attr: re.escape(str(getattr(self, attr)))

1063

for attr in self.runtime_expansions}

1050

for attr in self.runtime_expansions }

1064

1051

try:

1065

1052

command = self.checker_command % escaped_attrs

1066

1053

except TypeError as error:

1078

1065

# The exception is when not debugging but nevertheless

1079

1066

# running in the foreground; use the previously

1080

1067

# created wnull.

1081

popen_args = {"close_fds": True,

1082

"shell": True,

1083

"cwd": "/"}

1068

popen_args = { "close_fds": True,

1069

"shell": True,

1070

"cwd": "/" }

1084

1071

if (not self.server_settings["debug"]

1085

1072

and self.server_settings["foreground"]):

1086

1073

popen_args.update({"stdout": wnull,

1087

"stderr": wnull})

1088

pipe = multiprocessing.Pipe(duplex=False)

1074

"stderr": wnull })

1075

pipe = multiprocessing.Pipe(duplex = False)

1089

1076

self.checker = multiprocessing.Process(

1090

target=call_pipe,

1091

args=(pipe[1], subprocess.call, command),

1092

kwargs=popen_args)

1077

target = call_pipe,

1078

args = (pipe[1], subprocess.call, command),

1079

kwargs = popen_args)

1093

1080

self.checker.start()

1094

1081

self.checker_callback_tag = GLib.io_add_watch(

1095

1082

pipe[0].fileno(), GLib.IO_IN,

1096

1083

self.checker_callback, pipe[0], command)

1097

1084

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

1098

1085

return True

1099

1086

1100

1087

def stop_checker(self):

1101

1088

"""Force the checker process, if any, to stop."""

1102

1089

if self.checker_callback_tag:

1115

1102

byte_arrays=False):

1116

1103

"""Decorators for marking methods of a DBusObjectWithProperties to

1117

1104

become properties on the D-Bus.

1118

1105

1119

1106

The decorated method will be called with no arguments by "Get"

1120

1107

and with one argument by "Set".

1121

1108

1122

1109

The parameters, where they are supported, are the same as

1123

1110

dbus.service.method, except there is only "signature", since the

1124

1111

type from Get() and the type sent to Set() is the same.

1128

1115

if byte_arrays and signature != "ay":

1129

1116

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

1130

1117

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

1131

1118

1132

1119

def decorator(func):

1133

1120

func._dbus_is_property = True

1134

1121

func._dbus_interface = dbus_interface

1137

1124

func._dbus_name = func.__name__

1138

1125

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

1139

1126

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

1140

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

1127

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1141

1128

return func

1142

1129

1143

1130

return decorator

1144

1131

1145

1132

1146

1133

def dbus_interface_annotations(dbus_interface):

1147

1134

"""Decorator for marking functions returning interface annotations

1148

1135

1149

1136

Usage:

1150

1137

1151

1138

@dbus_interface_annotations("org.example.Interface")

1152

1139

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

1153

1140

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

1154

1141

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

1155

1142

"false"}

1156

1143

"""

1157

1144

1158

1145

def decorator(func):

1159

1146

func._dbus_is_interface = True

1160

1147

func._dbus_interface = dbus_interface

1161

1148

func._dbus_name = dbus_interface

1162

1149

return func

1163

1150

1164

1151

return decorator

1165

1152

1166

1153

1167

1154

def dbus_annotations(annotations):

1168

1155

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

1169

1156

Usage:

1170

1157

1171

1158

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

1172

1159

"org.freedesktop.DBus.Property."

1173

1160

"EmitsChangedSignal": "false"})

1175

1162

access="r")

1176

1163

def Property_dbus_property(self):

1177

1164

return dbus.Boolean(False)

1178

1165

1179

1166

See also the DBusObjectWithAnnotations class.

1180

1167

"""

1181

1168

1182

1169

def decorator(func):

1183

1170

func._dbus_annotations = annotations

1184

1171

return func

1185

1172

1186

1173

return decorator

1187

1174

1188

1175

1206

1193

1207

1194

class DBusObjectWithAnnotations(dbus.service.Object):

1208

1195

"""A D-Bus object with annotations.

1209

1196

1210

1197

Classes inheriting from this can use the dbus_annotations

1211

1198

decorator to add annotations to methods or signals.

1212

1199

"""

1213

1200

1214

1201

@staticmethod

1215

1202

def _is_dbus_thing(thing):

1216

1203

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

1217

1204

1218

1205

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

1219

1206

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

1220

1207

"""

1221

1208

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

1222

1209

False)

1223

1210

1224

1211

def _get_all_dbus_things(self, thing):

1225

1212

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

1226

1213

"""

1229

1216

for cls in self.__class__.__mro__

1230

1217

for name, athing in

1231

1218

inspect.getmembers(cls, self._is_dbus_thing(thing)))

1232

1219

1233

1220

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1234

out_signature="s",

1235

path_keyword='object_path',

1236

connection_keyword='connection')

1221

out_signature = "s",

1222

path_keyword = 'object_path',

1223

connection_keyword = 'connection')

1237

1224

def Introspect(self, object_path, connection):

1238

1225

"""Overloading of standard D-Bus method.

1239

1226

1240

1227

Inserts annotation tags on methods and signals.

1241

1228

"""

1242

1229

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

1243

1230

connection)

1244

1231

try:

1245

1232

document = xml.dom.minidom.parseString(xmlstring)

1246

1233

1247

1234

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

1248

1235

# Add annotation tags

1249

1236

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

1276

1263

if_tag.appendChild(ann_tag)

1277

1264

# Fix argument name for the Introspect method itself

1278

1265

if (if_tag.getAttribute("name")

1279

== dbus.INTROSPECTABLE_IFACE):

1266

== dbus.INTROSPECTABLE_IFACE):

1280

1267

for cn in if_tag.getElementsByTagName("method"):

1281

1268

if cn.getAttribute("name") == "Introspect":

1282

1269

for arg in cn.getElementsByTagName("arg"):

1295

1282

1296

1283

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1297

1284

"""A D-Bus object with properties.

1298

1285

1299

1286

Classes inheriting from this can use the dbus_service_property

1300

1287

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

1301

1288

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

1302

1289

"""

1303

1290

1304

1291

def _get_dbus_property(self, interface_name, property_name):

1305

1292

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

1306

1293

property with the specified name and interface.

1311

1298

if (value._dbus_name == property_name

1312

1299

and value._dbus_interface == interface_name):

1313

1300

return value.__get__(self)

1314

1301

1315

1302

# No such property

1316

1303

raise DBusPropertyNotFound("{}:{}.{}".format(

1317

1304

self.dbus_object_path, interface_name, property_name))

1318

1305

1319

1306

@classmethod

1320

1307

def _get_all_interface_names(cls):

1321

1308

"""Get a sequence of all interfaces supported by an object"""

1324

1311

for x in (inspect.getmro(cls))

1325

1312

for attr in dir(x))

1326

1313

if name is not None)

1327

1314

1328

1315

@dbus.service.method(dbus.PROPERTIES_IFACE,

1329

1316

in_signature="ss",

1330

1317

out_signature="v")

1338

1325

if not hasattr(value, "variant_level"):

1339

1326

return value

1340

1327

return type(value)(value, variant_level=value.variant_level+1)

1341

1328

1342

1329

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")

1343

1330

def Set(self, interface_name, property_name, value):

1344

1331

"""Standard D-Bus property Set() method, see D-Bus standard.

1356

1343

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

1357

1344

for byte in value))

1358

1345

prop(value)

1359

1346

1360

1347

@dbus.service.method(dbus.PROPERTIES_IFACE,

1361

1348

in_signature="s",

1362

1349

out_signature="a{sv}")

1363

1350

def GetAll(self, interface_name):

1364

1351

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

1365

1352

standard.

1366

1353

1367

1354

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

1368

1355

"""

1369

1356

properties = {}

1380

1367

properties[name] = value

1381

1368

continue

1382

1369

properties[name] = type(value)(

1383

value, variant_level=value.variant_level + 1)

1370

value, variant_level = value.variant_level + 1)

1384

1371

return dbus.Dictionary(properties, signature="sv")

1385

1372

1386

1373

@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")

1387

1374

def PropertiesChanged(self, interface_name, changed_properties,

1388

1375

invalidated_properties):

1390

1377

standard.

1391

1378

"""

1392

1379

pass

1393

1380

1394

1381

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1395

1382

out_signature="s",

1396

1383

path_keyword='object_path',

1397

1384

connection_keyword='connection')

1398

1385

def Introspect(self, object_path, connection):

1399

1386

"""Overloading of standard D-Bus method.

1400

1387

1401

1388

Inserts property tags and interface annotation tags.

1402

1389

"""

1403

1390

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1405

1392

connection)

1406

1393

try:

1407

1394

document = xml.dom.minidom.parseString(xmlstring)

1408

1395

1409

1396

def make_tag(document, name, prop):

1410

1397

e = document.createElement("property")

1411

1398

e.setAttribute("name", name)

1412

1399

e.setAttribute("type", prop._dbus_signature)

1413

1400

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

1414

1401

return e

1415

1402

1416

1403

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

1417

1404

# Add property tags

1418

1405

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

1460

1447

exc_info=error)

1461

1448

return xmlstring

1462

1449

1463

1464

1450

try:

1465

1451

dbus.OBJECT_MANAGER_IFACE

1466

1452

except AttributeError:

1467

1453

dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"

1468

1454

1469

1470

1455

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1471

1456

"""A D-Bus object with an ObjectManager.

1472

1457

1473

1458

Classes inheriting from this exposes the standard

1474

1459

GetManagedObjects call and the InterfacesAdded and

1475

1460

InterfacesRemoved signals on the standard

1476

1461

"org.freedesktop.DBus.ObjectManager" interface.

1477

1462

1478

1463

Note: No signals are sent automatically; they must be sent

1479

1464

manually.

1480

1465

"""

1481

1466

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1482

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

1467

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

1483

1468

def GetManagedObjects(self):

1484

1469

"""This function must be overridden"""

1485

1470

raise NotImplementedError()

1486

1471

1487

1472

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1488

signature="oa{sa{sv}}")

1473

signature = "oa{sa{sv}}")

1489

1474

def InterfacesAdded(self, object_path, interfaces_and_properties):

1490

1475

pass

1491

1492

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")

1476

1477

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")

1493

1478

def InterfacesRemoved(self, object_path, interfaces):

1494

1479

pass

1495

1480

1496

1481

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1497

out_signature="s",

1498

path_keyword='object_path',

1499

connection_keyword='connection')

1482

out_signature = "s",

1483

path_keyword = 'object_path',

1484

connection_keyword = 'connection')

1500

1485

def Introspect(self, object_path, connection):

1501

1486

"""Overloading of standard D-Bus method.

1502

1487

1503

1488

Override return argument name of GetManagedObjects to be

1504

1489

"objpath_interfaces_and_properties"

1505

1490

"""

1508

1493

connection)

1509

1494

try:

1510

1495

document = xml.dom.minidom.parseString(xmlstring)

1511

1496

1512

1497

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

1513

1498

# Fix argument name for the GetManagedObjects method

1514

1499

if (if_tag.getAttribute("name")

1515

== dbus.OBJECT_MANAGER_IFACE):

1500

== dbus.OBJECT_MANAGER_IFACE):

1516

1501

for cn in if_tag.getElementsByTagName("method"):

1517

1502

if (cn.getAttribute("name")

1518

1503

== "GetManagedObjects"):

1528

1513

except (AttributeError, xml.dom.DOMException,

1529

1514

xml.parsers.expat.ExpatError) as error:

1530

1515

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

1531

exc_info=error)

1516

exc_info = error)

1532

1517

return xmlstring

1533

1518

1534

1535

1519

def datetime_to_dbus(dt, variant_level=0):

1536

1520

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

1537

1521

if dt is None:

1538

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

1522

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

1539

1523

return dbus.String(dt.isoformat(), variant_level=variant_level)

1540

1524

1541

1525

1544

1528

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

1545

1529

interface names according to the "alt_interface_names" mapping.

1546

1530

Usage:

1547

1531

1548

1532

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

1549

1533

"net.example.AlternateInterface"})

1550

1534

class SampleDBusObject(dbus.service.Object):

1551

1535

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

1552

1536

def SampleDBusMethod():

1553

1537

pass

1554

1538

1555

1539

The above "SampleDBusMethod" on "SampleDBusObject" will be

1556

1540

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

1557

1541

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

1558

1542

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

1559

1543

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

1560

1544

1561

1545

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

1562

1546

(from DBusObjectWithProperties) and interfaces (from the

1563

1547

dbus_interface_annotations decorator).

1564

1548

"""

1565

1549

1566

1550

def wrapper(cls):

1567

1551

for orig_interface_name, alt_interface_name in (

1568

1552

alt_interface_names.items()):

1608

1592

attribute._dbus_annotations)

1609

1593

except AttributeError:

1610

1594

pass

1611

1612

1595

# Define a creator of a function to call both the

1613

1596

# original and alternate functions, so both the

1614

1597

# original and alternate signals gets sent when

1617

1600

"""This function is a scope container to pass

1618

1601

func1 and func2 to the "call_both" function

1619

1602

outside of its arguments"""

1620

1603

1621

1604

@functools.wraps(func2)

1622

1605

def call_both(*args, **kwargs):

1623

1606

"""This function will emit two D-Bus

1624

1607

signals by calling func1 and func2"""

1625

1608

func1(*args, **kwargs)

1626

1609

func2(*args, **kwargs)

1627

# Make wrapper function look like a D-Bus

1628

# signal

1610

# Make wrapper function look like a D-Bus signal

1629

1611

for name, attr in inspect.getmembers(func2):

1630

1612

if name.startswith("_dbus_"):

1631

1613

setattr(call_both, name, attr)

1632

1614

1633

1615

return call_both

1634

1616

# Create the "call_both" function and add it to

1635

1617

# the class

1681

1663

(copy_function(attribute)))

1682

1664

if deprecate:

1683

1665

# Deprecate all alternate interfaces

1684

iname = "_AlternateDBusNames_interface_annotation{}"

1666

iname="_AlternateDBusNames_interface_annotation{}"

1685

1667

for interface_name in interface_names:

1686

1668

1687

1669

@dbus_interface_annotations(interface_name)

1688

1670

def func(self):

1689

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

1690

"true"}

1671

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

1672

"true" }

1691

1673

# Find an unused name

1692

1674

for aname in (iname.format(i)

1693

1675

for i in itertools.count()):

1704

1686

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

1705

1687

(cls, ), attr)

1706

1688

return cls

1707

1689

1708

1690

return wrapper

1709

1691

1710

1692

1712

1694

"se.bsnet.fukt.Mandos"})

1713

1695

class ClientDBus(Client, DBusObjectWithProperties):

1714

1696

"""A Client class using D-Bus

1715

1697

1716

1698

Attributes:

1717

1699

dbus_object_path: dbus.ObjectPath

1718

1700

bus: dbus.SystemBus()

1719

1701

"""

1720

1702

1721

1703

runtime_expansions = (Client.runtime_expansions

1722

1704

+ ("dbus_object_path", ))

1723

1705

1724

1706

_interface = "se.recompile.Mandos.Client"

1725

1707

1726

1708

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

1727

1728

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

1709

1710

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

1729

1711

self.bus = bus

1730

1712

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

1731

1713

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

1737

1719

"/clients/" + client_object_name)

1738

1720

DBusObjectWithProperties.__init__(self, self.bus,

1739

1721

self.dbus_object_path)

1740

1722

1741

1723

def notifychangeproperty(transform_func, dbus_name,

1742

1724

type_func=lambda x: x,

1743

1725

variant_level=1,

1745

1727

_interface=_interface):

1746

1728

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

1747

1729

its changes to DBus.

1748

1730

1749

1731

transform_fun: Function that takes a value and a variant_level

1750

1732

and transforms it to a D-Bus type.

1751

1733

dbus_name: D-Bus name of the variable

1754

1736

variant_level: D-Bus variant level. Default: 1

1755

1737

"""

1756

1738

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

1757

1739

1758

1740

def setter(self, value):

1759

1741

if hasattr(self, "dbus_object_path"):

1760

1742

if (not hasattr(self, attrname) or

1767

1749

else:

1768

1750

dbus_value = transform_func(

1769

1751

type_func(value),

1770

variant_level=variant_level)

1752

variant_level = variant_level)

1771

1753

self.PropertyChanged(dbus.String(dbus_name),

1772

1754

dbus_value)

1773

1755

self.PropertiesChanged(

1774

1756

_interface,

1775

dbus.Dictionary({dbus.String(dbus_name):

1776

dbus_value}),

1757

dbus.Dictionary({ dbus.String(dbus_name):

1758

dbus_value }),

1777

1759

dbus.Array())

1778

1760

setattr(self, attrname, value)

1779

1761

1780

1762

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

1781

1763

1782

1764

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1783

1765

approvals_pending = notifychangeproperty(dbus.Boolean,

1784

1766

"ApprovalPending",

1785

type_func=bool)

1767

type_func = bool)

1786

1768

enabled = notifychangeproperty(dbus.Boolean, "Enabled")

1787

1769

last_enabled = notifychangeproperty(datetime_to_dbus,

1788

1770

"LastEnabled")

1789

1771

checker = notifychangeproperty(

1790

1772

dbus.Boolean, "CheckerRunning",

1791

type_func=lambda checker: checker is not None)

1773

type_func = lambda checker: checker is not None)

1792

1774

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1793

1775

"LastCheckedOK")

1794

1776

last_checker_status = notifychangeproperty(dbus.Int16,

1799

1781

"ApprovedByDefault")

1800

1782

approval_delay = notifychangeproperty(

1801

1783

dbus.UInt64, "ApprovalDelay",

1802

type_func=lambda td: td.total_seconds() * 1000)

1784

type_func = lambda td: td.total_seconds() * 1000)

1803

1785

approval_duration = notifychangeproperty(

1804

1786

dbus.UInt64, "ApprovalDuration",

1805

type_func=lambda td: td.total_seconds() * 1000)

1787

type_func = lambda td: td.total_seconds() * 1000)

1806

1788

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

1807

1789

timeout = notifychangeproperty(

1808

1790

dbus.UInt64, "Timeout",

1809

type_func=lambda td: td.total_seconds() * 1000)

1791

type_func = lambda td: td.total_seconds() * 1000)

1810

1792

extended_timeout = notifychangeproperty(

1811

1793

dbus.UInt64, "ExtendedTimeout",

1812

type_func=lambda td: td.total_seconds() * 1000)

1794

type_func = lambda td: td.total_seconds() * 1000)

1813

1795

interval = notifychangeproperty(

1814

1796

dbus.UInt64, "Interval",

1815

type_func=lambda td: td.total_seconds() * 1000)

1797

type_func = lambda td: td.total_seconds() * 1000)

1816

1798

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

1817

1799

secret = notifychangeproperty(dbus.ByteArray, "Secret",

1818

1800

invalidate_only=True)

1819

1801

1820

1802

del notifychangeproperty

1821

1803

1822

1804

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

1823

1805

try:

1824

1806

self.remove_from_connection()

1827

1809

if hasattr(DBusObjectWithProperties, "__del__"):

1828

1810

DBusObjectWithProperties.__del__(self, *args, **kwargs)

1829

1811

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

1830

1812

1831

1813

def checker_callback(self, source, condition,

1832

1814

connection, command, *args, **kwargs):

1833

1815

ret = Client.checker_callback(self, source, condition,

1849

1831

| self.last_checker_signal),

1850

1832

dbus.String(command))

1851

1833

return ret

1852

1834

1853

1835

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

1854

1836

old_checker_pid = getattr(self.checker, "pid", None)

1855

1837

r = Client.start_checker(self, *args, **kwargs)

1859

1841

# Emit D-Bus signal

1860

1842

self.CheckerStarted(self.current_checker_command)

1861

1843

return r

1862

1844

1863

1845

def _reset_approved(self):

1864

1846

self.approved = None

1865

1847

return False

1866

1848

1867

1849

def approve(self, value=True):

1868

1850

self.approved = value

1869

1851

GLib.timeout_add(int(self.approval_duration.total_seconds()

1870

1852

* 1000), self._reset_approved)

1871

1853

self.send_changedstate()

1872

1873

# D-Bus methods, signals & properties

1874

1875

# Interfaces

1876

1877

# Signals

1878

1854

1855

## D-Bus methods, signals & properties

1856

1857

## Interfaces

1858

1859

## Signals

1860

1879

1861

# CheckerCompleted - signal

1880

1862

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

1881

1863

def CheckerCompleted(self, exitcode, waitstatus, command):

1882

1864

"D-Bus signal"

1883

1865

pass

1884

1866

1885

1867

# CheckerStarted - signal

1886

1868

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

1887

1869

def CheckerStarted(self, command):

1888

1870

"D-Bus signal"

1889

1871

pass

1890

1872

1891

1873

# PropertyChanged - signal

1892

1874

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

1893

1875

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

1894

1876

def PropertyChanged(self, property, value):

1895

1877

"D-Bus signal"

1896

1878

pass

1897

1879

1898

1880

# GotSecret - signal

1899

1881

@dbus.service.signal(_interface)

1900

1882

def GotSecret(self):

1903

1885

server to mandos-client

1904

1886

"""

1905

1887

pass

1906

1888

1907

1889

# Rejected - signal

1908

1890

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

1909

1891

def Rejected(self, reason):

1910

1892

"D-Bus signal"

1911

1893

pass

1912

1894

1913

1895

# NeedApproval - signal

1914

1896

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

1915

1897

def NeedApproval(self, timeout, default):

1916

1898

"D-Bus signal"

1917

1899

return self.need_approval()

1918

1919

# Methods

1920

1900

1901

## Methods

1902

1921

1903

# Approve - method

1922

1904

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

1923

1905

def Approve(self, value):

1924

1906

self.approve(value)

1925

1907

1926

1908

# CheckedOK - method

1927

1909

@dbus.service.method(_interface)

1928

1910

def CheckedOK(self):

1929

1911

self.checked_ok()

1930

1912

1931

1913

# Enable - method

1932

1914

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

1933

1915

@dbus.service.method(_interface)

1934

1916

def Enable(self):

1935

1917

"D-Bus method"

1936

1918

self.enable()

1937

1919

1938

1920

# StartChecker - method

1939

1921

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

1940

1922

@dbus.service.method(_interface)

1941

1923

def StartChecker(self):

1942

1924

"D-Bus method"

1943

1925

self.start_checker()

1944

1926

1945

1927

# Disable - method

1946

1928

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

1947

1929

@dbus.service.method(_interface)

1948

1930

def Disable(self):

1949

1931

"D-Bus method"

1950

1932

self.disable()

1951

1933

1952

1934

# StopChecker - method

1953

1935

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

1954

1936

@dbus.service.method(_interface)

1955

1937

def StopChecker(self):

1956

1938

self.stop_checker()

1957

1958

# Properties

1959

1939

1940

## Properties

1941

1960

1942

# ApprovalPending - property

1961

1943

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

1962

1944

def ApprovalPending_dbus_property(self):

1963

1945

return dbus.Boolean(bool(self.approvals_pending))

1964

1946

1965

1947

# ApprovedByDefault - property

1966

1948

@dbus_service_property(_interface,

1967

1949

signature="b",

1970

1952

if value is None: # get

1971

1953

return dbus.Boolean(self.approved_by_default)

1972

1954

self.approved_by_default = bool(value)

1973

1955

1974

1956

# ApprovalDelay - property

1975

1957

@dbus_service_property(_interface,

1976

1958

signature="t",

1980

1962

return dbus.UInt64(self.approval_delay.total_seconds()

1981

1963

* 1000)

1982

1964

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

1983

1965

1984

1966

# ApprovalDuration - property

1985

1967

@dbus_service_property(_interface,

1986

1968

signature="t",

1990

1972

return dbus.UInt64(self.approval_duration.total_seconds()

1991

1973

* 1000)

1992

1974

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

1993

1975

1994

1976

# Name - property

1995

1977

@dbus_annotations(

1996

1978

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})

1997

1979

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

1998

1980

def Name_dbus_property(self):

1999

1981

return dbus.String(self.name)

2000

1982

2001

1983

# Fingerprint - property

2002

1984

@dbus_annotations(

2003

1985

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})

2004

1986

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

2005

1987

def Fingerprint_dbus_property(self):

2006

1988

return dbus.String(self.fingerprint)

2007

1989

2008

1990

# Host - property

2009

1991

@dbus_service_property(_interface,

2010

1992

signature="s",

2013

1995

if value is None: # get

2014

1996

return dbus.String(self.host)

2015

1997

self.host = str(value)

2016

1998

2017

1999

# Created - property

2018

2000

@dbus_annotations(

2019

2001

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})

2020

2002

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

2021

2003

def Created_dbus_property(self):

2022

2004

return datetime_to_dbus(self.created)

2023

2005

2024

2006

# LastEnabled - property

2025

2007

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

2026

2008

def LastEnabled_dbus_property(self):

2027

2009

return datetime_to_dbus(self.last_enabled)

2028

2010

2029

2011

# Enabled - property

2030

2012

@dbus_service_property(_interface,

2031

2013

signature="b",

2037

2019

self.enable()

2038

2020

else:

2039

2021

self.disable()

2040

2022

2041

2023

# LastCheckedOK - property

2042

2024

@dbus_service_property(_interface,

2043

2025

signature="s",

2047

2029

self.checked_ok()

2048

2030

return

2049

2031

return datetime_to_dbus(self.last_checked_ok)

2050

2032

2051

2033

# LastCheckerStatus - property

2052

2034

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

2053

2035

def LastCheckerStatus_dbus_property(self):

2054

2036

return dbus.Int16(self.last_checker_status)

2055

2037

2056

2038

# Expires - property

2057

2039

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

2058

2040

def Expires_dbus_property(self):

2059

2041

return datetime_to_dbus(self.expires)

2060

2042

2061

2043

# LastApprovalRequest - property

2062

2044

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

2063

2045

def LastApprovalRequest_dbus_property(self):

2064

2046

return datetime_to_dbus(self.last_approval_request)

2065

2047

2066

2048

# Timeout - property

2067

2049

@dbus_service_property(_interface,

2068

2050

signature="t",

2087

2069

self.disable_initiator_tag = GLib.timeout_add(

2088

2070

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

2089

2071

self.disable)

2090

2072

2091

2073

# ExtendedTimeout - property

2092

2074

@dbus_service_property(_interface,

2093

2075

signature="t",

2097

2079

return dbus.UInt64(self.extended_timeout.total_seconds()

2098

2080

* 1000)

2099

2081

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

2100

2082

2101

2083

# Interval - property

2102

2084

@dbus_service_property(_interface,

2103

2085

signature="t",

2113

2095

GLib.source_remove(self.checker_initiator_tag)

2114

2096

self.checker_initiator_tag = GLib.timeout_add(

2115

2097

value, self.start_checker)

2116

self.start_checker() # Start one now, too

2117

2098

self.start_checker() # Start one now, too

2099

2118

2100

# Checker - property

2119

2101

@dbus_service_property(_interface,

2120

2102

signature="s",

2123

2105

if value is None: # get

2124

2106

return dbus.String(self.checker_command)

2125

2107

self.checker_command = str(value)

2126

2108

2127

2109

# CheckerRunning - property

2128

2110

@dbus_service_property(_interface,

2129

2111

signature="b",

2135

2117

self.start_checker()

2136

2118

else:

2137

2119

self.stop_checker()

2138

2120

2139

2121

# ObjectPath - property

2140

2122

@dbus_annotations(

2141

2123

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",

2142

2124

"org.freedesktop.DBus.Deprecated": "true"})

2143

2125

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

2144

2126

def ObjectPath_dbus_property(self):

2145

return self.dbus_object_path # is already a dbus.ObjectPath

2146

2127

return self.dbus_object_path # is already a dbus.ObjectPath

2128

2147

2129

# Secret = property

2148

2130

@dbus_annotations(

2149

2131

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

2154

2136

byte_arrays=True)

2155

2137

def Secret_dbus_property(self, value):

2156

2138

self.secret = bytes(value)

2157

2139

2158

2140

del _interface

2159

2141

2160

2142

2164

2146

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

2165

2147

if not self._pipe.recv():

2166

2148

raise KeyError(fpr)

2167

2149

2168

2150

def __getattribute__(self, name):

2169

2151

if name == '_pipe':

2170

2152

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

2173

2155

if data[0] == 'data':

2174

2156

return data[1]

2175

2157

if data[0] == 'function':

2176

2158

2177

2159

def func(*args, **kwargs):

2178

2160

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

2179

2161

return self._pipe.recv()[1]

2180

2162

2181

2163

return func

2182

2164

2183

2165

def __setattr__(self, name, value):

2184

2166

if name == '_pipe':

2185

2167

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

2188

2170

2189

2171

class ClientHandler(socketserver.BaseRequestHandler, object):

2190

2172

"""A class to handle client connections.

2191

2173

2192

2174

Instantiated once for each connection to handle it.

2193

2175

Note: This will run in its own forked process."""

2194

2176

2195

2177

def handle(self):

2196

2178

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

2197

2179

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

2198

2180

str(self.client_address))

2199

2181

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

2200

2182

self.server.child_pipe.fileno())

2201

2183

2202

2184

session = gnutls.ClientSession(self.request)

2203

2204

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

2205

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

2206

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

2207

# "+DHE-DSS"))

2185

2186

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

2187

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

2188

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

2189

# "+DHE-DSS"))

2208

2190

# Use a fallback default, since this MUST be set.

2209

2191

priority = self.server.gnutls_priority

2210

2192

if priority is None:

2212

2194

gnutls.priority_set_direct(session._c_object,

2213

2195

priority.encode("utf-8"),

2214

2196

None)

2215

2197

2216

2198

# Start communication using the Mandos protocol

2217

2199

# Get protocol number

2218

2200

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

2223

2205

except (ValueError, IndexError, RuntimeError) as error:

2224

2206

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

2225

2207

return

2226

2208

2227

2209

# Start GnuTLS connection

2228

2210

try:

2229

2211

session.handshake()

2233

2215

# established. Just abandon the request.

2234

2216

return

2235

2217

logger.debug("Handshake succeeded")

2236

2218

2237

2219

approval_required = False

2238

2220

try:

2239

2221

try:

2243

2225

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

2244

2226

return

2245

2227

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

2246

2228

2247

2229

try:

2248

2230

client = ProxyClient(child_pipe, fpr,

2249

2231

self.client_address)

2250

2232

except KeyError:

2251

2233

return

2252

2234

2253

2235

if client.approval_delay:

2254

2236

delay = client.approval_delay

2255

2237

client.approvals_pending += 1

2256

2238

approval_required = True

2257

2239

2258

2240

while True:

2259

2241

if not client.enabled:

2260

2242

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

2263

2245

# Emit D-Bus signal

2264

2246

client.Rejected("Disabled")

2265

2247

return

2266

2248

2267

2249

if client.approved or not client.approval_delay:

2268

# We are approved or approval is disabled

2250

#We are approved or approval is disabled

2269

2251

break

2270

2252

elif client.approved is None:

2271

2253

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

2282

2264

# Emit D-Bus signal

2283

2265

client.Rejected("Denied")

2284

2266

return

2285

2286

# wait until timeout or approved

2267

2268

#wait until timeout or approved

2287

2269

time = datetime.datetime.now()

2288

2270

client.changedstate.acquire()

2289

2271

client.changedstate.wait(delay.total_seconds())

2302

2284

break

2303

2285

else:

2304

2286

delay -= time2 - time

2305

2287

2306

2288

try:

2307

2289

session.send(client.secret)

2308

2290

except gnutls.Error as error:

2309

2291

logger.warning("gnutls send failed",

2310

exc_info=error)

2292

exc_info = error)

2311

2293

return

2312

2294

2313

2295

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

2314

2296

# bump the timeout using extended_timeout

2315

2297

client.bump_timeout(client.extended_timeout)

2316

2298

if self.server.use_dbus:

2317

2299

# Emit D-Bus signal

2318

2300

client.GotSecret()

2319

2301

2320

2302

finally:

2321

2303

if approval_required:

2322

2304

client.approvals_pending -= 1

2325

2307

except gnutls.Error as error:

2326

2308

logger.warning("GnuTLS bye failed",

2327

2309

exc_info=error)

2328

2310

2329

2311

@staticmethod

2330

2312

def peer_certificate(session):

2331

2313

"Return the peer's OpenPGP certificate as a bytestring"

2343

2325

return None

2344

2326

cert = cert_list[0]

2345

2327

return ctypes.string_at(cert.data, cert.size)

2346

2328

2347

2329

@staticmethod

2348

2330

def fingerprint(openpgp):

2349

2331

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2382

2364

2383

2365

class MultiprocessingMixIn(object):

2384

2366

"""Like socketserver.ThreadingMixIn, but with multiprocessing"""

2385

2367

2386

2368

def sub_process_main(self, request, address):

2387

2369

try:

2388

2370

self.finish_request(request, address)

2389

2371

except Exception:

2390

2372

self.handle_error(request, address)

2391

2373

self.close_request(request)

2392

2374

2393

2375

def process_request(self, request, address):

2394

2376

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

2395

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

2396

args=(request, address))

2377

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

2378

args = (request, address))

2397

2379

proc.start()

2398

2380

return proc

2399

2381

2400

2382

2401

2383

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2402

2384

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

2403

2385

2404

2386

def process_request(self, request, client_address):

2405

2387

"""Overrides and wraps the original process_request().

2406

2388

2407

2389

This function creates a new pipe in self.pipe

2408

2390

"""

2409

2391

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2410

2392

2411

2393

proc = MultiprocessingMixIn.process_request(self, request,

2412

2394

client_address)

2413

2395

self.child_pipe.close()

2414

2396

self.add_pipe(parent_pipe, proc)

2415

2397

2416

2398

def add_pipe(self, parent_pipe, proc):

2417

2399

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

2418

2400

raise NotImplementedError()

2421

2403

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2422

2404

socketserver.TCPServer, object):

2423

2405

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

2424

2406

2425

2407

Attributes:

2426

2408

enabled: Boolean; whether this server is activated yet

2427

2409

interface: None or a network interface name (string)

2428

2410

use_ipv6: Boolean; to use IPv6 or not

2429

2411

"""

2430

2412

2431

2413

def __init__(self, server_address, RequestHandlerClass,

2432

2414

interface=None,

2433

2415

use_ipv6=True,

2443

2425

self.socketfd = socketfd

2444

2426

# Save the original socket.socket() function

2445

2427

self.socket_socket = socket.socket

2446

2447

2428

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

2448

#

2429

#

2449

2430

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

2450

2431

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

2451

2432

# patching socket.socket.)

2452

#

2433

#

2453

2434

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

2454

2435

@functools.wraps(socket.socket)

2455

2436

def socket_wrapper(*args, **kwargs):

2467

2448

# socket_wrapper(), if socketfd was set.

2468

2449

socketserver.TCPServer.__init__(self, server_address,

2469

2450

RequestHandlerClass)

2470

2451

2471

2452

def server_bind(self):

2472

2453

"""This overrides the normal server_bind() function

2473

2454

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

2500

2481

if self.server_address[0] or self.server_address[1]:

2501

2482

if not self.server_address[0]:

2502

2483

if self.address_family == socket.AF_INET6:

2503

any_address = "::" # in6addr_any

2484

any_address = "::" # in6addr_any

2504

2485

else:

2505

any_address = "0.0.0.0" # INADDR_ANY

2486

any_address = "0.0.0.0" # INADDR_ANY

2506

2487

self.server_address = (any_address,

2507

2488

self.server_address[1])

2508

2489

elif not self.server_address[1]:

2518

2499

2519

2500

class MandosServer(IPv6_TCPServer):

2520

2501

"""Mandos server.

2521

2502

2522

2503

Attributes:

2523

2504

clients: set of Client objects

2524

2505

gnutls_priority GnuTLS priority string

2525

2506

use_dbus: Boolean; to emit D-Bus signals or not

2526

2507

2527

2508

Assumes a GLib.MainLoop event loop.

2528

2509

"""

2529

2510

2530

2511

def __init__(self, server_address, RequestHandlerClass,

2531

2512

interface=None,

2532

2513

use_ipv6=True,

2542

2523

self.gnutls_priority = gnutls_priority

2543

2524

IPv6_TCPServer.__init__(self, server_address,

2544

2525

RequestHandlerClass,

2545

interface=interface,

2546

use_ipv6=use_ipv6,

2547

socketfd=socketfd)

2548

2526

interface = interface,

2527

use_ipv6 = use_ipv6,

2528

socketfd = socketfd)

2529

2549

2530

def server_activate(self):

2550

2531

if self.enabled:

2551

2532

return socketserver.TCPServer.server_activate(self)

2552

2533

2553

2534

def enable(self):

2554

2535

self.enabled = True

2555

2536

2556

2537

def add_pipe(self, parent_pipe, proc):

2557

2538

# Call "handle_ipc" for both data and EOF events

2558

2539

GLib.io_add_watch(

2559

2540

parent_pipe.fileno(),

2560

2541

GLib.IO_IN | GLib.IO_HUP,

2561

2542

functools.partial(self.handle_ipc,

2562

parent_pipe=parent_pipe,

2563

proc=proc))

2564

2543

parent_pipe = parent_pipe,

2544

proc = proc))

2545

2565

2546

def handle_ipc(self, source, condition,

2566

2547

parent_pipe=None,

2567

proc=None,

2548

proc = None,

2568

2549

client_object=None):

2569

2550

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

2570

2551

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

2571

2552

# Wait for other process to exit

2572

2553

proc.join()

2573

2554

return False

2574

2555

2575

2556

# Read a request from the child

2576

2557

request = parent_pipe.recv()

2577

2558

command = request[0]

2578

2559

2579

2560

if command == 'init':

2580

2561

fpr = request[1]

2581

2562

address = request[2]

2582

2563

2583

2564

for c in self.clients.values():

2584

2565

if c.fingerprint == fpr:

2585

2566

client = c

2593

2574

address[0])

2594

2575

parent_pipe.send(False)

2595

2576

return False

2596

2577

2597

2578

GLib.io_add_watch(

2598

2579

parent_pipe.fileno(),

2599

2580

GLib.IO_IN | GLib.IO_HUP,

2600

2581

functools.partial(self.handle_ipc,

2601

parent_pipe=parent_pipe,

2602

proc=proc,

2603

client_object=client))

2582

parent_pipe = parent_pipe,

2583

proc = proc,

2584

client_object = client))

2604

2585

parent_pipe.send(True)

2605

2586

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

2606

2587

# same fileno

2609

2590

funcname = request[1]

2610

2591

args = request[2]

2611

2592

kwargs = request[3]

2612

2593

2613

2594

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

2614

2595

funcname)(*args,

2615

2596

**kwargs)))

2616

2597

2617

2598

if command == 'getattr':

2618

2599

attrname = request[1]

2619

2600

if isinstance(client_object.__getattribute__(attrname),

2622

2603

else:

2623

2604

parent_pipe.send((

2624

2605

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

2625

2606

2626

2607

if command == 'setattr':

2627

2608

attrname = request[1]

2628

2609

value = request[2]

2629

2610

setattr(client_object, attrname, value)

2630

2611

2631

2612

return True

2632

2613

2633

2614

2634

2615

def rfc3339_duration_to_delta(duration):

2635

2616

"""Parse an RFC 3339 "duration" and return a datetime.timedelta

2636

2617

2637

2618

>>> rfc3339_duration_to_delta("P7D")

2638

2619

datetime.timedelta(7)

2639

2620

>>> rfc3339_duration_to_delta("PT60S")

2649

2630

>>> rfc3339_duration_to_delta("P1DT3M20S")

2650

2631

datetime.timedelta(1, 200)

2651

2632

"""

2652

2633

2653

2634

# Parsing an RFC 3339 duration with regular expressions is not

2654

2635

# possible - there would have to be multiple places for the same

2655

2636

# values, like seconds. The current code, while more esoteric, is

2656

2637

# cleaner without depending on a parsing library. If Python had a

2657

2638

# built-in library for parsing we would use it, but we'd like to

2658

2639

# avoid excessive use of external libraries.

2659

2640

2660

2641

# New type for defining tokens, syntax, and semantics all-in-one

2661

2642

Token = collections.namedtuple("Token", (

2662

2643

"regexp", # To match token; if "value" is not None, must have

2695

2676

frozenset((token_year, token_month,

2696

2677

token_day, token_time,

2697

2678

token_week)))

2698

# Define starting values:

2699

# Value so far

2700

value = datetime.timedelta()

2679

# Define starting values

2680

value = datetime.timedelta() # Value so far

2701

2681

found_token = None

2702

# Following valid tokens

2703

followers = frozenset((token_duration, ))

2704

# String left to parse

2705

s = duration

2682

followers = frozenset((token_duration, )) # Following valid tokens

2683

s = duration # String left to parse

2706

2684

# Loop until end token is found

2707

2685

while found_token is not token_end:

2708

2686

# Search for any currently valid tokens

2732

2710

2733

2711

def string_to_delta(interval):

2734

2712

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

2735

2713

2736

2714

>>> string_to_delta('7d')

2737

2715

datetime.timedelta(7)

2738

2716

>>> string_to_delta('60s')

2746

2724

>>> string_to_delta('5m 30s')

2747

2725

datetime.timedelta(0, 330)

2748

2726

"""

2749

2727

2750

2728

try:

2751

2729

return rfc3339_duration_to_delta(interval)

2752

2730

except ValueError:

2753

2731

pass

2754

2732

2755

2733

timevalue = datetime.timedelta(0)

2756

2734

for s in interval.split():

2757

2735

try:

2775

2753

return timevalue

2776

2754

2777

2755

2778

def daemon(nochdir=False, noclose=False):

2756

def daemon(nochdir = False, noclose = False):

2779

2757

"""See daemon(3). Standard BSD Unix function.

2780

2758

2781

2759

This should really exist as os.daemon, but it doesn't (yet)."""

2782

2760

if os.fork():

2783

2761

sys.exit()

2801

2779

2802

2780

2803

2781

def main():

2804

2782

2805

2783

##################################################################

2806

2784

# Parsing of options, both command line and config file

2807

2785

2808

2786

parser = argparse.ArgumentParser()

2809

2787

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

2810

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

2788

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

2811

2789

help="show version number and exit")

2812

2790

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

2813

2791

help="Bind to interface IF")

2849

2827

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

2850

2828

dest="zeroconf", help="Do not use Zeroconf",

2851

2829

default=None)

2852

2830

2853

2831

options = parser.parse_args()

2854

2832

2855

2833

if options.check:

2856

2834

import doctest

2857

2835

fail_count, test_count = doctest.testmod()

2858

2836

sys.exit(os.EX_OK if fail_count == 0 else 1)

2859

2837

2860

2838

# Default values for config file for server-global settings

2861

server_defaults = {"interface": "",

2862

"address": "",

2863

"port": "",

2864

"debug": "False",

2865

"priority":

2866

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"

2867

":+SIGN-DSA-SHA256",

2868

"servicename": "Mandos",

2869

"use_dbus": "True",

2870

"use_ipv6": "True",

2871

"debuglevel": "",

2872

"restore": "True",

2873

"socket": "",

2874

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

2875

"foreground": "False",

2876

"zeroconf": "True",

2877

}

2878

2839

server_defaults = { "interface": "",

2840

"address": "",

2841

"port": "",

2842

"debug": "False",

2843

"priority":

2844

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"

2845

":+SIGN-DSA-SHA256",

2846

"servicename": "Mandos",

2847

"use_dbus": "True",

2848

"use_ipv6": "True",

2849

"debuglevel": "",

2850

"restore": "True",

2851

"socket": "",

2852

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

2853

"foreground": "False",

2854

"zeroconf": "True",

2855

}

2856

2879

2857

# Parse config file for server-global settings

2880

2858

server_config = configparser.SafeConfigParser(server_defaults)

2881

2859

del server_defaults

2883

2861

# Convert the SafeConfigParser object to a dict

2884

2862

server_settings = server_config.defaults()

2885

2863

# Use the appropriate methods on the non-string config options

2886

for option in ("debug", "use_dbus", "use_ipv6", "restore",

2887

"foreground", "zeroconf"):

2864

for option in ("debug", "use_dbus", "use_ipv6", "foreground"):

2888

2865

server_settings[option] = server_config.getboolean("DEFAULT",

2889

2866

option)

2890

2867

if server_settings["port"]:

2900

2877

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

2901

2878

["socket"])

2902

2879

del server_config

2903

2880

2904

2881

# Override the settings from the config file with command line

2905

2882

# options, if set.

2906

2883

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

2924

2901

if server_settings["debug"]:

2925

2902

server_settings["foreground"] = True

2926

2903

# Now we have our good server settings in "server_settings"

2927

2904

2928

2905

##################################################################

2929

2906

2930

2907

if (not server_settings["zeroconf"]

2931

2908

and not (server_settings["port"]

2932

2909

or server_settings["socket"] != "")):

2933

2910

parser.error("Needs port or socket to work without Zeroconf")

2934

2911

2935

2912

# For convenience

2936

2913

debug = server_settings["debug"]

2937

2914

debuglevel = server_settings["debuglevel"]

2941

2918

stored_state_file)

2942

2919

foreground = server_settings["foreground"]

2943

2920

zeroconf = server_settings["zeroconf"]

2944

2921

2945

2922

if debug:

2946

2923

initlogger(debug, logging.DEBUG)

2947

2924

else:

2950

2927

else:

2951

2928

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

2952

2929

initlogger(debug, level)

2953

2930

2954

2931

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

2955

2932

syslogger.setFormatter(

2956

2933

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

2957

2934

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

2958

2935

server_settings["servicename"])))

2959

2936

2960

2937

# Parse config file with clients

2961

2938

client_config = configparser.SafeConfigParser(Client

2962

2939

.client_defaults)

2963

2940

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

2964

2941

"clients.conf"))

2965

2942

2966

2943

global mandos_dbus_service

2967

2944

mandos_dbus_service = None

2968

2945

2969

2946

socketfd = None

2970

2947

if server_settings["socket"] != "":

2971

2948

socketfd = server_settings["socket"]

2987

2964

except IOError as e:

2988

2965

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

2989

2966

exc_info=e)

2990

2967

2991

2968

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

2992

2969

("mandos", "mandos"),

2993

2970

("nobody", "nogroup")):

3011

2988

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

3012

2989

if error.errno != errno.EPERM:

3013

2990

raise

3014

2991

3015

2992

if debug:

3016

2993

# Enable all possible GnuTLS debugging

3017

2994

3018

2995

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

3019

2996

# - GnuTLS manual

3020

2997

gnutls.global_set_log_level(11)

3021

2998

3022

2999

@gnutls.log_func

3023

3000

def debug_gnutls(level, string):

3024

3001

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

3025

3002

3026

3003

gnutls.global_set_log_function(debug_gnutls)

3027

3004

3028

3005

# Redirect stdin so all checkers get /dev/null

3029

3006

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

3030

3007

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

3031

3008

if null > 2:

3032

3009

os.close(null)

3033

3010

3034

3011

# Need to fork before connecting to D-Bus

3035

3012

if not foreground:

3036

3013

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

3037

3014

daemon()

3038

3015

3039

3016

# multiprocessing will use threads, so before we use GLib we need

3040

3017

# to inform GLib that threads will be used.

3041

3018

GLib.threads_init()

3042

3019

3043

3020

global main_loop

3044

3021

# From the Avahi example code

3045

3022

DBusGMainLoop(set_as_default=True)

3062

3039

if zeroconf:

3063

3040

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3064

3041

service = AvahiServiceToSyslog(

3065

name=server_settings["servicename"],

3066

servicetype="_mandos._tcp",

3067

protocol=protocol,

3068

bus=bus)

3042

name = server_settings["servicename"],

3043

servicetype = "_mandos._tcp",

3044

protocol = protocol,

3045

bus = bus)

3069

3046

if server_settings["interface"]:

3070

3047

service.interface = if_nametoindex(

3071

3048

server_settings["interface"].encode("utf-8"))

3072

3049

3073

3050

global multiprocessing_manager

3074

3051

multiprocessing_manager = multiprocessing.Manager()

3075

3052

3076

3053

client_class = Client

3077

3054

if use_dbus:

3078

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

3079

3055

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

3056

3080

3057

client_settings = Client.config_parser(client_config)

3081

3058

old_client_settings = {}

3082

3059

clients_data = {}

3083

3060

3084

3061

# This is used to redirect stdout and stderr for checker processes

3085

3062

global wnull

3086

wnull = open(os.devnull, "w") # A writable /dev/null

3063

wnull = open(os.devnull, "w") # A writable /dev/null

3087

3064

# Only used if server is running in foreground but not in debug

3088

3065

# mode

3089

3066

if debug or not foreground:

3090

3067

wnull.close()

3091

3068

3092

3069

# Get client data and settings from last running state.

3093

3070

if server_settings["restore"]:

3094

3071

try:

3095

3072

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

3096

if sys.version_info.major == 2:

3073

if sys.version_info.major == 2:

3097

3074

clients_data, old_client_settings = pickle.load(

3098

3075

stored_state)

3099

3076

else:

3100

3077

bytes_clients_data, bytes_old_client_settings = (

3101

pickle.load(stored_state, encoding="bytes"))

3102

# Fix bytes to strings

3103

# clients_data

3078

pickle.load(stored_state, encoding = "bytes"))

3079

### Fix bytes to strings

3080

## clients_data

3104

3081

# .keys()

3105

clients_data = {(key.decode("utf-8")

3106

if isinstance(key, bytes)

3107

else key): value

3108

for key, value in

3109

bytes_clients_data.items()}

3082

clients_data = { (key.decode("utf-8")

3083

if isinstance(key, bytes)

3084

else key): value

3085

for key, value in

3086

bytes_clients_data.items() }

3110

3087

del bytes_clients_data

3111

3088

for key in clients_data:

3112

value = {(k.decode("utf-8")

3113

if isinstance(k, bytes) else k): v

3114

for k, v in

3115

clients_data[key].items()}

3089

value = { (k.decode("utf-8")

3090

if isinstance(k, bytes) else k): v

3091

for k, v in

3092

clients_data[key].items() }

3116

3093

clients_data[key] = value

3117

3094

# .client_structure

3118

3095

value["client_structure"] = [

3119

3096

(s.decode("utf-8")

3120

3097

if isinstance(s, bytes)

3121

3098

else s) for s in

3122

value["client_structure"]]

3099

value["client_structure"] ]

3123

3100

# .name & .host

3124

3101

for k in ("name", "host"):

3125

3102

if isinstance(value[k], bytes):

3126

3103

value[k] = value[k].decode("utf-8")

3127

# old_client_settings

3104

## old_client_settings

3128

3105

# .keys()

3129

3106

old_client_settings = {

3130

3107

(key.decode("utf-8")

3131

3108

if isinstance(key, bytes)

3132

3109

else key): value

3133

3110

for key, value in

3134

bytes_old_client_settings.items()}

3111

bytes_old_client_settings.items() }

3135

3112

del bytes_old_client_settings

3136

3113

# .host

3137

3114

for value in old_client_settings.values():

3151

3128

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

3152

3129

"EOFError:",

3153

3130

exc_info=e)

3154

3131

3155

3132

with PGPEngine() as pgp:

3156

3133

for client_name, client in clients_data.items():

3157

3134

# Skip removed clients

3158

3135

if client_name not in client_settings:

3159

3136

continue

3160

3137

3161

3138

# Decide which value to use after restoring saved state.

3162

3139

# We have three different values: Old config file,

3163

3140

# new config file, and saved state.

3174

3151

client[name] = value

3175

3152

except KeyError:

3176

3153

pass

3177

3154

3178

3155

# Clients who has passed its expire date can still be

3179

3156

# enabled if its last checker was successful. A Client

3180

3157

# whose checker succeeded before we stored its state is

3213

3190

client_name))

3214

3191

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

3215

3192

["secret"])

3216

3193

3217

3194

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

3218

3195

for client_name in (set(old_client_settings)

3219

3196

- set(client_settings)):

3221

3198

for client_name in (set(client_settings)

3222

3199

- set(old_client_settings)):

3223

3200

clients_data[client_name] = client_settings[client_name]

3224

3201

3225

3202

# Create all client objects

3226

3203

for client_name, client in clients_data.items():

3227

3204

tcp_server.clients[client_name] = client_class(

3228

name=client_name,

3229

settings=client,

3230

server_settings=server_settings)

3231

3205

name = client_name,

3206

settings = client,

3207

server_settings = server_settings)

3208

3232

3209

if not tcp_server.clients:

3233

3210

logger.warning("No clients defined")

3234

3211

3235

3212

if not foreground:

3236

3213

if pidfile is not None:

3237

3214

pid = os.getpid()

3243

3220

pidfilename, pid)

3244

3221

del pidfile

3245

3222

del pidfilename

3246

3223

3247

3224

for termsig in (signal.SIGHUP, signal.SIGTERM):

3248

3225

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3249

3226

lambda: main_loop.quit() and False)

3250

3227

3251

3228

if use_dbus:

3252

3229

3253

3230

@alternate_dbus_interfaces(

3254

{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})

3231

{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })

3255

3232

class MandosDBusService(DBusObjectWithObjectManager):

3256

3233

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

3257

3234

3258

3235

def __init__(self):

3259

3236

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

3260

3237

3261

3238

_interface = "se.recompile.Mandos"

3262

3239

3263

3240

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

3264

3241

def ClientAdded(self, objpath):

3265

3242

"D-Bus signal"

3266

3243

pass

3267

3244

3268

3245

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

3269

3246

def ClientNotFound(self, fingerprint, address):

3270

3247

"D-Bus signal"

3271

3248

pass

3272

3249

3273

3250

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

3274

3251

"true"})

3275

3252

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

3276

3253

def ClientRemoved(self, objpath, name):

3277

3254

"D-Bus signal"

3278

3255

pass

3279

3256

3280

3257

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

3281

3258

"true"})

3282

3259

@dbus.service.method(_interface, out_signature="ao")

3284

3261

"D-Bus method"

3285

3262

return dbus.Array(c.dbus_object_path for c in

3286

3263

tcp_server.clients.values())

3287

3264

3288

3265

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

3289

3266

"true"})

3290

3267

@dbus.service.method(_interface,

3292

3269

def GetAllClientsWithProperties(self):

3293

3270

"D-Bus method"

3294

3271

return dbus.Dictionary(

3295

{c.dbus_object_path: c.GetAll(

3272

{ c.dbus_object_path: c.GetAll(

3296

3273

"se.recompile.Mandos.Client")

3297

for c in tcp_server.clients.values()},

3274

for c in tcp_server.clients.values() },

3298

3275

signature="oa{sv}")

3299

3276

3300

3277

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

3301

3278

def RemoveClient(self, object_path):

3302

3279

"D-Bus method"

3310

3287

self.client_removed_signal(c)

3311

3288

return

3312

3289

raise KeyError(object_path)

3313

3290

3314

3291

del _interface

3315

3292

3316

3293

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3317

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

3294

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

3318

3295

def GetManagedObjects(self):

3319

3296

"""D-Bus method"""

3320

3297

return dbus.Dictionary(

3321

{client.dbus_object_path:

3322

dbus.Dictionary(

3323

{interface: client.GetAll(interface)

3324

for interface in

3325

client._get_all_interface_names()})

3326

for client in tcp_server.clients.values()})

3327

3298

{ client.dbus_object_path:

3299

dbus.Dictionary(

3300

{ interface: client.GetAll(interface)

3301

for interface in

3302

client._get_all_interface_names()})

3303

for client in tcp_server.clients.values()})

3304

3328

3305

def client_added_signal(self, client):

3329

3306

"""Send the new standard signal and the old signal"""

3330

3307

if use_dbus:

3332

3309

self.InterfacesAdded(

3333

3310

client.dbus_object_path,

3334

3311

dbus.Dictionary(

3335

{interface: client.GetAll(interface)

3336

for interface in

3337

client._get_all_interface_names()}))

3312

{ interface: client.GetAll(interface)

3313

for interface in

3314

client._get_all_interface_names()}))

3338

3315

# Old signal

3339

3316

self.ClientAdded(client.dbus_object_path)

3340

3317

3341

3318

def client_removed_signal(self, client):

3342

3319

"""Send the new standard signal and the old signal"""

3343

3320

if use_dbus:

3348

3325

# Old signal

3349

3326

self.ClientRemoved(client.dbus_object_path,

3350

3327

client.name)

3351

3328

3352

3329

mandos_dbus_service = MandosDBusService()

3353

3330

3354

3331

# Save modules to variables to exempt the modules from being

3355

3332

# unloaded before the function registered with atexit() is run.

3356

3333

mp = multiprocessing

3357

3334

wn = wnull

3358

3359

3335

def cleanup():

3360

3336

"Cleanup function; run on exit"

3361

3337

if zeroconf:

3362

3338

service.cleanup()

3363

3339

3364

3340

mp.active_children()

3365

3341

wn.close()

3366

3342

if not (tcp_server.clients or client_settings):

3367

3343

return

3368

3344

3369

3345

# Store client before exiting. Secrets are encrypted with key

3370

3346

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

3371

3347

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

3376

3352

client.encrypted_secret = pgp.encrypt(client.secret,

3377

3353

key)

3378

3354

client_dict = {}

3379

3355

3380

3356

# A list of attributes that can not be pickled

3381

3357

# + secret.

3382

exclude = {"bus", "changedstate", "secret",

3383

"checker", "server_settings"}

3358

exclude = { "bus", "changedstate", "secret",

3359

"checker", "server_settings" }

3384

3360

for name, typ in inspect.getmembers(dbus.service

3385

3361

.Object):

3386

3362

exclude.add(name)

3387

3363

3388

3364

client_dict["encrypted_secret"] = (client

3389

3365

.encrypted_secret)

3390

3366

for attr in client.client_structure:

3391

3367

if attr not in exclude:

3392

3368

client_dict[attr] = getattr(client, attr)

3393

3369

3394

3370

clients[client.name] = client_dict

3395

3371

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

3396

3372

3397

3373

try:

3398

3374

with tempfile.NamedTemporaryFile(

3399

3375

mode='wb',

3402

3378

dir=os.path.dirname(stored_state_path),

3403

3379

delete=False) as stored_state:

3404

3380

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

3405

protocol=2)

3381

protocol = 2)

3406

3382

tempname = stored_state.name

3407

3383

os.rename(tempname, stored_state_path)

3408

3384

except (IOError, OSError) as e:

3418

3394

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

3419

3395

exc_info=e)

3420

3396

raise

3421

3397

3422

3398

# Delete all clients, and settings from config

3423

3399

while tcp_server.clients:

3424

3400

name, client = tcp_server.clients.popitem()

3430

3406

if use_dbus:

3431

3407

mandos_dbus_service.client_removed_signal(client)

3432

3408

client_settings.clear()

3433

3409

3434

3410

atexit.register(cleanup)

3435

3411

3436

3412

for client in tcp_server.clients.values():

3437

3413

if use_dbus:

3438

3414

# Emit D-Bus signal for adding

3440

3416

# Need to initiate checking of clients

3441

3417

if client.enabled:

3442

3418

client.init_checker()

3443

3419

3444

3420

tcp_server.enable()

3445

3421

tcp_server.server_activate()

3446

3422

3447

3423

# Find out what port we got

3448

3424

if zeroconf:

3449

3425

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

3454

3430

else: # IPv4

3455

3431

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

3456

3432

*tcp_server.socket.getsockname())

3457

3458

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

3459

3433

3434

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

3435

3460

3436

try:

3461

3437

if zeroconf:

3462

3438

# From the Avahi example code

3467

3443

cleanup()

3468

3444

sys.exit(1)

3469

3445

# End of Avahi example code

3470

3446

3471

3447

GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,

3472

3448

lambda *args, **kwargs:

3473

3449

(tcp_server.handle_request

3474

3450

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

3475

3451

3476

3452

logger.debug("Starting main loop")

3477

3453

main_loop.run()

3478

3454

except AvahiError as error: