/mandos/trunk : revision 9

1

#!/usr/bin/python3 -bI

2

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

3

#

4

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

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

#

13

# Everything else is

14

15

16

#

17

# This file is part of Mandos.

18

#

19

# Mandos is free software: you can redistribute it and/or modify it

20

# under the terms of the GNU General Public License as published by

21

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

22

# (at your option) any later version.

23

#

24

# Mandos is distributed in the hope that it will be useful, but

25

# WITHOUT ANY WARRANTY; without even the implied warranty of

26

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

27

# GNU General Public License for more details.

28

#

29

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

30

# along with Mandos. If not, see <http://www.gnu.org/licenses/>.

31

#

32

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

33

#

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

try:

38

from future_builtins import *

39

except ImportError:

40

pass

41

42

import sys

43

import unittest

44

import argparse

45

import logging

46

import os

47

try:

48

import SocketServer as socketserver

49

except ImportError:

50

import socketserver

1

#!/usr/bin/python

2

3

import SocketServer

51

4

import socket

5

import select

6

from optparse import OptionParser

52

7

import datetime

53

8

import errno

54

try:

55

import ConfigParser as configparser

56

except ImportError:

57

import configparser

9

import gnutls.crypto

10

import gnutls.connection

11

import gnutls.errors

12

import ConfigParser

13

import sys

58

14

import re

15

import os

59

16

import signal

60

import subprocess

61

import atexit

62

import stat

63

import logging.handlers

64

import pwd

65

import contextlib

66

import struct

67

import fcntl

68

import functools

69

try:

70

import cPickle as pickle

71

except ImportError:

72

import pickle

73

import multiprocessing

74

import types

75

import binascii

76

import tempfile

77

import itertools

78

import collections

79

import codecs

80

import random

81

import shlex

82

83

import dbus

84

import dbus.service

85

import gi

86

from gi.repository import GLib

87

from dbus.mainloop.glib import DBusGMainLoop

88

import ctypes

89

import ctypes.util

90

import xml.dom.minidom

91

import inspect

92

93

if sys.version_info.major == 2:

94

__metaclass__ = type

95

str = unicode

96

input = raw_input

97

98

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

99

try:

100

collections.abc.Callable

101

except AttributeError:

102

class abc:

103

Callable = collections.Callable

104

collections.abc = abc

105

del abc

106

107

# Add shlex.quote if it does not exist

108

try:

109

shlex.quote

110

except AttributeError:

111

shlex.quote = re.escape

112

113

# Add os.set_inheritable if it does not exist

114

try:

115

os.set_inheritable

116

except AttributeError:

117

def set_inheritable(fd, inheritable):

118

flags = fcntl.fcntl(fd, fcntl.F_GETFD)

119

if inheritable and ((flags & fcntl.FD_CLOEXEC) != 0):

120

fcntl.fcntl(fd, fcntl.F_SETFL, flags & ~fcntl.FD_CLOEXEC)

121

elif (not inheritable) and ((flags & fcntl.FD_CLOEXEC) == 0):

122

fcntl.fcntl(fd, fcntl.F_SETFL, flags | fcntl.FD_CLOEXEC)

123

os.set_inheritable = set_inheritable

124

del set_inheritable

125

126

# Show warnings by default

127

if not sys.warnoptions:

128

import warnings

129

warnings.simplefilter("default")

130

131

# Try to find the value of SO_BINDTODEVICE:

132

try:

133

# This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and

134

# newer, and it is also the most natural place for it:

135

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

136

except AttributeError:

137

try:

138

# This is where SO_BINDTODEVICE was up to and including Python

139

# 2.6, and also 3.2:

140

from IN import SO_BINDTODEVICE

141

except ImportError:

142

# In Python 2.7 it seems to have been removed entirely.

143

# Try running the C preprocessor:

144

try:

145

cc = subprocess.Popen(["cc", "--language=c", "-E",

146

"/dev/stdin"],

147

stdin=subprocess.PIPE,

148

stdout=subprocess.PIPE)

149

stdout = cc.communicate(

150

"#include <sys/socket.h>\nSO_BINDTODEVICE\n")[0]

151

SO_BINDTODEVICE = int(stdout.splitlines()[-1])

152

except (OSError, ValueError, IndexError):

153

# No value found

154

SO_BINDTODEVICE = None

155

156

if sys.version_info < (3, 2):

157

configparser.Configparser = configparser.SafeConfigParser

158

159

version = "1.8.17"

160

stored_state_file = "clients.pickle"

161

162

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

163

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

164

syslogger = None

165

166

try:

167

if_nametoindex = ctypes.cdll.LoadLibrary(

168

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

169

except (OSError, AttributeError):

170

171

def if_nametoindex(interface):

172

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

173

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

174

with contextlib.closing(socket.socket()) as s:

175

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

176

struct.pack(b"16s16x", interface))

177

interface_index = struct.unpack("I", ifreq[16:20])[0]

178

return interface_index

179

180

181

def copy_function(func):

182

"""Make a copy of a function"""

183

if sys.version_info.major == 2:

184

return types.FunctionType(func.func_code,

185

func.func_globals,

186

func.func_name,

187

func.func_defaults,

188

func.func_closure)

189

else:

190

return types.FunctionType(func.__code__,

191

func.__globals__,

192

func.__name__,

193

func.__defaults__,

194

func.__closure__)

195

196

197

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

198

"""init logger and add loglevel"""

199

200

global syslogger

201

syslogger = (logging.handlers.SysLogHandler(

202

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

203

address="/dev/log"))

204

syslogger.setFormatter(logging.Formatter

205

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

206

" %(message)s"))

207

log.addHandler(syslogger)

208

209

if debug:

210

console = logging.StreamHandler()

211

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

212

" [%(process)d]:"

213

" %(levelname)s:"

214

" %(message)s"))

215

log.addHandler(console)

216

log.setLevel(level)

217

218

219

class PGPError(Exception):

220

"""Exception if encryption/decryption fails"""

221

pass

222

223

224

class PGPEngine:

225

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

226

227

def __init__(self):

228

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

229

self.gpg = "gpg"

230

try:

231

output = subprocess.check_output(["gpgconf"])

232

for line in output.splitlines():

233

name, text, path = line.split(b":")

234

if name == b"gpg":

235

self.gpg = path

236

break

237

except OSError as e:

238

if e.errno != errno.ENOENT:

239

raise

240

self.gnupgargs = ["--batch",

241

"--homedir", self.tempdir,

242

"--force-mdc",

243

"--quiet"]

244

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

245

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

246

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

247

248

def __enter__(self):

249

return self

250

251

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

252

self._cleanup()

253

return False

254

255

def __del__(self):

256

self._cleanup()

257

258

def _cleanup(self):

259

if self.tempdir is not None:

260

# Delete contents of tempdir

261

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

262

topdown=False):

263

for filename in files:

264

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

265

for dirname in dirs:

266

os.rmdir(os.path.join(root, dirname))

267

# Remove tempdir

268

os.rmdir(self.tempdir)

269

self.tempdir = None

270

271

def password_encode(self, password):

272

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

273

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

274

encoded = b"mandos" + binascii.hexlify(password)

275

if len(encoded) > 2048:

276

# GnuPG can't handle long passwords, so encode differently

277

encoded = (b"mandos" + password.replace(b"\\", b"\\\\")

278

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

279

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

280

return encoded

281

282

def encrypt(self, data, password):

283

passphrase = self.password_encode(password)

284

with tempfile.NamedTemporaryFile(

285

dir=self.tempdir) as passfile:

286

passfile.write(passphrase)

287

passfile.flush()

288

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

289

"--passphrase-file",

290

passfile.name]

291

+ self.gnupgargs,

292

stdin=subprocess.PIPE,

293

stdout=subprocess.PIPE,

294

stderr=subprocess.PIPE)

295

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

296

if proc.returncode != 0:

297

raise PGPError(err)

298

return ciphertext

299

300

def decrypt(self, data, password):

301

passphrase = self.password_encode(password)

302

with tempfile.NamedTemporaryFile(

303

dir=self.tempdir) as passfile:

304

passfile.write(passphrase)

305

passfile.flush()

306

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

307

"--passphrase-file",

308

passfile.name]

309

+ self.gnupgargs,

310

stdin=subprocess.PIPE,

311

stdout=subprocess.PIPE,

312

stderr=subprocess.PIPE)

313

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

314

if proc.returncode != 0:

315

raise PGPError(err)

316

return decrypted_plaintext

317

318

319

# Pretend that we have an Avahi module

320

class avahi:

321

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

322

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

323

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

324

PROTO_INET = 0 # avahi-common/address.h

325

PROTO_INET6 = 1 # avahi-common/address.h

326

DBUS_NAME = "org.freedesktop.Avahi"

327

DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"

328

DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"

329

DBUS_PATH_SERVER = "/"

330

331

@staticmethod

332

def string_array_to_txt_array(t):

333

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

334

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

335

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

336

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

337

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

338

SERVER_INVALID = 0 # avahi-common/defs.h

339

SERVER_REGISTERING = 1 # avahi-common/defs.h

340

SERVER_RUNNING = 2 # avahi-common/defs.h

341

SERVER_COLLISION = 3 # avahi-common/defs.h

342

SERVER_FAILURE = 4 # avahi-common/defs.h

343

344

345

class AvahiError(Exception):

346

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

347

self.value = value

348

return super(AvahiError, self).__init__(value, *args,

349

**kwargs)

350

351

352

class AvahiServiceError(AvahiError):

353

pass

354

355

356

class AvahiGroupError(AvahiError):

357

pass

358

359

360

class AvahiService:

361

"""An Avahi (Zeroconf) service.

362

363

Attributes:

364

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

365

Used to optionally bind to the specified interface.

366

name: string; Example: "Mandos"

367

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

368

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

369

port: integer; what port to announce

370

TXT: list of strings; TXT record for the service

371

domain: string; Domain to publish on, default to .local if empty.

372

host: string; Host to publish records for, default is localhost

373

max_renames: integer; maximum number of renames

374

rename_count: integer; counter so we only rename after collisions

375

a sensible number of times

376

group: D-Bus Entry Group

377

server: D-Bus Server

378

bus: dbus.SystemBus()

379

"""

380

381

def __init__(self,

382

interface=avahi.IF_UNSPEC,

383

name=None,

384

servicetype=None,

385

port=None,

386

TXT=None,

387

domain="",

388

host="",

389

max_renames=32768,

390

protocol=avahi.PROTO_UNSPEC,

391

bus=None):

392

self.interface = interface

393

self.name = name

394

self.type = servicetype

395

self.port = port

396

self.TXT = TXT if TXT is not None else []

397

self.domain = domain

398

self.host = host

399

self.rename_count = 0

400

self.max_renames = max_renames

401

self.protocol = protocol

402

self.group = None # our entry group

403

self.server = None

404

self.bus = bus

405

self.entry_group_state_changed_match = None

406

407

def rename(self, remove=True):

408

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

409

if self.rename_count >= self.max_renames:

410

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

411

" after %i retries, exiting.",

412

self.rename_count)

413

raise AvahiServiceError("Too many renames")

414

self.name = str(

415

self.server.GetAlternativeServiceName(self.name))

416

self.rename_count += 1

417

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

418

self.name)

419

if remove:

420

self.remove()

421

try:

422

self.add()

423

except dbus.exceptions.DBusException as error:

424

if (error.get_dbus_name()

425

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

426

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

427

return self.rename(remove=False)

428

else:

429

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

430

self.cleanup()

431

os._exit(1)

432

433

def remove(self):

434

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

435

if self.entry_group_state_changed_match is not None:

436

self.entry_group_state_changed_match.remove()

437

self.entry_group_state_changed_match = None

438

if self.group is not None:

439

self.group.Reset()

440

441

def add(self):

442

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

443

self.remove()

444

if self.group is None:

445

self.group = dbus.Interface(

446

self.bus.get_object(avahi.DBUS_NAME,

447

self.server.EntryGroupNew()),

448

avahi.DBUS_INTERFACE_ENTRY_GROUP)

449

self.entry_group_state_changed_match = (

450

self.group.connect_to_signal(

451

"StateChanged", self.entry_group_state_changed))

452

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

453

self.name, self.type)

454

self.group.AddService(

455

self.interface,

456

self.protocol,

457

dbus.UInt32(0), # flags

458

self.name, self.type,

459

self.domain, self.host,

460

dbus.UInt16(self.port),

461

avahi.string_array_to_txt_array(self.TXT))

462

self.group.Commit()

463

464

def entry_group_state_changed(self, state, error):

465

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

466

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

467

468

if state == avahi.ENTRY_GROUP_ESTABLISHED:

469

log.debug("Zeroconf service established.")

470

elif state == avahi.ENTRY_GROUP_COLLISION:

471

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

472

self.rename()

473

elif state == avahi.ENTRY_GROUP_FAILURE:

474

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

475

str(error))

476

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

477

478

def cleanup(self):

479

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

480

if self.group is not None:

481

try:

482

self.group.Free()

483

except (dbus.exceptions.UnknownMethodException,

484

dbus.exceptions.DBusException):

485

pass

486

self.group = None

487

self.remove()

488

489

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

490

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

491

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

492

bad_states = {

493

avahi.SERVER_INVALID: "Zeroconf server invalid",

494

avahi.SERVER_REGISTERING: None,

495

avahi.SERVER_COLLISION: "Zeroconf server name collision",

496

avahi.SERVER_FAILURE: "Zeroconf server failure",

497

}

498

if state in bad_states:

499

if bad_states[state] is not None:

500

if error is None:

501

log.error(bad_states[state])

502

else:

503

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

504

self.cleanup()

505

elif state == avahi.SERVER_RUNNING:

506

try:

507

self.add()

508

except dbus.exceptions.DBusException as error:

509

if (error.get_dbus_name()

510

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

511

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

512

return self.rename(remove=False)

513

else:

514

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

515

self.cleanup()

516

os._exit(1)

517

else:

518

if error is None:

519

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

520

else:

521

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

522

523

def activate(self):

524

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

525

if self.server is None:

526

self.server = dbus.Interface(

527

self.bus.get_object(avahi.DBUS_NAME,

528

avahi.DBUS_PATH_SERVER,

529

follow_name_owner_changes=True),

530

avahi.DBUS_INTERFACE_SERVER)

531

self.server.connect_to_signal("StateChanged",

532

self.server_state_changed)

533

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

534

535

536

class AvahiServiceToSyslog(AvahiService):

537

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

538

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

539

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

540

**kwargs)

541

syslogger.setFormatter(logging.Formatter(

542

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

543

.format(self.name)))

544

return ret

545

546

547

# Pretend that we have a GnuTLS module

548

class gnutls:

549

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

550

551

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

552

if library is None:

553

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

554

_library = ctypes.cdll.LoadLibrary(library)

555

del library

556

557

# Unless otherwise indicated, the constants and types below are

558

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

559

560

# Constants

561

E_SUCCESS = 0

562

E_INTERRUPTED = -52

563

E_AGAIN = -28

564

CRT_OPENPGP = 2

565

CRT_RAWPK = 3

566

CLIENT = 2

567

SHUT_RDWR = 0

568

CRD_CERTIFICATE = 1

569

E_NO_CERTIFICATE_FOUND = -49

570

X509_FMT_DER = 0

571

NO_TICKETS = 1<<10

572

ENABLE_RAWPK = 1<<18

573

CTYPE_PEERS = 3

574

KEYID_USE_SHA256 = 1 # gnutls/x509.h

575

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

576

577

# Types

578

class _session_int(ctypes.Structure):

579

_fields_ = []

580

session_t = ctypes.POINTER(_session_int)

581

582

class certificate_credentials_st(ctypes.Structure):

583

_fields_ = []

584

certificate_credentials_t = ctypes.POINTER(

585

certificate_credentials_st)

586

certificate_type_t = ctypes.c_int

587

588

class datum_t(ctypes.Structure):

589

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

590

("size", ctypes.c_uint)]

591

592

class _openpgp_crt_int(ctypes.Structure):

593

_fields_ = []

594

openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)

595

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

596

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

597

credentials_type_t = ctypes.c_int

598

transport_ptr_t = ctypes.c_void_p

599

close_request_t = ctypes.c_int

600

601

# Exceptions

602

class Error(Exception):

603

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

604

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

605

# code is passed, convert it to a string with

606

# gnutls.strerror()

607

self.code = code

608

if message is None and code is not None:

609

message = gnutls.strerror(code).decode(

610

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

611

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

612

message, *args)

613

614

class CertificateSecurityError(Error):

615

pass

616

617

class PointerTo:

618

def __init__(self, cls):

619

self.cls = cls

620

621

def from_param(self, obj):

622

if not isinstance(obj, self.cls):

623

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

624

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

625

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

626

627

class CastToVoidPointer:

628

def __init__(self, cls):

629

self.cls = cls

630

631

def from_param(self, obj):

632

if not isinstance(obj, self.cls):

633

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

634

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

635

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

636

637

class With_from_param:

638

@classmethod

639

def from_param(cls, obj):

640

return obj._as_parameter_

641

642

# Classes

643

class Credentials(With_from_param):

644

def __init__(self):

645

self._as_parameter_ = gnutls.certificate_credentials_t()

646

gnutls.certificate_allocate_credentials(self)

647

self.type = gnutls.CRD_CERTIFICATE

648

649

def __del__(self):

650

gnutls.certificate_free_credentials(self)

651

652

class ClientSession(With_from_param):

653

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

654

self._as_parameter_ = gnutls.session_t()

655

gnutls_flags = gnutls.CLIENT

656

if gnutls.check_version(b"3.5.6"):

657

gnutls_flags |= gnutls.NO_TICKETS

658

if gnutls.has_rawpk:

659

gnutls_flags |= gnutls.ENABLE_RAWPK

660

gnutls.init(self, gnutls_flags)

661

del gnutls_flags

662

gnutls.set_default_priority(self)

663

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

664

gnutls.handshake_set_private_extensions(self, True)

665

self.socket = socket

666

if credentials is None:

667

credentials = gnutls.Credentials()

668

gnutls.credentials_set(self, credentials.type,

669

credentials)

670

self.credentials = credentials

671

672

def __del__(self):

673

gnutls.deinit(self)

674

675

def handshake(self):

676

return gnutls.handshake(self)

677

678

def send(self, data):

679

data = bytes(data)

680

data_len = len(data)

681

while data_len > 0:

682

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

683

data_len)

684

685

def bye(self):

686

return gnutls.bye(self, gnutls.SHUT_RDWR)

687

688

# Error handling functions

689

def _error_code(result):

690

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

691

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

692

if result >= gnutls.E_SUCCESS:

693

return result

694

if result == gnutls.E_NO_CERTIFICATE_FOUND:

695

raise gnutls.CertificateSecurityError(code=result)

696

raise gnutls.Error(code=result)

697

698

def _retry_on_error(result, func, arguments,

699

_error_code=_error_code):

700

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

701

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

702

while result < gnutls.E_SUCCESS:

703

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

704

return _error_code(result)

705

result = func(*arguments)

706

return result

707

708

# Unless otherwise indicated, the function declarations below are

709

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

710

711

# Functions

712

priority_set_direct = _library.gnutls_priority_set_direct

713

priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,

714

ctypes.POINTER(ctypes.c_char_p)]

715

priority_set_direct.restype = _error_code

716

717

init = _library.gnutls_init

718

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

719

init.restype = _error_code

720

721

set_default_priority = _library.gnutls_set_default_priority

722

set_default_priority.argtypes = [ClientSession]

723

set_default_priority.restype = _error_code

724

725

record_send = _library.gnutls_record_send

726

record_send.argtypes = [ClientSession, ctypes.c_void_p,

727

ctypes.c_size_t]

728

record_send.restype = ctypes.c_ssize_t

729

record_send.errcheck = _retry_on_error

730

731

certificate_allocate_credentials = (

732

_library.gnutls_certificate_allocate_credentials)

733

certificate_allocate_credentials.argtypes = [

734

PointerTo(Credentials)]

735

certificate_allocate_credentials.restype = _error_code

736

737

certificate_free_credentials = (

738

_library.gnutls_certificate_free_credentials)

739

certificate_free_credentials.argtypes = [Credentials]

740

certificate_free_credentials.restype = None

741

742

handshake_set_private_extensions = (

743

_library.gnutls_handshake_set_private_extensions)

744

handshake_set_private_extensions.argtypes = [ClientSession,

745

ctypes.c_int]

746

handshake_set_private_extensions.restype = None

747

748

credentials_set = _library.gnutls_credentials_set

749

credentials_set.argtypes = [ClientSession, credentials_type_t,

750

CastToVoidPointer(Credentials)]

751

credentials_set.restype = _error_code

752

753

strerror = _library.gnutls_strerror

754

strerror.argtypes = [ctypes.c_int]

755

strerror.restype = ctypes.c_char_p

756

757

certificate_type_get = _library.gnutls_certificate_type_get

758

certificate_type_get.argtypes = [ClientSession]

759

certificate_type_get.restype = _error_code

760

761

certificate_get_peers = _library.gnutls_certificate_get_peers

762

certificate_get_peers.argtypes = [ClientSession,

763

ctypes.POINTER(ctypes.c_uint)]

764

certificate_get_peers.restype = ctypes.POINTER(datum_t)

765

766

global_set_log_level = _library.gnutls_global_set_log_level

767

global_set_log_level.argtypes = [ctypes.c_int]

768

global_set_log_level.restype = None

769

770

global_set_log_function = _library.gnutls_global_set_log_function

771

global_set_log_function.argtypes = [log_func]

772

global_set_log_function.restype = None

773

774

deinit = _library.gnutls_deinit

775

deinit.argtypes = [ClientSession]

776

deinit.restype = None

777

778

handshake = _library.gnutls_handshake

779

handshake.argtypes = [ClientSession]

780

handshake.restype = ctypes.c_int

781

handshake.errcheck = _retry_on_error

782

783

transport_set_ptr = _library.gnutls_transport_set_ptr

784

transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]

785

transport_set_ptr.restype = None

786

787

bye = _library.gnutls_bye

788

bye.argtypes = [ClientSession, close_request_t]

789

bye.restype = ctypes.c_int

790

bye.errcheck = _retry_on_error

791

792

check_version = _library.gnutls_check_version

793

check_version.argtypes = [ctypes.c_char_p]

794

check_version.restype = ctypes.c_char_p

795

796

_need_version = b"3.3.0"

797

if check_version(_need_version) is None:

798

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

799

.format(_need_version))

800

801

_tls_rawpk_version = b"3.6.6"

802

has_rawpk = bool(check_version(_tls_rawpk_version))

803

804

if has_rawpk:

805

# Types

806

class pubkey_st(ctypes.Structure):

807

_fields = []

808

pubkey_t = ctypes.POINTER(pubkey_st)

809

810

x509_crt_fmt_t = ctypes.c_int

811

812

# All the function declarations below are from

813

# gnutls/abstract.h

814

pubkey_init = _library.gnutls_pubkey_init

815

pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]

816

pubkey_init.restype = _error_code

817

818

pubkey_import = _library.gnutls_pubkey_import

819

pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),

820

x509_crt_fmt_t]

821

pubkey_import.restype = _error_code

822

823

pubkey_get_key_id = _library.gnutls_pubkey_get_key_id

824

pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,

825

ctypes.POINTER(ctypes.c_ubyte),

826

ctypes.POINTER(ctypes.c_size_t)]

827

pubkey_get_key_id.restype = _error_code

828

829

pubkey_deinit = _library.gnutls_pubkey_deinit

830

pubkey_deinit.argtypes = [pubkey_t]

831

pubkey_deinit.restype = None

832

else:

833

# All the function declarations below are from

834

# gnutls/openpgp.h

835

836

openpgp_crt_init = _library.gnutls_openpgp_crt_init

837

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

838

openpgp_crt_init.restype = _error_code

839

840

openpgp_crt_import = _library.gnutls_openpgp_crt_import

841

openpgp_crt_import.argtypes = [openpgp_crt_t,

842

ctypes.POINTER(datum_t),

843

openpgp_crt_fmt_t]

844

openpgp_crt_import.restype = _error_code

845

846

openpgp_crt_verify_self = \

847

_library.gnutls_openpgp_crt_verify_self

848

openpgp_crt_verify_self.argtypes = [

849

openpgp_crt_t,

850

ctypes.c_uint,

851

ctypes.POINTER(ctypes.c_uint),

852

]

853

openpgp_crt_verify_self.restype = _error_code

854

855

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

856

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

857

openpgp_crt_deinit.restype = None

858

859

openpgp_crt_get_fingerprint = (

860

_library.gnutls_openpgp_crt_get_fingerprint)

861

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

862

ctypes.c_void_p,

863

ctypes.POINTER(

864

ctypes.c_size_t)]

865

openpgp_crt_get_fingerprint.restype = _error_code

866

867

if check_version(b"3.6.4"):

868

certificate_type_get2 = _library.gnutls_certificate_type_get2

869

certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]

870

certificate_type_get2.restype = _error_code

871

872

# Remove non-public functions

873

del _error_code, _retry_on_error

874

875

876

def call_pipe(connection, # : multiprocessing.Connection

877

func, *args, **kwargs):

878

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

879

880

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

881

return value on the provided multiprocessing.Connection.

882

"""

883

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

884

connection.close()

885

886

887

class Client:

888

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

889

890

Attributes:

891

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

892

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

893

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

894

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

895

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

896

running.

897

checker_callback_tag: a GLib event source tag, or None

898

checker_command: string; External command which is run to check

899

if client lives. %() expansions are done at

900

runtime with vars(self) as dict, so that for

901

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

902

checker_initiator_tag: a GLib event source tag, or None

903

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

904

client_structure: Object describing what attributes a client has

905

and is used for storing the client at exit

906

current_checker_command: string; current running checker_command

907

disable_initiator_tag: a GLib event source tag, or None

908

enabled: bool()

909

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

910

uniquely identify an OpenPGP client

911

key_id: string (64 hexadecimal digits); used to uniquely identify

912

a client using raw public keys

913

host: string; available for use by the checker command

914

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

915

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

916

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

917

last_checker_status: integer between 0 and 255 reflecting exit

918

status of last checker. -1 reflects crashed

919

checker, -2 means no checker completed yet.

920

last_checker_signal: The signal which killed the last checker, if

921

last_checker_status is -1

922

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

923

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

924

D-Bus identifiers

925

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

926

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

927

until this client is disabled

928

extended_timeout: extra long timeout when secret has been sent

929

runtime_expansions: Allowed attributes for runtime expansion.

930

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

931

disabled, or None

932

server_settings: The server_settings dict from main()

933

"""

934

935

runtime_expansions = ("approval_delay", "approval_duration",

936

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

937

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

938

"last_approval_request", "last_checked_ok",

939

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

940

client_defaults = {

941

"timeout": "PT5M",

942

"extended_timeout": "PT15M",

943

"interval": "PT2M",

944

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

945

"host": "",

946

"approval_delay": "PT0S",

947

"approval_duration": "PT1S",

948

"approved_by_default": "True",

949

"enabled": "True",

950

}

951

952

@staticmethod

953

def config_parser(config):

954

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

955

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

956

with exceptions for any special settings as defined above.

957

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

958

value given the same arguments.

959

"""

960

settings = {}

961

for client_name in config.sections():

962

section = dict(config.items(client_name))

963

client = settings[client_name] = {}

964

965

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

966

# Reformat values from string types to Python types

967

client["approved_by_default"] = config.getboolean(

968

client_name, "approved_by_default")

969

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

970

"enabled")

971

972

# Uppercase and remove spaces from key_id and fingerprint

973

# for later comparison purposes with return value from the

974

# key_id() and fingerprint() functions

975

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

976

.replace(" ", ""))

977

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

978

"").upper()

979

.replace(" ", ""))

980

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

981

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

982

" fingerprint", client_name)

983

del settings[client_name]

984

continue

985

if "secret" in section:

986

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

987

.encode("utf-8"),

988

"base64")

989

elif "secfile" in section:

990

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

991

(section["secfile"])),

992

"rb") as secfile:

993

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

994

else:

995

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

996

.format(section))

997

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

998

client["extended_timeout"] = string_to_delta(

999

section["extended_timeout"])

1000

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

1001

client["approval_delay"] = string_to_delta(

1002

section["approval_delay"])

1003

client["approval_duration"] = string_to_delta(

1004

section["approval_duration"])

1005

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

1006

client["last_approval_request"] = None

1007

client["last_checked_ok"] = None

1008

client["last_checker_status"] = -2

1009

1010

return settings

1011

1012

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

1013

self.name = name

1014

if server_settings is None:

1015

server_settings = {}

1016

self.server_settings = server_settings

1017

# adding all client settings

1018

for setting, value in settings.items():

1019

setattr(self, setting, value)

1020

1021

if self.enabled:

1022

if not hasattr(self, "last_enabled"):

1023

self.last_enabled = datetime.datetime.utcnow()

1024

if not hasattr(self, "expires"):

1025

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

1026

+ self.timeout)

1027

else:

1028

self.last_enabled = None

1029

self.expires = None

1030

1031

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

1032

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

1033

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

1034

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

1035

datetime.datetime.utcnow())

1036

1037

# attributes specific for this server instance

1038

self.checker = None

1039

self.checker_initiator_tag = None

1040

self.disable_initiator_tag = None

1041

self.checker_callback_tag = None

1042

self.current_checker_command = None

1043

self.approved = None

1044

self.approvals_pending = 0

1045

self.changedstate = multiprocessing_manager.Condition(

1046

multiprocessing_manager.Lock())

1047

self.client_structure = [attr

1048

for attr in self.__dict__.keys()

1049

if not attr.startswith("_")]

1050

self.client_structure.append("client_structure")

1051

1052

for name, t in inspect.getmembers(

1053

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

1054

if not name.startswith("_"):

1055

self.client_structure.append(name)

1056

1057

# Send notice to process children that client state has changed

1058

def send_changedstate(self):

1059

with self.changedstate:

1060

self.changedstate.notify_all()

1061

1062

def enable(self):

1063

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

1064

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

1065

# Already enabled

1066

return

1067

self.enabled = True

1068

self.last_enabled = datetime.datetime.utcnow()

1069

self.init_checker()

1070

self.send_changedstate()

1071

1072

def disable(self, quiet=True):

1073

"""Disable this client."""

1074

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

1075

return False

1076

if not quiet:

1077

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

1078

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

1079

GLib.source_remove(self.disable_initiator_tag)

1080

self.disable_initiator_tag = None

1081

self.expires = None

1082

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

1083

GLib.source_remove(self.checker_initiator_tag)

1084

self.checker_initiator_tag = None

1085

self.stop_checker()

1086

self.enabled = False

1087

if not quiet:

1088

self.send_changedstate()

1089

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

1090

return False

1091

1092

def __del__(self):

1093

self.disable()

1094

1095

def init_checker(self, randomize_start=False):

1096

# Schedule a new checker to be started a randomly selected

1097

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

1098

# the startup of checkers over time when the server is

1099

# started.

1100

if self.checker_initiator_tag is not None:

1101

GLib.source_remove(self.checker_initiator_tag)

1102

interval_milliseconds = int(self.interval.total_seconds()

1103

* 1000)

1104

if randomize_start:

1105

delay_milliseconds = random.randrange(

1106

interval_milliseconds + 1)

1107

else:

1108

delay_milliseconds = interval_milliseconds

1109

self.checker_initiator_tag = GLib.timeout_add(

1110

delay_milliseconds, self.start_checker, randomize_start)

1111

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

1112

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

1113

# expire at the soonest one interval after a checker was

1114

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

1115

# time might have to be extended.

1116

now = datetime.datetime.utcnow()

1117

self.expires = now + delay + self.interval

1118

# Schedule a disable() at expire time

1119

if self.disable_initiator_tag is not None:

1120

GLib.source_remove(self.disable_initiator_tag)

1121

self.disable_initiator_tag = GLib.timeout_add(

1122

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

1123

self.disable)

1124

1125

def checker_callback(self, source, condition, connection,

1126

command):

1127

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

1128

# Read return code from connection (see call_pipe)

1129

returncode = connection.recv()

1130

connection.close()

1131

if self.checker is not None:

1132

self.checker.join()

1133

self.checker_callback_tag = None

1134

self.checker = None

1135

1136

if returncode >= 0:

1137

self.last_checker_status = returncode

1138

self.last_checker_signal = None

1139

if self.last_checker_status == 0:

1140

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

1141

self.checked_ok()

1142

else:

1143

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

1144

else:

1145

self.last_checker_status = -1

1146

self.last_checker_signal = -returncode

1147

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

1148

return False

1149

1150

def checked_ok(self):

1151

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

1152

self.last_checked_ok = datetime.datetime.utcnow()

1153

self.last_checker_status = 0

1154

self.last_checker_signal = None

1155

self.bump_timeout()

1156

1157

def bump_timeout(self, timeout=None):

1158

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

17

18

class Client(object):

19

def __init__(self, name=None, options=None, dn=None,

20

password=None, passfile=None, fqdn=None,

21

timeout=None, interval=-1):

22

self.name = name

23

self.dn = dn

24

if password:

25

self.password = password

26

elif passfile:

27

self.password = open(passfile).readall()

28

else:

29

print "No Password or Passfile in client config file"

30

# raise RuntimeError XXX

31

self.password = "gazonk"

32

self.fqdn = fqdn # string

33

self.created = datetime.datetime.now()

34

self.last_seen = None # datetime.datetime()

1159

35

if timeout is None:

1160

timeout = self.timeout

1161

if self.disable_initiator_tag is not None:

1162

GLib.source_remove(self.disable_initiator_tag)

1163

self.disable_initiator_tag = None

1164

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

1165

self.disable_initiator_tag = GLib.timeout_add(

1166

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

1167

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

1168

1169

def need_approval(self):

1170

self.last_approval_request = datetime.datetime.utcnow()

1171

1172

def start_checker(self, start_was_randomized=False):

1173

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

1174

1175

If a checker already exists, leave it running and do

1176

nothing."""

1177

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

1178

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

1179

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

1180

# would inevitably timeout, since no checker would get a

1181

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

1182

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

1183

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

1184

# should be.

1185

1186

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

1187

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

1188

self.checker.join()

1189

self.checker = None

1190

# Start a new checker if needed

1191

if self.checker is None:

1192

# Escape attributes for the shell

1193

escaped_attrs = {

1194

attr: shlex.quote(str(getattr(self, attr)))

1195

for attr in self.runtime_expansions}

1196

try:

1197

command = self.checker_command % escaped_attrs

1198

except TypeError as error:

1199

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

1200

self.checker_command, exc_info=error)

1201

return True # Try again later

1202

self.current_checker_command = command

1203

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

1204

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

1205

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

1206

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

1207

# always replaced by /dev/null.)

1208

# The exception is when not debugging but nevertheless

1209

# running in the foreground; use the previously

1210

# created wnull.

1211

popen_args = {"close_fds": True,

1212

"shell": True,

1213

"cwd": "/"}

1214

if (not self.server_settings["debug"]

1215

and self.server_settings["foreground"]):

1216

popen_args.update({"stdout": wnull,

1217

"stderr": wnull})

1218

pipe = multiprocessing.Pipe(duplex=False)

1219

self.checker = multiprocessing.Process(

1220

target=call_pipe,

1221

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

1222

kwargs=popen_args)

1223

self.checker.start()

1224

self.checker_callback_tag = GLib.io_add_watch(

1225

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

1226

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

1227

self.checker_callback, pipe[0], command)

1228

if start_was_randomized:

1229

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

1230

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

1231

# interval from then on.

1232

now = datetime.datetime.utcnow()

1233

self.checker_initiator_tag = GLib.timeout_add(

1234

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

1235

self.start_checker)

1236

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

1237

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

1238

return False

1239

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

1240

return True

1241

36

timeout = options.timeout

37

self.timeout = timeout # datetime.timedelta()

38

if interval == -1:

39

interval = options.interval

40

self.interval = interval # datetime.timedelta()

41

self.next_check = datetime.datetime.now() # datetime.datetime()

42

self.checker = None # or a subprocess.Popen()

43

def check_action(self, now=None):

44

"""The checker said something and might have completed.

45

Check if is has, and take appropriate actions."""

46

if self.checker.poll() is None:

47

# False alarm, no result yet

48

#self.checker.read()

49

return

50

if now is None:

51

now = datetime.datetime.now()

52

if self.checker.returncode == 0:

53

self.last_seen = now

54

while self.next_check <= now:

55

self.next_check += self.interval

56

handle_request = check_action

57

def start_checker(self):

58

self.stop_checker()

59

try:

60

self.checker = subprocess.Popen("sleep 1; fping -q -- %s"

61

% re.escape(self.fqdn),

62

stdout=subprocess.PIPE,

63

close_fds=True,

64

shell=True, cwd="/")

65

except subprocess.OSError, e:

66

print "Failed to start subprocess:", e

1242

67

def stop_checker(self):

1243

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

1244

if self.checker_callback_tag:

1245

GLib.source_remove(self.checker_callback_tag)

1246

self.checker_callback_tag = None

1247

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

68

if self.checker is None:

1248

69

return

1249

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

1250

self.checker.terminate()

70

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

71

if self.checker.poll() is None:

72

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

1251

73

self.checker = None

1252

1253

1254

def dbus_service_property(dbus_interface,

1255

signature="v",

1256

access="readwrite",

1257

byte_arrays=False):

1258

"""Decorators for marking methods of a DBusObjectWithProperties to

1259

become properties on the D-Bus.

1260

1261

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

1262

and with one argument by "Set".

1263

1264

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

1265

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

1266

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

1267

"""

1268

# Encoding deeply encoded byte arrays is not supported yet by the

1269

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

1270

if byte_arrays and signature != "ay":

1271

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

1272

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

1273

1274

def decorator(func):

1275

func._dbus_is_property = True

1276

func._dbus_interface = dbus_interface

1277

func._dbus_signature = signature

1278

func._dbus_access = access

1279

func._dbus_name = func.__name__

1280

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

1281

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

1282

func._dbus_get_args_options = {"byte_arrays": byte_arrays}

1283

return func

1284

1285

return decorator

1286

1287

1288

def dbus_interface_annotations(dbus_interface):

1289

"""Decorator for marking functions returning interface annotations

1290

1291

Usage:

1292

1293

@dbus_interface_annotations("org.example.Interface")

1294

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

1295

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

1296

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

1297

"false"}

1298

"""

1299

1300

def decorator(func):

1301

func._dbus_is_interface = True

1302

func._dbus_interface = dbus_interface

1303

func._dbus_name = dbus_interface

1304

return func

1305

1306

return decorator

1307

1308

1309

def dbus_annotations(annotations):

1310

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

1311

Usage:

1312

1313

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

1314

"org.freedesktop.DBus.Property."

1315

"EmitsChangedSignal": "false"})

1316

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

1317

access="r")

1318

def Property_dbus_property(self):

1319

return dbus.Boolean(False)

1320

1321

See also the DBusObjectWithAnnotations class.

1322

"""

1323

1324

def decorator(func):

1325

func._dbus_annotations = annotations

1326

return func

1327

1328

return decorator

1329

1330

1331

class DBusPropertyException(dbus.exceptions.DBusException):

1332

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

1333

"""

1334

pass

1335

1336

1337

class DBusPropertyAccessException(DBusPropertyException):

1338

"""A property's access permissions disallows an operation.

1339

"""

1340

pass

1341

1342

1343

class DBusPropertyNotFound(DBusPropertyException):

1344

"""An attempt was made to access a non-existing property.

1345

"""

1346

pass

1347

1348

1349

class DBusObjectWithAnnotations(dbus.service.Object):

1350

"""A D-Bus object with annotations.

1351

1352

Classes inheriting from this can use the dbus_annotations

1353

decorator to add annotations to methods or signals.

1354

"""

1355

1356

@staticmethod

1357

def _is_dbus_thing(thing):

1358

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

1359

1360

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

1361

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

1362

"""

1363

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

1364

False)

1365

1366

def _get_all_dbus_things(self, thing):

1367

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

1368

"""

1369

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

1370

athing.__get__(self))

1371

for cls in self.__class__.__mro__

1372

for name, athing in

1373

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

1374

1375

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1376

out_signature="s",

1377

path_keyword="object_path",

1378

connection_keyword="connection")

1379

def Introspect(self, object_path, connection):

1380

"""Overloading of standard D-Bus method.

1381

1382

Inserts annotation tags on methods and signals.

1383

"""

1384

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

1385

connection)

1386

try:

1387

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

1388

1389

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

1390

# Add annotation tags

1391

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

1392

for tag in if_tag.getElementsByTagName(typ):

1393

annots = dict()

1394

for name, prop in (self.

1395

_get_all_dbus_things(typ)):

1396

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

1397

and prop._dbus_interface

1398

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

1399

annots.update(getattr(

1400

prop, "_dbus_annotations", {}))

1401

for name, value in annots.items():

1402

ann_tag = document.createElement(

1403

"annotation")

1404

ann_tag.setAttribute("name", name)

1405

ann_tag.setAttribute("value", value)

1406

tag.appendChild(ann_tag)

1407

# Add interface annotation tags

1408

for annotation, value in dict(

1409

itertools.chain.from_iterable(

1410

annotations().items()

1411

for name, annotations

1412

in self._get_all_dbus_things("interface")

1413

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

1414

)).items():

1415

ann_tag = document.createElement("annotation")

1416

ann_tag.setAttribute("name", annotation)

1417

ann_tag.setAttribute("value", value)

1418

if_tag.appendChild(ann_tag)

1419

# Fix argument name for the Introspect method itself

1420

if (if_tag.getAttribute("name")

1421

== dbus.INTROSPECTABLE_IFACE):

1422

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

1423

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

1424

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

1425

if (arg.getAttribute("direction")

1426

== "out"):

1427

arg.setAttribute("name",

1428

"xml_data")

1429

xmlstring = document.toxml("utf-8")

1430

document.unlink()

1431

except (AttributeError, xml.dom.DOMException,

1432

xml.parsers.expat.ExpatError) as error:

1433

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

1434

exc_info=error)

1435

return xmlstring

1436

1437

1438

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1439

"""A D-Bus object with properties.

1440

1441

Classes inheriting from this can use the dbus_service_property

1442

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

1443

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

1444

"""

1445

1446

def _get_dbus_property(self, interface_name, property_name):

1447

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

1448

property with the specified name and interface.

1449

"""

1450

for cls in self.__class__.__mro__:

1451

for name, value in inspect.getmembers(

1452

cls, self._is_dbus_thing("property")):

1453

if (value._dbus_name == property_name

1454

and value._dbus_interface == interface_name):

1455

return value.__get__(self)

1456

1457

# No such property

1458

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

1459

self.dbus_object_path, interface_name, property_name))

1460

1461

@classmethod

1462

def _get_all_interface_names(cls):

1463

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

1464

return (name for name in set(getattr(getattr(x, attr),

1465

"_dbus_interface", None)

1466

for x in (inspect.getmro(cls))

1467

for attr in dir(x))

1468

if name is not None)

1469

1470

@dbus.service.method(dbus.PROPERTIES_IFACE,

1471

in_signature="ss",

1472

out_signature="v")

1473

def Get(self, interface_name, property_name):

1474

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

1475

"""

1476

prop = self._get_dbus_property(interface_name, property_name)

1477

if prop._dbus_access == "write":

1478

raise DBusPropertyAccessException(property_name)

1479

value = prop()

1480

if not hasattr(value, "variant_level"):

1481

return value

1482

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

1483

1484

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

1485

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

1486

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

1487

"""

1488

prop = self._get_dbus_property(interface_name, property_name)

1489

if prop._dbus_access == "read":

1490

raise DBusPropertyAccessException(property_name)

1491

if prop._dbus_get_args_options["byte_arrays"]:

1492

# The byte_arrays option is not supported yet on

1493

# signatures other than "ay".

1494

if prop._dbus_signature != "ay":

1495

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

1496

"'ay' signature {!r}"

1497

.format(prop._dbus_signature))

1498

value = dbus.ByteArray(bytes(value))

1499

prop(value)

1500

1501

@dbus.service.method(dbus.PROPERTIES_IFACE,

1502

in_signature="s",

1503

out_signature="a{sv}")

1504

def GetAll(self, interface_name):

1505

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

1506

standard.

1507

1508

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

1509

"""

1510

properties = {}

1511

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

1512

if (interface_name

1513

and interface_name != prop._dbus_interface):

1514

# Interface non-empty but did not match

1515

continue

1516

# Ignore write-only properties

1517

if prop._dbus_access == "write":

1518

continue

1519

value = prop()

1520

if not hasattr(value, "variant_level"):

1521

properties[name] = value

1522

continue

1523

properties[name] = type(value)(

1524

value, variant_level=value.variant_level + 1)

1525

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

1526

1527

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

1528

def PropertiesChanged(self, interface_name, changed_properties,

1529

invalidated_properties):

1530

"""Standard D-Bus PropertiesChanged() signal, see D-Bus

1531

standard.

1532

"""

1533

pass

1534

1535

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1536

out_signature="s",

1537

path_keyword="object_path",

1538

connection_keyword="connection")

1539

def Introspect(self, object_path, connection):

1540

"""Overloading of standard D-Bus method.

1541

1542

Inserts property tags and interface annotation tags.

1543

"""

1544

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1545

object_path,

1546

connection)

1547

try:

1548

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

1549

1550

def make_tag(document, name, prop):

1551

e = document.createElement("property")

1552

e.setAttribute("name", name)

1553

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

1554

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

1555

return e

1556

1557

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

1558

# Add property tags

1559

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

1560

for name, prop

1561

in self._get_all_dbus_things("property")

1562

if prop._dbus_interface

1563

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

1564

if_tag.appendChild(tag)

1565

# Add annotation tags for properties

1566

for tag in if_tag.getElementsByTagName("property"):

1567

annots = dict()

1568

for name, prop in self._get_all_dbus_things(

1569

"property"):

1570

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

1571

and prop._dbus_interface

1572

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

1573

annots.update(getattr(

1574

prop, "_dbus_annotations", {}))

1575

for name, value in annots.items():

1576

ann_tag = document.createElement(

1577

"annotation")

1578

ann_tag.setAttribute("name", name)

1579

ann_tag.setAttribute("value", value)

1580

tag.appendChild(ann_tag)

1581

# Add the names to the return values for the

1582

# "org.freedesktop.DBus.Properties" methods

1583

if (if_tag.getAttribute("name")

1584

== "org.freedesktop.DBus.Properties"):

1585

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

1586

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

1587

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

1588

if (arg.getAttribute("direction")

1589

== "out"):

1590

arg.setAttribute("name", "value")

1591

elif cn.getAttribute("name") == "GetAll":

1592

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

1593

if (arg.getAttribute("direction")

1594

== "out"):

1595

arg.setAttribute("name", "props")

1596

xmlstring = document.toxml("utf-8")

1597

document.unlink()

1598

except (AttributeError, xml.dom.DOMException,

1599

xml.parsers.expat.ExpatError) as error:

1600

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

1601

exc_info=error)

1602

return xmlstring

1603

1604

1605

try:

1606

dbus.OBJECT_MANAGER_IFACE

1607

except AttributeError:

1608

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

1609

1610

1611

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1612

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

1613

1614

Classes inheriting from this exposes the standard

1615

GetManagedObjects call and the InterfacesAdded and

1616

InterfacesRemoved signals on the standard

1617

"org.freedesktop.DBus.ObjectManager" interface.

1618

1619

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

1620

manually.

1621

"""

1622

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1623

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

1624

def GetManagedObjects(self):

1625

"""This function must be overridden"""

1626

raise NotImplementedError()

1627

1628

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1629

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

1630

def InterfacesAdded(self, object_path, interfaces_and_properties):

1631

pass

1632

1633

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

1634

def InterfacesRemoved(self, object_path, interfaces):

1635

pass

1636

1637

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1638

out_signature="s",

1639

path_keyword="object_path",

1640

connection_keyword="connection")

1641

def Introspect(self, object_path, connection):

1642

"""Overloading of standard D-Bus method.

1643

1644

Override return argument name of GetManagedObjects to be

1645

"objpath_interfaces_and_properties"

1646

"""

1647

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1648

object_path,

1649

connection)

1650

try:

1651

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

1652

1653

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

1654

# Fix argument name for the GetManagedObjects method

1655

if (if_tag.getAttribute("name")

1656

== dbus.OBJECT_MANAGER_IFACE):

1657

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

1658

if (cn.getAttribute("name")

1659

== "GetManagedObjects"):

1660

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

1661

if (arg.getAttribute("direction")

1662

== "out"):

1663

arg.setAttribute(

1664

"name",

1665

"objpath_interfaces"

1666

"_and_properties")

1667

xmlstring = document.toxml("utf-8")

1668

document.unlink()

1669

except (AttributeError, xml.dom.DOMException,

1670

xml.parsers.expat.ExpatError) as error:

1671

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

1672

exc_info=error)

1673

return xmlstring

1674

1675

1676

def datetime_to_dbus(dt, variant_level=0):

1677

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

1678

if dt is None:

1679

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

1680

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

1681

1682

1683

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1684

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

1685

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

1686

interface names according to the "alt_interface_names" mapping.

1687

Usage:

1688

1689

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

1690

"net.example.AlternateInterface"})

1691

class SampleDBusObject(dbus.service.Object):

1692

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

1693

def SampleDBusMethod():

1694

pass

1695

1696

The above "SampleDBusMethod" on "SampleDBusObject" will be

1697

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

1698

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

1699

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

1700

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

1701

1702

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

1703

(from DBusObjectWithProperties) and interfaces (from the

1704

dbus_interface_annotations decorator).

1705

"""

1706

1707

def wrapper(cls):

1708

for orig_interface_name, alt_interface_name in (

1709

alt_interface_names.items()):

1710

attr = {}

1711

interface_names = set()

1712

# Go though all attributes of the class

1713

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

1714

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

1715

# with the wrong interface name

1716

if (not hasattr(attribute, "_dbus_interface")

1717

or not attribute._dbus_interface.startswith(

1718

orig_interface_name)):

1719

continue

1720

# Create an alternate D-Bus interface name based on

1721

# the current name

1722

alt_interface = attribute._dbus_interface.replace(

1723

orig_interface_name, alt_interface_name)

1724

interface_names.add(alt_interface)

1725

# Is this a D-Bus signal?

1726

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

1727

# Extract the original non-method undecorated

1728

# function by black magic

1729

if sys.version_info.major == 2:

1730

nonmethod_func = (dict(

1731

zip(attribute.func_code.co_freevars,

1732

attribute.__closure__))

1733

["func"].cell_contents)

1734

else:

1735

nonmethod_func = (dict(

1736

zip(attribute.__code__.co_freevars,

1737

attribute.__closure__))

1738

["func"].cell_contents)

1739

# Create a new, but exactly alike, function

1740

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

1741

# with the alternate D-Bus interface name

1742

new_function = copy_function(nonmethod_func)

1743

new_function = (dbus.service.signal(

1744

alt_interface,

1745

attribute._dbus_signature)(new_function))

1746

# Copy annotations, if any

1747

try:

1748

new_function._dbus_annotations = dict(

1749

attribute._dbus_annotations)

1750

except AttributeError:

1751

pass

1752

1753

# Define a creator of a function to call both the

1754

# original and alternate functions, so both the

1755

# original and alternate signals gets sent when

1756

# the function is called

1757

def fixscope(func1, func2):

1758

"""This function is a scope container to pass

1759

func1 and func2 to the "call_both" function

1760

outside of its arguments"""

1761

1762

@functools.wraps(func2)

1763

def call_both(*args, **kwargs):

1764

"""This function will emit two D-Bus

1765

signals by calling func1 and func2"""

1766

func1(*args, **kwargs)

1767

func2(*args, **kwargs)

1768

# Make wrapper function look like a D-Bus

1769

# signal

1770

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

1771

if name.startswith("_dbus_"):

1772

setattr(call_both, name, attr)

1773

1774

return call_both

1775

# Create the "call_both" function and add it to

1776

# the class

1777

attr[attrname] = fixscope(attribute, new_function)

1778

# Is this a D-Bus method?

1779

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

1780

# Create a new, but exactly alike, function

1781

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

1782

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

1783

# to the class.

1784

attr[attrname] = (

1785

dbus.service.method(

1786

alt_interface,

1787

attribute._dbus_in_signature,

1788

attribute._dbus_out_signature)

1789

(copy_function(attribute)))

1790

# Copy annotations, if any

1791

try:

1792

attr[attrname]._dbus_annotations = dict(

1793

attribute._dbus_annotations)

1794

except AttributeError:

1795

pass

1796

# Is this a D-Bus property?

1797

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

1798

# Create a new, but exactly alike, function

1799

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

1800

# property with the alternate D-Bus interface

1801

# name. Add it to the class.

1802

attr[attrname] = (dbus_service_property(

1803

alt_interface, attribute._dbus_signature,

1804

attribute._dbus_access,

1805

attribute._dbus_get_args_options

1806

["byte_arrays"])

1807

(copy_function(attribute)))

1808

# Copy annotations, if any

1809

try:

1810

attr[attrname]._dbus_annotations = dict(

1811

attribute._dbus_annotations)

1812

except AttributeError:

1813

pass

1814

# Is this a D-Bus interface?

1815

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

1816

# Create a new, but exactly alike, function

1817

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

1818

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

1819

# to the class.

1820

attr[attrname] = (

1821

dbus_interface_annotations(alt_interface)

1822

(copy_function(attribute)))

1823

if deprecate:

1824

# Deprecate all alternate interfaces

1825

iname = "_AlternateDBusNames_interface_annotation{}"

1826

for interface_name in interface_names:

1827

1828

@dbus_interface_annotations(interface_name)

1829

def func(self):

1830

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

1831

"true"}

1832

# Find an unused name

1833

for aname in (iname.format(i)

1834

for i in itertools.count()):

1835

if aname not in attr:

1836

attr[aname] = func

1837

break

1838

if interface_names:

1839

# Replace the class with a new subclass of it with

1840

# methods, signals, etc. as created above.

1841

if sys.version_info.major == 2:

1842

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

1843

(cls, ), attr)

1844

else:

1845

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

1846

(cls, ), attr)

1847

return cls

1848

1849

return wrapper

1850

1851

1852

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

1853

"se.bsnet.fukt.Mandos"})

1854

class ClientDBus(Client, DBusObjectWithProperties):

1855

"""A Client class using D-Bus

1856

1857

Attributes:

1858

dbus_object_path: dbus.ObjectPath

1859

bus: dbus.SystemBus()

1860

"""

1861

1862

runtime_expansions = (Client.runtime_expansions

1863

+ ("dbus_object_path", ))

1864

1865

_interface = "se.recompile.Mandos.Client"

1866

1867

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

1868

1869

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

1870

self.bus = bus

1871

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

1872

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

1873

# the D-Bus

1874

client_object_name = str(self.name).translate(

1875

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

1876

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

1877

self.dbus_object_path = dbus.ObjectPath(

1878

"/clients/" + client_object_name)

1879

DBusObjectWithProperties.__init__(self, self.bus,

1880

self.dbus_object_path)

1881

1882

def notifychangeproperty(transform_func, dbus_name,

1883

type_func=lambda x: x,

1884

variant_level=1,

1885

invalidate_only=False,

1886

_interface=_interface):

1887

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

1888

its changes to DBus.

1889

1890

transform_fun: Function that takes a value and a variant_level

1891

and transforms it to a D-Bus type.

1892

dbus_name: D-Bus name of the variable

1893

type_func: Function that transform the value before sending it

1894

to the D-Bus. Default: no transform

1895

variant_level: D-Bus variant level. Default: 1

1896

"""

1897

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

1898

1899

def setter(self, value):

1900

if hasattr(self, "dbus_object_path"):

1901

if (not hasattr(self, attrname) or

1902

type_func(getattr(self, attrname, None))

1903

!= type_func(value)):

1904

if invalidate_only:

1905

self.PropertiesChanged(

1906

_interface, dbus.Dictionary(),

1907

dbus.Array((dbus_name, )))

1908

else:

1909

dbus_value = transform_func(

1910

type_func(value),

1911

variant_level=variant_level)

1912

self.PropertyChanged(dbus.String(dbus_name),

1913

dbus_value)

1914

self.PropertiesChanged(

1915

_interface,

1916

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

1917

dbus_value}),

1918

dbus.Array())

1919

setattr(self, attrname, value)

1920

1921

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

1922

1923

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1924

approvals_pending = notifychangeproperty(dbus.Boolean,

1925

"ApprovalPending",

1926

type_func=bool)

1927

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

1928

last_enabled = notifychangeproperty(datetime_to_dbus,

1929

"LastEnabled")

1930

checker = notifychangeproperty(

1931

dbus.Boolean, "CheckerRunning",

1932

type_func=lambda checker: checker is not None)

1933

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1934

"LastCheckedOK")

1935

last_checker_status = notifychangeproperty(dbus.Int16,

1936

"LastCheckerStatus")

1937

last_approval_request = notifychangeproperty(

1938

datetime_to_dbus, "LastApprovalRequest")

1939

approved_by_default = notifychangeproperty(dbus.Boolean,

1940

"ApprovedByDefault")

1941

approval_delay = notifychangeproperty(

1942

dbus.UInt64, "ApprovalDelay",

1943

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

1944

approval_duration = notifychangeproperty(

1945

dbus.UInt64, "ApprovalDuration",

1946

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

1947

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

1948

timeout = notifychangeproperty(

1949

dbus.UInt64, "Timeout",

1950

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

1951

extended_timeout = notifychangeproperty(

1952

dbus.UInt64, "ExtendedTimeout",

1953

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

1954

interval = notifychangeproperty(

1955

dbus.UInt64, "Interval",

1956

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

1957

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

1958

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

1959

invalidate_only=True)

1960

1961

del notifychangeproperty

1962

1963

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

1964

try:

1965

self.remove_from_connection()

1966

except LookupError:

1967

pass

1968

if hasattr(DBusObjectWithProperties, "__del__"):

1969

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

1970

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

1971

1972

def checker_callback(self, source, condition,

1973

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

1974

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

1975

connection, command, *args,

1976

**kwargs)

1977

exitstatus = self.last_checker_status

1978

if exitstatus >= 0:

1979

# Emit D-Bus signal

1980

self.CheckerCompleted(dbus.Int16(exitstatus),

1981

# This is specific to GNU libC

1982

dbus.Int64(exitstatus << 8),

1983

dbus.String(command))

1984

else:

1985

# Emit D-Bus signal

1986

self.CheckerCompleted(dbus.Int16(-1),

1987

dbus.Int64(

1988

# This is specific to GNU libC

1989

(exitstatus << 8)

1990

| self.last_checker_signal),

1991

dbus.String(command))

1992

return ret

1993

1994

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

1995

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

1996

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

1997

# Only if new checker process was started

1998

if (self.checker is not None

1999

and old_checker_pid != self.checker.pid):

2000

# Emit D-Bus signal

2001

self.CheckerStarted(self.current_checker_command)

2002

return r

2003

2004

def _reset_approved(self):

2005

self.approved = None

2006

return False

2007

2008

def approve(self, value=True):

2009

self.approved = value

2010

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

2011

* 1000), self._reset_approved)

2012

self.send_changedstate()

2013

2014

# D-Bus methods, signals & properties

2015

2016

# Interfaces

2017

2018

# Signals

2019

2020

# CheckerCompleted - signal

2021

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

2022

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

2023

"D-Bus signal"

2024

pass

2025

2026

# CheckerStarted - signal

2027

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

2028

def CheckerStarted(self, command):

2029

"D-Bus signal"

2030

pass

2031

2032

# PropertyChanged - signal

2033

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

2034

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

2035

def PropertyChanged(self, property, value):

2036

"D-Bus signal"

2037

pass

2038

2039

# GotSecret - signal

2040

@dbus.service.signal(_interface)

2041

def GotSecret(self):

2042

"""D-Bus signal

2043

Is sent after a successful transfer of secret from the Mandos

2044

server to mandos-client

2045

"""

2046

pass

2047

2048

# Rejected - signal

2049

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

2050

def Rejected(self, reason):

2051

"D-Bus signal"

2052

pass

2053

2054

# NeedApproval - signal

2055

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

2056

def NeedApproval(self, timeout, default):

2057

"D-Bus signal"

2058

return self.need_approval()

2059

2060

# Methods

2061

2062

# Approve - method

2063

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

2064

def Approve(self, value):

2065

self.approve(value)

2066

2067

# CheckedOK - method

2068

@dbus.service.method(_interface)

2069

def CheckedOK(self):

2070

self.checked_ok()

2071

2072

# Enable - method

2073

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

2074

@dbus.service.method(_interface)

2075

def Enable(self):

2076

"D-Bus method"

2077

self.enable()

2078

2079

# StartChecker - method

2080

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

2081

@dbus.service.method(_interface)

2082

def StartChecker(self):

2083

"D-Bus method"

2084

self.start_checker()

2085

2086

# Disable - method

2087

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

2088

@dbus.service.method(_interface)

2089

def Disable(self):

2090

"D-Bus method"

2091

self.disable()

2092

2093

# StopChecker - method

2094

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

2095

@dbus.service.method(_interface)

2096

def StopChecker(self):

2097

self.stop_checker()

2098

2099

# Properties

2100

2101

# ApprovalPending - property

2102

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

2103

def ApprovalPending_dbus_property(self):

2104

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

2105

2106

# ApprovedByDefault - property

2107

@dbus_service_property(_interface,

2108

signature="b",

2109

access="readwrite")

2110

def ApprovedByDefault_dbus_property(self, value=None):

2111

if value is None: # get

2112

return dbus.Boolean(self.approved_by_default)

2113

self.approved_by_default = bool(value)

2114

2115

# ApprovalDelay - property

2116

@dbus_service_property(_interface,

2117

signature="t",

2118

access="readwrite")

2119

def ApprovalDelay_dbus_property(self, value=None):

2120

if value is None: # get

2121

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

2122

* 1000)

2123

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

2124

2125

# ApprovalDuration - property

2126

@dbus_service_property(_interface,

2127

signature="t",

2128

access="readwrite")

2129

def ApprovalDuration_dbus_property(self, value=None):

2130

if value is None: # get

2131

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

2132

* 1000)

2133

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

2134

2135

# Name - property

2136

@dbus_annotations(

2137

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

2138

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

2139

def Name_dbus_property(self):

2140

return dbus.String(self.name)

2141

2142

# KeyID - property

2143

@dbus_annotations(

2144

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

2145

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

2146

def KeyID_dbus_property(self):

2147

return dbus.String(self.key_id)

2148

2149

# Fingerprint - property

2150

@dbus_annotations(

2151

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

2152

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

2153

def Fingerprint_dbus_property(self):

2154

return dbus.String(self.fingerprint)

2155

2156

# Host - property

2157

@dbus_service_property(_interface,

2158

signature="s",

2159

access="readwrite")

2160

def Host_dbus_property(self, value=None):

2161

if value is None: # get

2162

return dbus.String(self.host)

2163

self.host = str(value)

2164

2165

# Created - property

2166

@dbus_annotations(

2167

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

2168

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

2169

def Created_dbus_property(self):

2170

return datetime_to_dbus(self.created)

2171

2172

# LastEnabled - property

2173

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

2174

def LastEnabled_dbus_property(self):

2175

return datetime_to_dbus(self.last_enabled)

2176

2177

# Enabled - property

2178

@dbus_service_property(_interface,

2179

signature="b",

2180

access="readwrite")

2181

def Enabled_dbus_property(self, value=None):

2182

if value is None: # get

2183

return dbus.Boolean(self.enabled)

2184

if value:

2185

self.enable()

2186

else:

2187

self.disable()

2188

2189

# LastCheckedOK - property

2190

@dbus_service_property(_interface,

2191

signature="s",

2192

access="readwrite")

2193

def LastCheckedOK_dbus_property(self, value=None):

2194

if value is not None:

2195

self.checked_ok()

2196

return

2197

return datetime_to_dbus(self.last_checked_ok)

2198

2199

# LastCheckerStatus - property

2200

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

2201

def LastCheckerStatus_dbus_property(self):

2202

return dbus.Int16(self.last_checker_status)

2203

2204

# Expires - property

2205

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

2206

def Expires_dbus_property(self):

2207

return datetime_to_dbus(self.expires)

2208

2209

# LastApprovalRequest - property

2210

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

2211

def LastApprovalRequest_dbus_property(self):

2212

return datetime_to_dbus(self.last_approval_request)

2213

2214

# Timeout - property

2215

@dbus_service_property(_interface,

2216

signature="t",

2217

access="readwrite")

2218

def Timeout_dbus_property(self, value=None):

2219

if value is None: # get

2220

return dbus.UInt64(self.timeout.total_seconds() * 1000)

2221

old_timeout = self.timeout

2222

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

2223

# Reschedule disabling

2224

if self.enabled:

2225

now = datetime.datetime.utcnow()

2226

self.expires += self.timeout - old_timeout

2227

if self.expires <= now:

2228

# The timeout has passed

2229

self.disable()

2230

else:

2231

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

2232

is None):

2233

return

2234

GLib.source_remove(self.disable_initiator_tag)

2235

self.disable_initiator_tag = GLib.timeout_add(

2236

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

2237

self.disable)

2238

2239

# ExtendedTimeout - property

2240

@dbus_service_property(_interface,

2241

signature="t",

2242

access="readwrite")

2243

def ExtendedTimeout_dbus_property(self, value=None):

2244

if value is None: # get

2245

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

2246

* 1000)

2247

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

2248

2249

# Interval - property

2250

@dbus_service_property(_interface,

2251

signature="t",

2252

access="readwrite")

2253

def Interval_dbus_property(self, value=None):

2254

if value is None: # get

2255

return dbus.UInt64(self.interval.total_seconds() * 1000)

2256

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

2257

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

2258

return

2259

if self.enabled:

2260

# Reschedule checker run

2261

GLib.source_remove(self.checker_initiator_tag)

2262

self.checker_initiator_tag = GLib.timeout_add(

2263

value, self.start_checker)

2264

self.start_checker() # Start one now, too

2265

2266

# Checker - property

2267

@dbus_service_property(_interface,

2268

signature="s",

2269

access="readwrite")

2270

def Checker_dbus_property(self, value=None):

2271

if value is None: # get

2272

return dbus.String(self.checker_command)

2273

self.checker_command = str(value)

2274

2275

# CheckerRunning - property

2276

@dbus_service_property(_interface,

2277

signature="b",

2278

access="readwrite")

2279

def CheckerRunning_dbus_property(self, value=None):

2280

if value is None: # get

2281

return dbus.Boolean(self.checker is not None)

2282

if value:

2283

self.start_checker()

2284

else:

2285

self.stop_checker()

2286

2287

# ObjectPath - property

2288

@dbus_annotations(

2289

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

2290

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

2291

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

2292

def ObjectPath_dbus_property(self):

2293

return self.dbus_object_path # is already a dbus.ObjectPath

2294

2295

# Secret = property

2296

@dbus_annotations(

2297

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

2298

"invalidates"})

2299

@dbus_service_property(_interface,

2300

signature="ay",

2301

access="write",

2302

byte_arrays=True)

2303

def Secret_dbus_property(self, value):

2304

self.secret = bytes(value)

2305

2306

del _interface

2307

2308

2309

class ProxyClient:

2310

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

2311

self._pipe = child_pipe

2312

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

2313

if not self._pipe.recv():

2314

raise KeyError(key_id or fpr)

2315

2316

def __getattribute__(self, name):

2317

if name == "_pipe":

2318

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

2319

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

2320

data = self._pipe.recv()

2321

if data[0] == "data":

2322

return data[1]

2323

if data[0] == "function":

2324

2325

def func(*args, **kwargs):

2326

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

2327

return self._pipe.recv()[1]

2328

2329

return func

2330

2331

def __setattr__(self, name, value):

2332

if name == "_pipe":

2333

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

2334

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

2335

2336

2337

class ClientHandler(socketserver.BaseRequestHandler, object):

2338

"""A class to handle client connections.

2339

2340

Instantiated once for each connection to handle it.

2341

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

2342

2343

def handle(self):

2344

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

2345

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

2346

str(self.client_address))

2347

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

2348

2349

session = gnutls.ClientSession(self.request)

2350

2351

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

2352

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

2353

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

2354

# "+DHE-DSS"))

2355

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

2356

priority = self.server.gnutls_priority

2357

if priority is None:

2358

priority = "NORMAL"

2359

gnutls.priority_set_direct(session,

2360

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

2361

2362

# Start communication using the Mandos protocol

2363

# Get protocol number

2364

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

2365

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

2366

try:

2367

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

2368

raise RuntimeError(line)

2369

except (ValueError, IndexError, RuntimeError) as error:

2370

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

2371

return

2372

2373

# Start GnuTLS connection

2374

try:

2375

session.handshake()

2376

except gnutls.Error as error:

2377

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

2378

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

2379

# established. Just abandon the request.

2380

return

2381

log.debug("Handshake succeeded")

2382

2383

approval_required = False

2384

try:

2385

if gnutls.has_rawpk:

2386

fpr = b""

2387

try:

2388

key_id = self.key_id(

2389

self.peer_certificate(session))

2390

except (TypeError, gnutls.Error) as error:

2391

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

2392

return

2393

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

2394

key_id.decode("utf-8",

2395

errors="replace"))

2396

2397

else:

2398

key_id = b""

2399

try:

2400

fpr = self.fingerprint(

2401

self.peer_certificate(session))

2402

except (TypeError, gnutls.Error) as error:

2403

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

2404

return

2405

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

2406

2407

try:

2408

client = ProxyClient(child_pipe, key_id, fpr,

2409

self.client_address)

2410

except KeyError:

2411

return

2412

2413

if client.approval_delay:

2414

delay = client.approval_delay

2415

client.approvals_pending += 1

2416

approval_required = True

2417

2418

while True:

2419

if not client.enabled:

2420

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

2421

if self.server.use_dbus:

2422

# Emit D-Bus signal

2423

client.Rejected("Disabled")

2424

return

2425

2426

if client.approved or not client.approval_delay:

2427

# We are approved or approval is disabled

2428

break

2429

elif client.approved is None:

2430

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

2431

client.name)

2432

if self.server.use_dbus:

2433

# Emit D-Bus signal

2434

client.NeedApproval(

2435

client.approval_delay.total_seconds()

2436

* 1000, client.approved_by_default)

2437

else:

2438

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

2439

client.name)

2440

if self.server.use_dbus:

2441

# Emit D-Bus signal

2442

client.Rejected("Denied")

2443

return

2444

2445

# wait until timeout or approved

2446

time = datetime.datetime.now()

2447

client.changedstate.acquire()

2448

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

2449

client.changedstate.release()

2450

time2 = datetime.datetime.now()

2451

if (time2 - time) >= delay:

2452

if not client.approved_by_default:

2453

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

2454

" waiting for approval",

2455

client.name)

2456

if self.server.use_dbus:

2457

# Emit D-Bus signal

2458

client.Rejected("Approval timed out")

2459

return

2460

else:

2461

break

2462

else:

2463

delay -= time2 - time

2464

2465

try:

2466

session.send(client.secret)

2467

except gnutls.Error as error:

2468

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

2469

return

2470

2471

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

2472

# bump the timeout using extended_timeout

2473

client.bump_timeout(client.extended_timeout)

2474

if self.server.use_dbus:

2475

# Emit D-Bus signal

2476

client.GotSecret()

2477

2478

finally:

2479

if approval_required:

2480

client.approvals_pending -= 1

2481

try:

2482

session.bye()

2483

except gnutls.Error as error:

2484

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

2485

2486

@staticmethod

2487

def peer_certificate(session):

2488

"Return the peer's certificate as a bytestring"

2489

try:

2490

cert_type = gnutls.certificate_type_get2(

2491

session, gnutls.CTYPE_PEERS)

2492

except AttributeError:

2493

cert_type = gnutls.certificate_type_get(session)

2494

if gnutls.has_rawpk:

2495

valid_cert_types = frozenset((gnutls.CRT_RAWPK,))

2496

else:

2497

valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))

2498

# If not a valid certificate type...

2499

if cert_type not in valid_cert_types:

2500

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

2501

valid_cert_types)

2502

# ...return invalid data

2503

return b""

2504

list_size = ctypes.c_uint(1)

2505

cert_list = (gnutls.certificate_get_peers

2506

(session, ctypes.byref(list_size)))

2507

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

2508

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

2509

if list_size.value == 0:

74

__del__ = stop_checker

75

def fileno(self):

76

if self.checker is None:

2510

77

return None

2511

cert = cert_list[0]

2512

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

2513

2514

@staticmethod

2515

def key_id(certificate):

2516

"Convert a certificate bytestring to a hexdigit key ID"

2517

# New GnuTLS "datum" with the public key

2518

datum = gnutls.datum_t(

2519

ctypes.cast(ctypes.c_char_p(certificate),

2520

ctypes.POINTER(ctypes.c_ubyte)),

2521

ctypes.c_uint(len(certificate)))

2522

# XXX all these need to be created in the gnutls "module"

2523

# New empty GnuTLS certificate

2524

pubkey = gnutls.pubkey_t()

2525

gnutls.pubkey_init(ctypes.byref(pubkey))

2526

# Import the raw public key into the certificate

2527

gnutls.pubkey_import(pubkey,

2528

ctypes.byref(datum),

2529

gnutls.X509_FMT_DER)

2530

# New buffer for the key ID

2531

buf = ctypes.create_string_buffer(32)

2532

buf_len = ctypes.c_size_t(len(buf))

2533

# Get the key ID from the raw public key into the buffer

2534

gnutls.pubkey_get_key_id(

2535

pubkey,

2536

gnutls.KEYID_USE_SHA256,

2537

ctypes.cast(ctypes.byref(buf),

2538

ctypes.POINTER(ctypes.c_ubyte)),

2539

ctypes.byref(buf_len))

2540

# Deinit the certificate

2541

gnutls.pubkey_deinit(pubkey)

2542

2543

# Convert the buffer to a Python bytestring

2544

key_id = ctypes.string_at(buf, buf_len.value)

2545

# Convert the bytestring to hexadecimal notation

2546

hex_key_id = binascii.hexlify(key_id).upper()

2547

return hex_key_id

2548

2549

@staticmethod

2550

def fingerprint(openpgp):

2551

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2552

# New GnuTLS "datum" with the OpenPGP public key

2553

datum = gnutls.datum_t(

2554

ctypes.cast(ctypes.c_char_p(openpgp),

2555

ctypes.POINTER(ctypes.c_ubyte)),

2556

ctypes.c_uint(len(openpgp)))

2557

# New empty GnuTLS certificate

2558

crt = gnutls.openpgp_crt_t()

2559

gnutls.openpgp_crt_init(ctypes.byref(crt))

2560

# Import the OpenPGP public key into the certificate

2561

gnutls.openpgp_crt_import(crt, ctypes.byref(datum),

2562

gnutls.OPENPGP_FMT_RAW)

2563

# Verify the self signature in the key

2564

crtverify = ctypes.c_uint()

2565

gnutls.openpgp_crt_verify_self(crt, 0,

2566

ctypes.byref(crtverify))

2567

if crtverify.value != 0:

2568

gnutls.openpgp_crt_deinit(crt)

2569

raise gnutls.CertificateSecurityError(code

2570

=crtverify.value)

2571

# New buffer for the fingerprint

2572

buf = ctypes.create_string_buffer(20)

2573

buf_len = ctypes.c_size_t()

2574

# Get the fingerprint from the certificate into the buffer

2575

gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),

2576

ctypes.byref(buf_len))

2577

# Deinit the certificate

2578

gnutls.openpgp_crt_deinit(crt)

2579

# Convert the buffer to a Python bytestring

2580

fpr = ctypes.string_at(buf, buf_len.value)

2581

# Convert the bytestring to hexadecimal notation

2582

hex_fpr = binascii.hexlify(fpr).upper()

2583

return hex_fpr

2584

2585

2586

class MultiprocessingMixIn:

2587

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

2588

2589

def sub_process_main(self, request, address):

2590

try:

2591

self.finish_request(request, address)

2592

except Exception:

2593

self.handle_error(request, address)

2594

self.close_request(request)

2595

2596

def process_request(self, request, address):

2597

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

2598

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

2599

args=(request, address))

2600

proc.start()

2601

return proc

2602

2603

2604

class MultiprocessingMixInWithPipe(MultiprocessingMixIn):

2605

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

2606

2607

def process_request(self, request, client_address):

2608

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

2609

2610

This function creates a new pipe in self.pipe

2611

"""

2612

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2613

2614

proc = MultiprocessingMixIn.process_request(self, request,

2615

client_address)

2616

self.child_pipe.close()

2617

self.add_pipe(parent_pipe, proc)

2618

2619

def add_pipe(self, parent_pipe, proc):

2620

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

2621

raise NotImplementedError()

2622

2623

2624

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2625

socketserver.TCPServer):

2626

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

2627

2628

Attributes:

2629

enabled: Boolean; whether this server is activated yet

2630

interface: None or a network interface name (string)

2631

use_ipv6: Boolean; to use IPv6 or not

2632

"""

2633

2634

def __init__(self, server_address, RequestHandlerClass,

2635

interface=None,

2636

use_ipv6=True,

2637

socketfd=None):

2638

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

2639

creating a new one with socket.socket().

2640

"""

2641

self.interface = interface

2642

if use_ipv6:

2643

self.address_family = socket.AF_INET6

2644

if socketfd is not None:

2645

# Save the file descriptor

2646

self.socketfd = socketfd

2647

# Save the original socket.socket() function

2648

self.socket_socket = socket.socket

2649

2650

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

2651

#

2652

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

2653

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

2654

# patching socket.socket.)

2655

#

2656

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

2657

@functools.wraps(socket.socket)

2658

def socket_wrapper(*args, **kwargs):

2659

# Restore original function so subsequent calls are

2660

# not affected.

2661

socket.socket = self.socket_socket

2662

del self.socket_socket

2663

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

2664

# saved file descriptor.

2665

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

2666

# Replace socket.socket() function with wrapper

2667

socket.socket = socket_wrapper

2668

# The socketserver.TCPServer.__init__ will call

2669

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

2670

# socket_wrapper(), if socketfd was set.

2671

socketserver.TCPServer.__init__(self, server_address,

2672

RequestHandlerClass)

2673

2674

def server_bind(self):

2675

"""This overrides the normal server_bind() function

2676

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

2677

bind to an address or port if they were not specified."""

2678

global SO_BINDTODEVICE

2679

if self.interface is not None:

2680

if SO_BINDTODEVICE is None:

2681

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

2682

# common enough.

2683

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

2684

SO_BINDTODEVICE = 25

2685

try:

2686

self.socket.setsockopt(

2687

socket.SOL_SOCKET, SO_BINDTODEVICE,

2688

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

2689

except socket.error as error:

2690

if error.errno == errno.EPERM:

2691

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

2692

self.interface)

2693

elif error.errno == errno.ENOPROTOOPT:

2694

log.error("SO_BINDTODEVICE not available; cannot"

2695

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

2696

elif error.errno == errno.ENODEV:

2697

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

2698

" bind", self.interface)

2699

else:

2700

raise

2701

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

2702

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

2703

if self.server_address[1]:

2704

self.allow_reuse_address = True

2705

if not self.server_address[0]:

2706

if self.address_family == socket.AF_INET6:

2707

any_address = "::" # in6addr_any

2708

else:

2709

any_address = "0.0.0.0" # INADDR_ANY

2710

self.server_address = (any_address,

2711

self.server_address[1])

2712

elif not self.server_address[1]:

2713

self.server_address = (self.server_address[0], 0)

2714

# if self.interface:

2715

# self.server_address = (self.server_address[0],

2716

# 0, # port

2717

# 0, # flowinfo

2718

# if_nametoindex

2719

# (self.interface))

2720

return socketserver.TCPServer.server_bind(self)

2721

2722

2723

class MandosServer(IPv6_TCPServer):

2724

"""Mandos server.

2725

2726

Attributes:

2727

clients: set of Client objects

2728

gnutls_priority GnuTLS priority string

2729

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

2730

2731

Assumes a GLib.MainLoop event loop.

2732

"""

2733

2734

def __init__(self, server_address, RequestHandlerClass,

2735

interface=None,

2736

use_ipv6=True,

2737

clients=None,

2738

gnutls_priority=None,

2739

use_dbus=True,

2740

socketfd=None):

2741

self.enabled = False

2742

self.clients = clients

2743

if self.clients is None:

2744

self.clients = {}

2745

self.use_dbus = use_dbus

2746

self.gnutls_priority = gnutls_priority

2747

IPv6_TCPServer.__init__(self, server_address,

2748

RequestHandlerClass,

2749

interface=interface,

2750

use_ipv6=use_ipv6,

2751

socketfd=socketfd)

2752

2753

def server_activate(self):

2754

if self.enabled:

2755

return socketserver.TCPServer.server_activate(self)

2756

2757

def enable(self):

2758

self.enabled = True

2759

2760

def add_pipe(self, parent_pipe, proc):

2761

# Call "handle_ipc" for both data and EOF events

2762

GLib.io_add_watch(

2763

GLib.IOChannel.unix_new(parent_pipe.fileno()),

2764

GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,

2765

functools.partial(self.handle_ipc,

2766

parent_pipe=parent_pipe,

2767

proc=proc))

2768

2769

def handle_ipc(self, source, condition,

2770

parent_pipe=None,

2771

proc=None,

2772

client_object=None):

2773

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

2774

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

2775

# Wait for other process to exit

2776

proc.join()

2777

return False

2778

2779

# Read a request from the child

2780

request = parent_pipe.recv()

2781

command = request[0]

2782

2783

if command == "init":

2784

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

2785

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

2786

address = request[3]

2787

2788

for c in self.clients.values():

2789

if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"

2790

"27AE41E4649B934CA495991B7852B855"):

2791

continue

2792

if key_id and c.key_id == key_id:

2793

client = c

2794

break

2795

if fpr and c.fingerprint == fpr:

2796

client = c

2797

break

2798

else:

2799

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

2800

" %s", key_id or fpr, address)

2801

if self.use_dbus:

2802

# Emit D-Bus signal

2803

mandos_dbus_service.ClientNotFound(key_id or fpr,

2804

address[0])

2805

parent_pipe.send(False)

2806

return False

2807

2808

GLib.io_add_watch(

2809

GLib.IOChannel.unix_new(parent_pipe.fileno()),

2810

GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,

2811

functools.partial(self.handle_ipc,

2812

parent_pipe=parent_pipe,

2813

proc=proc,

2814

client_object=client))

2815

parent_pipe.send(True)

2816

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

2817

# same fileno

2818

return False

2819

if command == "funcall":

2820

funcname = request[1]

2821

args = request[2]

2822

kwargs = request[3]

2823

2824

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

2825

funcname)(*args,

2826

**kwargs)))

2827

2828

if command == "getattr":

2829

attrname = request[1]

2830

if isinstance(client_object.__getattribute__(attrname),

2831

collections.abc.Callable):

2832

parent_pipe.send(("function", ))

2833

else:

2834

parent_pipe.send((

2835

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

2836

2837

if command == "setattr":

2838

attrname = request[1]

2839

value = request[2]

2840

setattr(client_object, attrname, value)

2841

2842

return True

2843

2844

2845

def rfc3339_duration_to_delta(duration):

2846

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

2847

2848

>>> timedelta = datetime.timedelta

2849

>>> rfc3339_duration_to_delta("P7D") == timedelta(7)

2850

True

2851

>>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)

2852

True

2853

>>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)

2854

True

2855

>>> rfc3339_duration_to_delta("PT24H") == timedelta(1)

2856

True

2857

>>> rfc3339_duration_to_delta("P1W") == timedelta(7)

2858

True

2859

>>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)

2860

True

2861

>>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)

2862

True

2863

>>> del timedelta

2864

"""

2865

2866

# Parsing an RFC 3339 duration with regular expressions is not

2867

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

2868

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

2869

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

2870

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

2871

# avoid excessive use of external libraries.

2872

2873

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

2874

Token = collections.namedtuple("Token", (

2875

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

2876

# a "group" containing digits

2877

"value", # datetime.timedelta or None

2878

"followers")) # Tokens valid after this token

2879

# RFC 3339 "duration" tokens, syntax, and semantics; taken from

2880

# the "duration" ABNF definition in RFC 3339, Appendix A.

2881

token_end = Token(re.compile(r"$"), None, frozenset())

2882

token_second = Token(re.compile(r"(\d+)S"),

2883

datetime.timedelta(seconds=1),

2884

frozenset((token_end, )))

2885

token_minute = Token(re.compile(r"(\d+)M"),

2886

datetime.timedelta(minutes=1),

2887

frozenset((token_second, token_end)))

2888

token_hour = Token(re.compile(r"(\d+)H"),

2889

datetime.timedelta(hours=1),

2890

frozenset((token_minute, token_end)))

2891

token_time = Token(re.compile(r"T"),

2892

None,

2893

frozenset((token_hour, token_minute,

2894

token_second)))

2895

token_day = Token(re.compile(r"(\d+)D"),

2896

datetime.timedelta(days=1),

2897

frozenset((token_time, token_end)))

2898

token_month = Token(re.compile(r"(\d+)M"),

2899

datetime.timedelta(weeks=4),

2900

frozenset((token_day, token_end)))

2901

token_year = Token(re.compile(r"(\d+)Y"),

2902

datetime.timedelta(weeks=52),

2903

frozenset((token_month, token_end)))

2904

token_week = Token(re.compile(r"(\d+)W"),

2905

datetime.timedelta(weeks=1),

2906

frozenset((token_end, )))

2907

token_duration = Token(re.compile(r"P"), None,

2908

frozenset((token_year, token_month,

2909

token_day, token_time,

2910

token_week)))

2911

# Define starting values:

2912

# Value so far

2913

value = datetime.timedelta()

2914

found_token = None

2915

# Following valid tokens

2916

followers = frozenset((token_duration, ))

2917

# String left to parse

2918

s = duration

2919

# Loop until end token is found

2920

while found_token is not token_end:

2921

# Search for any currently valid tokens

2922

for token in followers:

2923

match = token.regexp.match(s)

2924

if match is not None:

2925

# Token found

2926

if token.value is not None:

2927

# Value found, parse digits

2928

factor = int(match.group(1), 10)

2929

# Add to value so far

2930

value += factor * token.value

2931

# Strip token from string

2932

s = token.regexp.sub("", s, 1)

2933

# Go to found token

2934

found_token = token

2935

# Set valid next tokens

2936

followers = found_token.followers

2937

break

2938

else:

2939

# No currently valid tokens were found

2940

raise ValueError("Invalid RFC 3339 duration: {!r}"

2941

.format(duration))

2942

# End token found

2943

return value

2944

78

return self.checker.stdout.fileno()

79

def next_stop(self):

80

"""The time when something must be done about this client"""

81

return min(self.last_seen + self.timeout, self.next_check)

82

def still_valid(self, now=None):

83

"""Has this client's timeout not passed?"""

84

if now is None:

85

now = datetime.datetime.now()

86

return now < (self.last_seen + timeout)

87

def it_is_time_to_check(self, now=None):

88

if now is None:

89

now = datetime.datetime.now()

90

return self.next_check <= now

91

92

93

class server_metaclass(type):

94

"Common behavior for the UDP and TCP server classes"

95

def __new__(cls, name, bases, attrs):

96

attrs["address_family"] = socket.AF_INET6

97

attrs["allow_reuse_address"] = True

98

def server_bind(self):

99

if self.options.interface:

100

if not hasattr(socket, "SO_BINDTODEVICE"):

101

# From /usr/include/asm-i486/socket.h

102

socket.SO_BINDTODEVICE = 25

103

try:

104

self.socket.setsockopt(socket.SOL_SOCKET,

105

socket.SO_BINDTODEVICE,

106

self.options.interface)

107

except socket.error, error:

108

if error[0] == errno.EPERM:

109

print "Warning: No permission to bind to interface", \

110

self.options.interface

111

else:

112

raise error

113

return super(type(self), self).server_bind()

114

attrs["server_bind"] = server_bind

115

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

116

if "options" in kwargs:

117

self.options = kwargs["options"]

118

del kwargs["options"]

119

if "clients" in kwargs:

120

self.clients = kwargs["clients"]

121

del kwargs["clients"]

122

if "credentials" in kwargs:

123

self.credentials = kwargs["credentials"]

124

del kwargs["credentials"]

125

return super(type(self), self).__init__(*args, **kwargs)

126

attrs["__init__"] = init

127

return type.__new__(cls, name, bases, attrs)

128

129

130

class udp_handler(SocketServer.DatagramRequestHandler, object):

131

def handle(self):

132

self.wfile.write("Polo")

133

print "UDP request answered"

134

135

136

class IPv6_UDPServer(SocketServer.UDPServer, object):

137

__metaclass__ = server_metaclass

138

def verify_request(self, request, client_address):

139

print "UDP request came"

140

return request[0] == "Marco"

141

142

143

class tcp_handler(SocketServer.BaseRequestHandler, object):

144

def handle(self):

145

print "TCP request came"

146

print "Request:", self.request

147

print "Client Address:", self.client_address

148

print "Server:", self.server

149

session = gnutls.connection.ServerSession(self.request,

150

self.server.credentials)

151

session.handshake()

152

if session.peer_certificate:

153

print "DN:", session.peer_certificate.subject

154

try:

155

session.verify_peer()

156

except gnutls.errors.CertificateError, error:

157

print "Verify failed", error

158

session.bye()

159

return

160

try:

161

session.send(dict((client.dn, client.password)

162

for client in self.server.clients)

163

[session.peer_certificate.subject])

164

except KeyError:

165

session.send("gazonk")

166

# Log maybe? XXX

167

session.bye()

168

169

170

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

171

__metaclass__ = server_metaclass

172

request_queue_size = 1024

173

174

175

in6addr_any = "::"

2945

176

2946

177

def string_to_delta(interval):

2947

178

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

2948

179

2949

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

2950

True

2951

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

2952

True

2953

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

2954

True

2955

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

2956

True

2957

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

2958

True

2959

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

2960

True

180

>>> string_to_delta('7d')

181

datetime.timedelta(7)

182

>>> string_to_delta('60s')

183

datetime.timedelta(0, 60)

184

>>> string_to_delta('60m')

185

datetime.timedelta(0, 3600)

186

>>> string_to_delta('24h')

187

datetime.timedelta(1)

188

>>> string_to_delta(u'1w')

189

datetime.timedelta(7)

2961

190

"""

2962

2963

191

try:

2964

return rfc3339_duration_to_delta(interval)

2965

except ValueError:

2966

pass

2967

2968

timevalue = datetime.timedelta(0)

2969

for s in interval.split():

2970

try:

2971

suffix = s[-1]

2972

value = int(s[:-1])

2973

if suffix == "d":

2974

delta = datetime.timedelta(value)

2975

elif suffix == "s":

2976

delta = datetime.timedelta(0, value)

2977

elif suffix == "m":

2978

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

2979

elif suffix == "h":

2980

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

2981

elif suffix == "w":

2982

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

2983

else:

2984

raise ValueError("Unknown suffix {!r}".format(suffix))

2985

except IndexError as e:

2986

raise ValueError(*(e.args))

2987

timevalue += delta

2988

return timevalue

2989

2990

2991

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

2992

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

2993

2994

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

2995

if os.fork():

2996

sys.exit()

2997

os.setsid()

2998

if not nochdir:

2999

os.chdir("/")

3000

if os.fork():

3001

sys.exit()

3002

if not noclose:

3003

# Close all standard open file descriptors

3004

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

3005

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

3006

raise OSError(errno.ENODEV,

3007

"{} not a character device"

3008

.format(os.devnull))

3009

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

3010

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

3011

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

3012

if null > 2:

3013

os.close(null)

192

suffix=unicode(interval[-1])

193

value=int(interval[:-1])

194

if suffix == u"d":

195

delta = datetime.timedelta(value)

196

elif suffix == u"s":

197

delta = datetime.timedelta(0, value)

198

elif suffix == u"m":

199

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

200

elif suffix == u"h":

201

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

202

elif suffix == u"w":

203

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

204

else:

205

raise ValueError

206

except (ValueError, IndexError):

207

raise ValueError

208

return delta

3014

209

3015

210

3016

211

def main():

3017

3018

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

3019

# Parsing of options, both command line and config file

3020

3021

parser = argparse.ArgumentParser()

3022

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

3023

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

3024

help="show version number and exit")

3025

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

3026

help="Bind to interface IF")

3027

parser.add_argument("-a", "--address",

3028

help="Address to listen for requests on")

3029

parser.add_argument("-p", "--port", type=int,

3030

help="Port number to receive requests on")

3031

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

3032

help="Run self-test")

3033

parser.add_argument("--debug", action="store_true",

3034

help="Debug mode; run in foreground and log"

3035

" to terminal", default=None)

3036

parser.add_argument("--debuglevel", metavar="LEVEL",

3037

help="Debug level for stdout output")

3038

parser.add_argument("--priority", help="GnuTLS"

3039

" priority string (see GnuTLS documentation)")

3040

parser.add_argument("--servicename",

3041

metavar="NAME", help="Zeroconf service name")

3042

parser.add_argument("--configdir",

3043

default="/etc/mandos", metavar="DIR",

3044

help="Directory to search for configuration"

3045

" files")

3046

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

3047

dest="use_dbus", help="Do not provide D-Bus"

3048

" system bus interface", default=None)

3049

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

3050

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

3051

default=None)

3052

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

3053

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

3054

" state", default=None)

3055

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

3056

help="Specify a file descriptor to a network"

3057

" socket to use instead of creating one")

3058

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

3059

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

3060

parser.add_argument("--foreground", action="store_true",

3061

help="Run in foreground", default=None)

3062

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

3063

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

3064

default=None)

3065

3066

options = parser.parse_args()

3067

3068

# Default values for config file for server-global settings

3069

if gnutls.has_rawpk:

3070

priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"

3071

":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")

3072

else:

3073

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

3074

":+SIGN-DSA-SHA256")

3075

server_defaults = {"interface": "",

3076

"address": "",

3077

"port": "",

3078

"debug": "False",

3079

"priority": priority,

3080

"servicename": "Mandos",

3081

"use_dbus": "True",

3082

"use_ipv6": "True",

3083

"debuglevel": "",

3084

"restore": "True",

3085

"socket": "",

3086

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

3087

"foreground": "False",

3088

"zeroconf": "True",

3089

}

3090

del priority

3091

3092

# Parse config file for server-global settings

3093

server_config = configparser.ConfigParser(server_defaults)

3094

del server_defaults

3095

server_config.read(os.path.join(options.configdir, "mandos.conf"))

3096

# Convert the ConfigParser object to a dict

3097

server_settings = server_config.defaults()

3098

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

3099

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

3100

"foreground", "zeroconf"):

3101

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

3102

option)

3103

if server_settings["port"]:

3104

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

3105

"port")

3106

if server_settings["socket"]:

3107

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

3108

"socket")

3109

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

3110

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

3111

# happen with a supplied network socket.

3112

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

3113

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

3114

["socket"])

3115

os.set_inheritable(server_settings["socket"], False)

3116

del server_config

3117

3118

# Override the settings from the config file with command line

3119

# options, if set.

3120

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

3121

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

3122

"use_ipv6", "debuglevel", "restore", "statedir",

3123

"socket", "foreground", "zeroconf"):

3124

value = getattr(options, option)

3125

if value is not None:

3126

server_settings[option] = value

3127

del options

3128

# Force all strings to be unicode

3129

for option in server_settings.keys():

3130

if isinstance(server_settings[option], bytes):

3131

server_settings[option] = (server_settings[option]

3132

.decode("utf-8"))

3133

# Force all boolean options to be boolean

3134

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

3135

"foreground", "zeroconf"):

3136

server_settings[option] = bool(server_settings[option])

3137

# Debug implies foreground

3138

if server_settings["debug"]:

3139

server_settings["foreground"] = True

3140

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

3141

3142

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

3143

3144

if (not server_settings["zeroconf"]

3145

and not (server_settings["port"]

3146

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

3147

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

3148

3149

# For convenience

3150

debug = server_settings["debug"]

3151

debuglevel = server_settings["debuglevel"]

3152

use_dbus = server_settings["use_dbus"]

3153

use_ipv6 = server_settings["use_ipv6"]

3154

stored_state_path = os.path.join(server_settings["statedir"],

3155

stored_state_file)

3156

foreground = server_settings["foreground"]

3157

zeroconf = server_settings["zeroconf"]

3158

3159

if debug:

3160

initlogger(debug, logging.DEBUG)

3161

else:

3162

if not debuglevel:

3163

initlogger(debug)

3164

else:

3165

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

3166

initlogger(debug, level)

3167

3168

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

3169

syslogger.setFormatter(

3170

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

3171

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

3172

server_settings["servicename"])))

3173

3174

# Parse config file with clients

3175

client_config = configparser.ConfigParser(Client.client_defaults)

3176

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

3177

"clients.conf"))

3178

3179

global mandos_dbus_service

3180

mandos_dbus_service = None

3181

3182

socketfd = None

3183

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

3184

socketfd = server_settings["socket"]

3185

tcp_server = MandosServer(

3186

(server_settings["address"], server_settings["port"]),

3187

ClientHandler,

3188

interface=(server_settings["interface"] or None),

3189

use_ipv6=use_ipv6,

3190

gnutls_priority=server_settings["priority"],

3191

use_dbus=use_dbus,

3192

socketfd=socketfd)

3193

if not foreground:

3194

pidfilename = "/run/mandos.pid"

3195

if not os.path.isdir("/run/."):

3196

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

3197

pidfile = None

3198

try:

3199

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

3200

except IOError as e:

3201

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

3202

exc_info=e)

3203

3204

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

3205

("mandos", "mandos"),

3206

("nobody", "nogroup")):

3207

try:

3208

uid = pwd.getpwnam(name).pw_uid

3209

gid = pwd.getpwnam(group).pw_gid

212

parser = OptionParser()

213

parser.add_option("-i", "--interface", type="string",

214

default="eth0", metavar="IF",

215

help="Interface to bind to")

216

parser.add_option("--cert", type="string", default="cert.pem",

217

metavar="FILE",

218

help="Public key certificate to use")

219

parser.add_option("--key", type="string", default="key.pem",

220

metavar="FILE",

221

help="Private key to use")

222

parser.add_option("--ca", type="string", default="ca.pem",

223

metavar="FILE",

224

help="Certificate Authority certificate to use")

225

parser.add_option("--crl", type="string", default="crl.pem",

226

metavar="FILE",

227

help="Certificate Revokation List to use")

228

parser.add_option("-p", "--port", type="int", default=49001,

229

help="Port number to receive requests on")

230

parser.add_option("--dh", type="int", metavar="BITS",

231

help="DH group to use")

232

parser.add_option("-t", "--timeout", type="string", # Parsed later

233

default="15m",

234

help="Amount of downtime allowed for clients")

235

parser.add_option("--interval", type="string", # Parsed later

236

default="5m",

237

help="How often to check that a client is up")

238

parser.add_option("--check", action="store_true", default=False,

239

help="Run self-test")

240

(options, args) = parser.parse_args()

241

242

if options.check:

243

import doctest

244

doctest.testmod()

245

sys.exit()

246

247

# Parse the time arguments

248

try:

249

options.timeout = string_to_delta(options.timeout)

250

except ValueError:

251

parser.error("option --timeout: Unparseable time")

252

253

try:

254

options.interval = string_to_delta(options.interval)

255

except ValueError:

256

parser.error("option --interval: Unparseable time")

257

258

cert = gnutls.crypto.X509Certificate(open(options.cert).read())

259

key = gnutls.crypto.X509PrivateKey(open(options.key).read())

260

ca = gnutls.crypto.X509Certificate(open(options.ca).read())

261

crl = gnutls.crypto.X509CRL(open(options.crl).read())

262

cred = gnutls.connection.X509Credentials(cert, key, [ca], [crl])

263

264

# Parse config file

265

defaults = {}

266

client_config_object = ConfigParser.SafeConfigParser(defaults)

267

client_config_object.read("mandos-clients.conf")

268

clients = [Client(name=section, options=options,

269

**(dict(client_config_object.items(section))))

270

for section in client_config_object.sections()]

271

272

udp_server = IPv6_UDPServer((in6addr_any, options.port),

273

udp_handler,

274

options=options)

275

276

tcp_server = IPv6_TCPServer((in6addr_any, options.port),

277

tcp_handler,

278

options=options,

279

clients=clients,

280

credentials=cred)

281

282

while True:

283

try:

284

input, out, err = select.select((udp_server,

285

tcp_server), (), ())

286

if not input:

287

pass

288

else:

289

for obj in input:

290

obj.handle_request()

291

except KeyboardInterrupt:

3210

292

break

3211

except KeyError:

3212

continue

3213

else:

3214

uid = 65534

3215

gid = 65534

3216

try:

3217

os.setgid(gid)

3218

os.setuid(uid)

3219

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

3220

except OSError as error:

3221

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

3222

os.strerror(error.errno))

3223

if error.errno != errno.EPERM:

3224

raise

3225

3226

if debug:

3227

# Enable all possible GnuTLS debugging

3228

3229

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

3230

# - GnuTLS manual

3231

gnutls.global_set_log_level(11)

3232

3233

@gnutls.log_func

3234

def debug_gnutls(level, string):

3235

log.debug("GnuTLS: %s",

3236

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

3237

3238

gnutls.global_set_log_function(debug_gnutls)

3239

3240

# Redirect stdin so all checkers get /dev/null

3241

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

3242

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

3243

if null > 2:

3244

os.close(null)

3245

3246

# Need to fork before connecting to D-Bus

3247

if not foreground:

3248

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

3249

daemon()

3250

3251

if gi.version_info < (3, 10, 2):

3252

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

3253

# need to inform GLib that threads will be used.

3254

GLib.threads_init()

3255

3256

global main_loop

3257

# From the Avahi example code

3258

DBusGMainLoop(set_as_default=True)

3259

main_loop = GLib.MainLoop()

3260

if use_dbus or zeroconf:

3261

bus = dbus.SystemBus()

3262

# End of Avahi example code

3263

if use_dbus:

3264

try:

3265

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

3266

bus,

3267

do_not_queue=True)

3268

old_bus_name = dbus.service.BusName(

3269

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

3270

do_not_queue=True)

3271

except dbus.exceptions.DBusException as e:

3272

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

3273

use_dbus = False

3274

server_settings["use_dbus"] = False

3275

tcp_server.use_dbus = False

3276

if zeroconf:

3277

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3278

service = AvahiServiceToSyslog(

3279

name=server_settings["servicename"],

3280

servicetype="_mandos._tcp",

3281

protocol=protocol,

3282

bus=bus)

3283

if server_settings["interface"]:

3284

service.interface = if_nametoindex(

3285

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

3286

3287

global multiprocessing_manager

3288

multiprocessing_manager = multiprocessing.Manager()

3289

3290

client_class = Client

3291

if use_dbus:

3292

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

3293

3294

client_settings = Client.config_parser(client_config)

3295

old_client_settings = {}

3296

clients_data = {}

3297

3298

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

3299

global wnull

3300

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

3301

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

3302

# mode

3303

if debug or not foreground:

3304

wnull.close()

3305

3306

# Get client data and settings from last running state.

3307

if server_settings["restore"]:

3308

try:

3309

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

3310

if sys.version_info.major == 2:

3311

clients_data, old_client_settings = pickle.load(

3312

stored_state)

3313

else:

3314

bytes_clients_data, bytes_old_client_settings = (

3315

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

3316

# Fix bytes to strings

3317

# clients_data

3318

# .keys()

3319

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

3320

if isinstance(key, bytes)

3321

else key): value

3322

for key, value in

3323

bytes_clients_data.items()}

3324

del bytes_clients_data

3325

for key in clients_data:

3326

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

3327

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

3328

for k, v in

3329

clients_data[key].items()}

3330

clients_data[key] = value

3331

# .client_structure

3332

value["client_structure"] = [

3333

(s.decode("utf-8")

3334

if isinstance(s, bytes)

3335

else s) for s in

3336

value["client_structure"]]

3337

# .name, .host, and .checker_command

3338

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

3339

if isinstance(value[k], bytes):

3340

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

3341

if "key_id" not in value:

3342

value["key_id"] = ""

3343

elif "fingerprint" not in value:

3344

value["fingerprint"] = ""

3345

# old_client_settings

3346

# .keys()

3347

old_client_settings = {

3348

(key.decode("utf-8")

3349

if isinstance(key, bytes)

3350

else key): value

3351

for key, value in

3352

bytes_old_client_settings.items()}

3353

del bytes_old_client_settings

3354

# .host and .checker_command

3355

for value in old_client_settings.values():

3356

for attribute in ("host", "checker_command"):

3357

if isinstance(value[attribute], bytes):

3358

value[attribute] = (value[attribute]

3359

.decode("utf-8"))

3360

os.remove(stored_state_path)

3361

except IOError as e:

3362

if e.errno == errno.ENOENT:

3363

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

3364

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

3365

else:

3366

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

3367

exc_info=e)

3368

raise

3369

except EOFError as e:

3370

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

3371

exc_info=e)

3372

3373

with PGPEngine() as pgp:

3374

for client_name, client in clients_data.items():

3375

# Skip removed clients

3376

if client_name not in client_settings:

3377

continue

3378

3379

# Decide which value to use after restoring saved state.

3380

# We have three different values: Old config file,

3381

# new config file, and saved state.

3382

# New config value takes precedence if it differs from old

3383

# config value, otherwise use saved state.

3384

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

3385

try:

3386

# For each value in new config, check if it

3387

# differs from the old config value (Except for

3388

# the "secret" attribute)

3389

if (name != "secret"

3390

and (value !=

3391

old_client_settings[client_name][name])):

3392

client[name] = value

3393

except KeyError:

3394

pass

3395

3396

# Clients who has passed its expire date can still be

3397

# enabled if its last checker was successful. A Client

3398

# whose checker succeeded before we stored its state is

3399

# assumed to have successfully run all checkers during

3400

# downtime.

3401

if client["enabled"]:

3402

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

3403

if not client["last_checked_ok"]:

3404

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

3405

" never performed a successful"

3406

" checker", client_name)

3407

client["enabled"] = False

3408

elif client["last_checker_status"] != 0:

3409

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

3410

" last checker failed with error"

3411

" code %s", client_name,

3412

client["last_checker_status"])

3413

client["enabled"] = False

3414

else:

3415

client["expires"] = (

3416

datetime.datetime.utcnow()

3417

+ client["timeout"])

3418

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

3419

" enabled", client_name)

3420

try:

3421

client["secret"] = pgp.decrypt(

3422

client["encrypted_secret"],

3423

client_settings[client_name]["secret"])

3424

except PGPError:

3425

# If decryption fails, we use secret from new settings

3426

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

3427

client_name)

3428

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

3429

["secret"])

3430

3431

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

3432

for client_name in (set(old_client_settings)

3433

- set(client_settings)):

3434

del clients_data[client_name]

3435

for client_name in (set(client_settings)

3436

- set(old_client_settings)):

3437

clients_data[client_name] = client_settings[client_name]

3438

3439

# Create all client objects

3440

for client_name, client in clients_data.items():

3441

tcp_server.clients[client_name] = client_class(

3442

name=client_name,

3443

settings=client,

3444

server_settings=server_settings)

3445

3446

if not tcp_server.clients:

3447

log.warning("No clients defined")

3448

3449

if not foreground:

3450

if pidfile is not None:

3451

pid = os.getpid()

3452

try:

3453

with pidfile:

3454

print(pid, file=pidfile)

3455

except IOError:

3456

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

3457

pidfilename, pid)

3458

del pidfile

3459

del pidfilename

3460

3461

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

3462

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3463

lambda: main_loop.quit() and False)

3464

3465

if use_dbus:

3466

3467

@alternate_dbus_interfaces(

3468

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

3469

class MandosDBusService(DBusObjectWithObjectManager):

3470

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

3471

3472

def __init__(self):

3473

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

3474

3475

_interface = "se.recompile.Mandos"

3476

3477

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

3478

def ClientAdded(self, objpath):

3479

"D-Bus signal"

3480

pass

3481

3482

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

3483

def ClientNotFound(self, key_id, address):

3484

"D-Bus signal"

3485

pass

3486

3487

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

3488

"true"})

3489

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

3490

def ClientRemoved(self, objpath, name):

3491

"D-Bus signal"

3492

pass

3493

3494

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

3495

"true"})

3496

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

3497

def GetAllClients(self):

3498

"D-Bus method"

3499

return dbus.Array(c.dbus_object_path for c in

3500

tcp_server.clients.values())

3501

3502

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

3503

"true"})

3504

@dbus.service.method(_interface,

3505

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

3506

def GetAllClientsWithProperties(self):

3507

"D-Bus method"

3508

return dbus.Dictionary(

3509

{c.dbus_object_path: c.GetAll(

3510

"se.recompile.Mandos.Client")

3511

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

3512

signature="oa{sv}")

3513

3514

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

3515

def RemoveClient(self, object_path):

3516

"D-Bus method"

3517

for c in tcp_server.clients.values():

3518

if c.dbus_object_path == object_path:

3519

del tcp_server.clients[c.name]

3520

c.remove_from_connection()

3521

# Don't signal the disabling

3522

c.disable(quiet=True)

3523

# Emit D-Bus signal for removal

3524

self.client_removed_signal(c)

3525

return

3526

raise KeyError(object_path)

3527

3528

del _interface

3529

3530

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3531

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

3532

def GetManagedObjects(self):

3533

"""D-Bus method"""

3534

return dbus.Dictionary(

3535

{client.dbus_object_path:

3536

dbus.Dictionary(

3537

{interface: client.GetAll(interface)

3538

for interface in

3539

client._get_all_interface_names()})

3540

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

3541

3542

def client_added_signal(self, client):

3543

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

3544

if use_dbus:

3545

# New standard signal

3546

self.InterfacesAdded(

3547

client.dbus_object_path,

3548

dbus.Dictionary(

3549

{interface: client.GetAll(interface)

3550

for interface in

3551

client._get_all_interface_names()}))

3552

# Old signal

3553

self.ClientAdded(client.dbus_object_path)

3554

3555

def client_removed_signal(self, client):

3556

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

3557

if use_dbus:

3558

# New standard signal

3559

self.InterfacesRemoved(

3560

client.dbus_object_path,

3561

client._get_all_interface_names())

3562

# Old signal

3563

self.ClientRemoved(client.dbus_object_path,

3564

client.name)

3565

3566

mandos_dbus_service = MandosDBusService()

3567

3568

# Save modules to variables to exempt the modules from being

3569

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

3570

mp = multiprocessing

3571

wn = wnull

3572

3573

def cleanup():

3574

"Cleanup function; run on exit"

3575

if zeroconf:

3576

service.cleanup()

3577

3578

mp.active_children()

3579

wn.close()

3580

if not (tcp_server.clients or client_settings):

3581

return

3582

3583

# Store client before exiting. Secrets are encrypted with key

3584

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

3585

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

3586

clients = {}

3587

with PGPEngine() as pgp:

3588

for client in tcp_server.clients.values():

3589

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

3590

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

3591

key)

3592

client_dict = {}

3593

3594

# A list of attributes that can not be pickled

3595

# + secret.

3596

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

3597

"checker", "server_settings"}

3598

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

3599

.Object):

3600

exclude.add(name)

3601

3602

client_dict["encrypted_secret"] = (client

3603

.encrypted_secret)

3604

for attr in client.client_structure:

3605

if attr not in exclude:

3606

client_dict[attr] = getattr(client, attr)

3607

3608

clients[client.name] = client_dict

3609

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

3610

3611

try:

3612

with tempfile.NamedTemporaryFile(

3613

mode="wb",

3614

suffix=".pickle",

3615

prefix="clients-",

3616

dir=os.path.dirname(stored_state_path),

3617

delete=False) as stored_state:

3618

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

3619

protocol=2)

3620

tempname = stored_state.name

3621

os.rename(tempname, stored_state_path)

3622

except (IOError, OSError) as e:

3623

if not debug:

3624

try:

3625

os.remove(tempname)

3626

except NameError:

3627

pass

3628

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

3629

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

3630

os.strerror(e.errno))

3631

else:

3632

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

3633

exc_info=e)

3634

raise

3635

3636

# Delete all clients, and settings from config

3637

while tcp_server.clients:

3638

name, client = tcp_server.clients.popitem()

3639

if use_dbus:

3640

client.remove_from_connection()

3641

# Don't signal the disabling

3642

client.disable(quiet=True)

3643

# Emit D-Bus signal for removal

3644

if use_dbus:

3645

mandos_dbus_service.client_removed_signal(client)

3646

client_settings.clear()

3647

3648

atexit.register(cleanup)

3649

3650

for client in tcp_server.clients.values():

3651

if use_dbus:

3652

# Emit D-Bus signal for adding

3653

mandos_dbus_service.client_added_signal(client)

3654

# Need to initiate checking of clients

3655

if client.enabled:

3656

client.init_checker(randomize_start=True)

3657

3658

tcp_server.enable()

3659

tcp_server.server_activate()

3660

3661

# Find out what port we got

3662

if zeroconf:

3663

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

3664

if use_ipv6:

3665

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

3666

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

3667

else: # IPv4

3668

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

3669

*tcp_server.socket.getsockname())

3670

3671

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

3672

3673

try:

3674

if zeroconf:

3675

# From the Avahi example code

3676

try:

3677

service.activate()

3678

except dbus.exceptions.DBusException as error:

3679

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

3680

cleanup()

3681

sys.exit(1)

3682

# End of Avahi example code

3683

3684

GLib.io_add_watch(

3685

GLib.IOChannel.unix_new(tcp_server.fileno()),

3686

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

3687

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

3688

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

3689

3690

log.debug("Starting main loop")

3691

main_loop.run()

3692

except AvahiError as error:

3693

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

3694

cleanup()

3695

sys.exit(1)

3696

except KeyboardInterrupt:

3697

if debug:

3698

print("", file=sys.stderr)

3699

log.debug("Server received KeyboardInterrupt")

3700

log.debug("Server exiting")

3701

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

3702

cleanup()

3703

3704

3705

def parse_test_args():

3706

# type: () -> argparse.Namespace

3707

parser = argparse.ArgumentParser(add_help=False)

3708

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

3709

parser.add_argument("--prefix", )

3710

args, unknown_args = parser.parse_known_args()

3711

if args.check:

3712

# Remove test options from sys.argv

3713

sys.argv[1:] = unknown_args

3714

return args

3715

3716

# Add all tests from doctest strings

3717

def load_tests(loader, tests, none):

3718

import doctest

3719

tests.addTests(doctest.DocTestSuite())

3720

return tests

293

294

# Cleanup here

295

for client in clients:

296

client.stop_checker()

297

3721

298

3722

299

if __name__ == "__main__":

3723

options = parse_test_args()

3724

try:

3725

if options.check:

3726

extra_test_prefix = options.prefix

3727

if extra_test_prefix is not None:

3728

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

3729

.result.wasSuccessful()):

3730

sys.exit(1)

3731

class ExtraTestLoader(unittest.TestLoader):

3732

testMethodPrefix = extra_test_prefix

3733

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

3734

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

3735

else:

3736

unittest.main(argv=[""])

3737

else:

3738

main()

3739

finally:

3740

logging.shutdown()

3741

3742

# Local Variables:

3743

# run-tests:

3744

# (lambda (&optional extra)

3745

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

3746

# extra))

3747

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

3748

# (funcall remove-test-window)

3749

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

3750

# run-tests-in-test-buffer:

3751

# (lambda (dir &optional extra)

3752

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

3753

# (setq buffer-read-only nil

3754

# default-directory dir)

3755

# (erase-buffer)

3756

# (compilation-mode))

3757

# (let ((process-result

3758

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

3759

# (process-file-shell-command

3760

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

3761

# (and (numberp process-result)

3762

# (= process-result 0))))

3763

# get-command-line:

3764

# (lambda (&optional extra)

3765

# (let ((quoted-script

3766

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

3767

# (format

3768

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

3769

# quoted-script)))

3770

# get-script-name:

3771

# (lambda ()

3772

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

3773

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

3774

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

3775

# (buffer-file-name))))

3776

# remove-test-window:

3777

# (lambda ()

3778

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

3779

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

3780

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

3781

# (lambda ()

3782

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

3783

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

3784

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

3785

# (display-buffer-overriding-action

3786

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

3787

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

3788

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

3789

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

3790

# eval:

3791

# (progn

3792

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

3793

# (funcall run-tests t)))

3794

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

3795

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

3796

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

3797

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

3798

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

3799

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

3800

# End:

300

main()

301