/mandos/release : revision 237.7.305

1

#!/usr/bin/python2.7

2

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

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 program is free software: you can redistribute it and/or modify

18

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

19

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

20

# (at your option) any later version.

21

#

22

# This program is distributed in the hope that it will be useful,

23

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

24

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

25

# GNU General Public License for more details.

26

#

27

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

28

# along with this program. If not, see

29

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

30

#

31

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

32

#

33

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

39

try:

40

import SocketServer as socketserver

41

except ImportError:

42

import socketserver

43

import socket

44

import argparse

45

import datetime

46

import errno

47

import gnutls.crypto

48

import gnutls.connection

49

import gnutls.errors

50

import gnutls.library.functions

51

import gnutls.library.constants

52

import gnutls.library.types

53

try:

54

import ConfigParser as configparser

55

except ImportError:

56

import configparser

57

import sys

58

import re

59

import os

60

import signal

61

import subprocess

62

import atexit

63

import stat

64

import logging

65

import logging.handlers

66

import pwd

67

import contextlib

68

import struct

69

import fcntl

70

import functools

71

try:

72

import cPickle as pickle

73

except ImportError:

74

import pickle

75

import multiprocessing

76

import types

77

import binascii

78

import tempfile

79

import itertools

80

import collections

81

import codecs

82

83

import dbus

84

import dbus.service

85

try:

86

import gobject

87

except ImportError:

88

from gi.repository import GObject as gobject

89

import avahi

90

from dbus.mainloop.glib import DBusGMainLoop

91

import ctypes

92

import ctypes.util

93

import xml.dom.minidom

94

import inspect

95

96

try:

97

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

98

except AttributeError:

99

try:

100

from IN import SO_BINDTODEVICE

101

except ImportError:

102

SO_BINDTODEVICE = None

103

104

if sys.version_info.major == 2:

105

str = unicode

106

107

version = "1.6.9"

108

stored_state_file = "clients.pickle"

109

110

logger = logging.getLogger()

111

syslogger = None

112

113

try:

114

if_nametoindex = ctypes.cdll.LoadLibrary(

115

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

116

except (OSError, AttributeError):

117

118

def if_nametoindex(interface):

119

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

120

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

121

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

122

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

123

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

124

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

125

return interface_index

126

127

128

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

129

"""init logger and add loglevel"""

130

131

global syslogger

132

syslogger = (logging.handlers.SysLogHandler(

133

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

134

address = "/dev/log"))

135

syslogger.setFormatter(logging.Formatter

136

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

137

' %(message)s'))

138

logger.addHandler(syslogger)

139

140

if debug:

141

console = logging.StreamHandler()

142

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

143

' [%(process)d]:'

144

' %(levelname)s:'

145

' %(message)s'))

146

logger.addHandler(console)

147

logger.setLevel(level)

148

149

150

class PGPError(Exception):

151

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

152

pass

153

154

155

class PGPEngine(object):

156

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

157

158

def __init__(self):

159

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

160

self.gnupgargs = ['--batch',

161

'--home', self.tempdir,

162

'--force-mdc',

163

'--quiet',

164

'--no-use-agent']

165

166

def __enter__(self):

167

return self

168

169

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

170

self._cleanup()

171

return False

172

173

def __del__(self):

174

self._cleanup()

175

176

def _cleanup(self):

177

if self.tempdir is not None:

178

# Delete contents of tempdir

179

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

180

topdown = False):

181

for filename in files:

182

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

183

for dirname in dirs:

184

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

185

# Remove tempdir

186

os.rmdir(self.tempdir)

187

self.tempdir = None

188

189

def password_encode(self, password):

190

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

191

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

192

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

193

if len(encoded) > 2048:

194

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

195

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

196

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

197

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

198

return encoded

199

200

def encrypt(self, data, password):

201

passphrase = self.password_encode(password)

202

with tempfile.NamedTemporaryFile(

203

dir=self.tempdir) as passfile:

204

passfile.write(passphrase)

205

passfile.flush()

206

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

207

'--passphrase-file',

208

passfile.name]

209

+ self.gnupgargs,

210

stdin = subprocess.PIPE,

211

stdout = subprocess.PIPE,

212

stderr = subprocess.PIPE)

213

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

214

if proc.returncode != 0:

215

raise PGPError(err)

216

return ciphertext

217

218

def decrypt(self, data, password):

219

passphrase = self.password_encode(password)

220

with tempfile.NamedTemporaryFile(

221

dir = self.tempdir) as passfile:

222

passfile.write(passphrase)

223

passfile.flush()

224

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

225

'--passphrase-file',

226

passfile.name]

227

+ self.gnupgargs,

228

stdin = subprocess.PIPE,

229

stdout = subprocess.PIPE,

230

stderr = subprocess.PIPE)

231

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

232

if proc.returncode != 0:

233

raise PGPError(err)

234

return decrypted_plaintext

235

236

237

class AvahiError(Exception):

238

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

239

self.value = value

240

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

241

**kwargs)

242

243

244

class AvahiServiceError(AvahiError):

245

pass

246

247

248

class AvahiGroupError(AvahiError):

249

pass

250

251

252

class AvahiService(object):

253

"""An Avahi (Zeroconf) service.

254

255

Attributes:

256

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

257

Used to optionally bind to the specified interface.

258

name: string; Example: 'Mandos'

259

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

260

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

261

port: integer; what port to announce

262

TXT: list of strings; TXT record for the service

263

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

264

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

265

max_renames: integer; maximum number of renames

266

rename_count: integer; counter so we only rename after collisions

267

a sensible number of times

268

group: D-Bus Entry Group

269

server: D-Bus Server

270

bus: dbus.SystemBus()

271

"""

272

273

def __init__(self,

274

interface = avahi.IF_UNSPEC,

275

name = None,

276

servicetype = None,

277

port = None,

278

TXT = None,

279

domain = "",

280

host = "",

281

max_renames = 32768,

282

protocol = avahi.PROTO_UNSPEC,

283

bus = None):

284

self.interface = interface

285

self.name = name

286

self.type = servicetype

287

self.port = port

288

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

289

self.domain = domain

290

self.host = host

291

self.rename_count = 0

292

self.max_renames = max_renames

293

self.protocol = protocol

294

self.group = None # our entry group

295

self.server = None

296

self.bus = bus

297

self.entry_group_state_changed_match = None

298

299

def rename(self, remove=True):

300

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

301

if self.rename_count >= self.max_renames:

302

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

303

" after %i retries, exiting.",

304

self.rename_count)

305

raise AvahiServiceError("Too many renames")

306

self.name = str(

307

self.server.GetAlternativeServiceName(self.name))

308

self.rename_count += 1

309

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

310

self.name)

311

if remove:

312

self.remove()

313

try:

314

self.add()

315

except dbus.exceptions.DBusException as error:

316

if (error.get_dbus_name()

317

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

318

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

319

return self.rename(remove=False)

320

else:

321

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

322

self.cleanup()

323

os._exit(1)

324

325

def remove(self):

326

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

327

if self.entry_group_state_changed_match is not None:

328

self.entry_group_state_changed_match.remove()

329

self.entry_group_state_changed_match = None

330

if self.group is not None:

331

self.group.Reset()

332

333

def add(self):

334

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

335

self.remove()

336

if self.group is None:

337

self.group = dbus.Interface(

338

self.bus.get_object(avahi.DBUS_NAME,

339

self.server.EntryGroupNew()),

340

avahi.DBUS_INTERFACE_ENTRY_GROUP)

341

self.entry_group_state_changed_match = (

342

self.group.connect_to_signal(

343

'StateChanged', self.entry_group_state_changed))

344

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

345

self.name, self.type)

346

self.group.AddService(

347

self.interface,

348

self.protocol,

349

dbus.UInt32(0), # flags

350

self.name, self.type,

351

self.domain, self.host,

352

dbus.UInt16(self.port),

353

avahi.string_array_to_txt_array(self.TXT))

354

self.group.Commit()

355

356

def entry_group_state_changed(self, state, error):

357

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

358

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

359

360

if state == avahi.ENTRY_GROUP_ESTABLISHED:

361

logger.debug("Zeroconf service established.")

362

elif state == avahi.ENTRY_GROUP_COLLISION:

363

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

364

self.rename()

365

elif state == avahi.ENTRY_GROUP_FAILURE:

366

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

367

str(error))

368

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

369

370

def cleanup(self):

371

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

372

if self.group is not None:

373

try:

374

self.group.Free()

375

except (dbus.exceptions.UnknownMethodException,

376

dbus.exceptions.DBusException):

377

pass

378

self.group = None

379

self.remove()

380

381

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

382

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

383

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

384

bad_states = {

385

avahi.SERVER_INVALID: "Zeroconf server invalid",

386

avahi.SERVER_REGISTERING: None,

387

avahi.SERVER_COLLISION: "Zeroconf server name collision",

388

avahi.SERVER_FAILURE: "Zeroconf server failure",

389

}

390

if state in bad_states:

391

if bad_states[state] is not None:

392

if error is None:

393

logger.error(bad_states[state])

394

else:

395

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

396

self.cleanup()

397

elif state == avahi.SERVER_RUNNING:

398

self.add()

399

else:

400

if error is None:

401

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

402

else:

403

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

404

405

def activate(self):

406

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

407

if self.server is None:

408

self.server = dbus.Interface(

409

self.bus.get_object(avahi.DBUS_NAME,

410

avahi.DBUS_PATH_SERVER,

411

follow_name_owner_changes=True),

412

avahi.DBUS_INTERFACE_SERVER)

413

self.server.connect_to_signal("StateChanged",

414

self.server_state_changed)

415

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

416

417

418

class AvahiServiceToSyslog(AvahiService):

419

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

420

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

421

ret = AvahiService.rename(self, *args, **kwargs)

422

syslogger.setFormatter(logging.Formatter(

423

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

424

.format(self.name)))

425

return ret

426

427

def call_pipe(connection, # : multiprocessing.Connection

428

func, *args, **kwargs):

429

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

430

431

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

432

return value on the provided multiprocessing.Connection.

433

"""

434

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

435

connection.close()

436

437

class Client(object):

438

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

439

440

Attributes:

441

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

442

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

443

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

444

checker: subprocess.Popen(); a running checker process used

445

to see if the client lives.

446

'None' if no process is running.

447

checker_callback_tag: a gobject event source tag, or None

448

checker_command: string; External command which is run to check

449

if client lives. %() expansions are done at

450

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

451

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

452

checker_initiator_tag: a gobject event source tag, or None

453

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

454

client_structure: Object describing what attributes a client has

455

and is used for storing the client at exit

456

current_checker_command: string; current running checker_command

457

disable_initiator_tag: a gobject event source tag, or None

458

enabled: bool()

459

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

460

uniquely identify the client

461

host: string; available for use by the checker command

462

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

463

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

464

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

465

last_checker_status: integer between 0 and 255 reflecting exit

466

status of last checker. -1 reflects crashed

467

checker, -2 means no checker completed yet.

468

last_checker_signal: The signal which killed the last checker, if

469

last_checker_status is -1

470

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

471

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

472

D-Bus identifiers

473

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

474

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

475

until this client is disabled

476

extended_timeout: extra long timeout when secret has been sent

477

runtime_expansions: Allowed attributes for runtime expansion.

478

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

479

disabled, or None

480

server_settings: The server_settings dict from main()

481

"""

482

483

runtime_expansions = ("approval_delay", "approval_duration",

484

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

485

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

486

"last_approval_request", "last_checked_ok",

487

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

488

client_defaults = {

489

"timeout": "PT5M",

490

"extended_timeout": "PT15M",

491

"interval": "PT2M",

492

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

493

"host": "",

494

"approval_delay": "PT0S",

495

"approval_duration": "PT1S",

496

"approved_by_default": "True",

497

"enabled": "True",

498

}

499

500

@staticmethod

501

def config_parser(config):

502

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

503

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

504

with exceptions for any special settings as defined above.

505

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

506

value given the same arguments.

507

"""

508

settings = {}

509

for client_name in config.sections():

510

section = dict(config.items(client_name))

511

client = settings[client_name] = {}

512

513

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

514

# Reformat values from string types to Python types

515

client["approved_by_default"] = config.getboolean(

516

client_name, "approved_by_default")

517

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

518

"enabled")

519

520

# Uppercase and remove spaces from fingerprint for later

521

# comparison purposes with return value from the

522

# fingerprint() function

523

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

524

.replace(" ", ""))

525

if "secret" in section:

526

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

527

elif "secfile" in section:

528

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

529

(section["secfile"])),

530

"rb") as secfile:

531

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

532

else:

533

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

534

.format(section))

535

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

536

client["extended_timeout"] = string_to_delta(

537

section["extended_timeout"])

538

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

539

client["approval_delay"] = string_to_delta(

540

section["approval_delay"])

541

client["approval_duration"] = string_to_delta(

542

section["approval_duration"])

543

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

544

client["last_approval_request"] = None

545

client["last_checked_ok"] = None

546

client["last_checker_status"] = -2

547

548

return settings

549

550

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

551

self.name = name

552

if server_settings is None:

553

server_settings = {}

554

self.server_settings = server_settings

555

# adding all client settings

556

for setting, value in settings.items():

557

setattr(self, setting, value)

558

559

if self.enabled:

560

if not hasattr(self, "last_enabled"):

561

self.last_enabled = datetime.datetime.utcnow()

562

if not hasattr(self, "expires"):

563

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

564

+ self.timeout)

565

else:

566

self.last_enabled = None

567

self.expires = None

568

569

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

570

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

571

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

572

datetime.datetime.utcnow())

573

574

# attributes specific for this server instance

575

self.checker = None

576

self.checker_initiator_tag = None

577

self.disable_initiator_tag = None

578

self.checker_callback_tag = None

579

self.current_checker_command = None

580

self.approved = None

581

self.approvals_pending = 0

582

self.changedstate = multiprocessing_manager.Condition(

583

multiprocessing_manager.Lock())

584

self.client_structure = [attr

585

for attr in self.__dict__.iterkeys()

586

if not attr.startswith("_")]

587

self.client_structure.append("client_structure")

588

589

for name, t in inspect.getmembers(

590

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

591

if not name.startswith("_"):

592

self.client_structure.append(name)

593

594

# Send notice to process children that client state has changed

595

def send_changedstate(self):

596

with self.changedstate:

597

self.changedstate.notify_all()

598

599

def enable(self):

600

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

601

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

602

# Already enabled

603

return

604

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

605

self.enabled = True

606

self.last_enabled = datetime.datetime.utcnow()

607

self.init_checker()

608

self.send_changedstate()

609

610

def disable(self, quiet=True):

611

"""Disable this client."""

612

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

613

return False

614

if not quiet:

615

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

616

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

617

gobject.source_remove(self.disable_initiator_tag)

618

self.disable_initiator_tag = None

619

self.expires = None

620

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

621

gobject.source_remove(self.checker_initiator_tag)

622

self.checker_initiator_tag = None

623

self.stop_checker()

624

self.enabled = False

625

if not quiet:

626

self.send_changedstate()

627

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

628

return False

629

630

def __del__(self):

631

self.disable()

632

633

def init_checker(self):

634

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

635

# and every interval from then on.

636

if self.checker_initiator_tag is not None:

637

gobject.source_remove(self.checker_initiator_tag)

638

self.checker_initiator_tag = gobject.timeout_add(

639

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

640

self.start_checker)

641

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

642

if self.disable_initiator_tag is not None:

643

gobject.source_remove(self.disable_initiator_tag)

644

self.disable_initiator_tag = gobject.timeout_add(

645

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

646

# Also start a new checker *right now*.

647

self.start_checker()

648

649

def checker_callback(self, source, condition, connection,

650

command):

651

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

652

self.checker_callback_tag = None

653

self.checker = None

654

# Read return code from connection (see call_pipe)

655

returncode = connection.recv()

656

connection.close()

657

658

if returncode >= 0:

659

self.last_checker_status = returncode

660

self.last_checker_signal = None

661

if self.last_checker_status == 0:

662

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

663

vars(self))

664

self.checked_ok()

665

else:

666

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

667

else:

668

self.last_checker_status = -1

669

self.last_checker_signal = -returncode

670

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

671

vars(self))

672

return False

673

674

def checked_ok(self):

675

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

676

self.last_checked_ok = datetime.datetime.utcnow()

677

self.last_checker_status = 0

678

self.last_checker_signal = None

679

self.bump_timeout()

680

681

def bump_timeout(self, timeout=None):

682

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

683

if timeout is None:

684

timeout = self.timeout

685

if self.disable_initiator_tag is not None:

686

gobject.source_remove(self.disable_initiator_tag)

687

self.disable_initiator_tag = None

688

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

689

self.disable_initiator_tag = gobject.timeout_add(

690

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

691

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

692

693

def need_approval(self):

694

self.last_approval_request = datetime.datetime.utcnow()

695

696

def start_checker(self):

697

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

698

699

If a checker already exists, leave it running and do

700

nothing."""

701

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

702

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

703

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

704

# would inevitably timeout, since no checker would get a

705

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

706

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

707

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

708

# should be.

709

710

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

711

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

712

self.checker.join()

713

self.checker = None

714

# Start a new checker if needed

715

if self.checker is None:

716

# Escape attributes for the shell

717

escaped_attrs = {

718

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

719

for attr in self.runtime_expansions }

720

try:

721

command = self.checker_command % escaped_attrs

722

except TypeError as error:

723

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

724

self.checker_command,

725

exc_info=error)

726

return True # Try again later

727

self.current_checker_command = command

728

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

729

self.name)

730

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

731

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

732

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

733

# always replaced by /dev/null.)

734

# The exception is when not debugging but nevertheless

735

# running in the foreground; use the previously

736

# created wnull.

737

popen_args = { "close_fds": True,

738

"shell": True,

739

"cwd": "/" }

740

if (not self.server_settings["debug"]

741

and self.server_settings["foreground"]):

742

popen_args.update({"stdout": wnull,

743

"stderr": wnull })

744

pipe = multiprocessing.Pipe(duplex = False)

745

self.checker = multiprocessing.Process(

746

target = call_pipe,

747

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

748

kwargs = popen_args)

749

self.checker.start()

750

self.checker_callback_tag = gobject.io_add_watch(

751

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

752

self.checker_callback, pipe[0], command)

753

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

754

return True

755

756

def stop_checker(self):

757

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

758

if self.checker_callback_tag:

759

gobject.source_remove(self.checker_callback_tag)

760

self.checker_callback_tag = None

761

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

762

return

763

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

764

self.checker.terminate()

765

self.checker = None

766

767

768

def dbus_service_property(dbus_interface,

769

signature="v",

770

access="readwrite",

771

byte_arrays=False):

772

"""Decorators for marking methods of a DBusObjectWithProperties to

773

become properties on the D-Bus.

774

775

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

776

and with one argument by "Set".

777

778

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

779

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

780

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

781

"""

782

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

783

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

784

if byte_arrays and signature != "ay":

785

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

786

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

787

788

def decorator(func):

789

func._dbus_is_property = True

790

func._dbus_interface = dbus_interface

791

func._dbus_signature = signature

792

func._dbus_access = access

793

func._dbus_name = func.__name__

794

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

795

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

796

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

797

return func

798

799

return decorator

800

801

802

def dbus_interface_annotations(dbus_interface):

803

"""Decorator for marking functions returning interface annotations

804

805

Usage:

806

807

@dbus_interface_annotations("org.example.Interface")

808

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

809

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

810

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

811

"false"}

812

"""

813

814

def decorator(func):

815

func._dbus_is_interface = True

816

func._dbus_interface = dbus_interface

817

func._dbus_name = dbus_interface

818

return func

819

820

return decorator

821

822

823

def dbus_annotations(annotations):

824

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

825

Usage:

826

827

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

828

"org.freedesktop.DBus.Property."

829

"EmitsChangedSignal": "false"})

830

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

831

access="r")

832

def Property_dbus_property(self):

833

return dbus.Boolean(False)

834

"""

835

836

def decorator(func):

837

func._dbus_annotations = annotations

838

return func

839

840

return decorator

841

842

843

class DBusPropertyException(dbus.exceptions.DBusException):

844

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

845

"""

846

pass

847

848

849

class DBusPropertyAccessException(DBusPropertyException):

850

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

851

"""

852

pass

853

854

855

class DBusPropertyNotFound(DBusPropertyException):

856

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

857

"""

858

pass

859

860

861

class DBusObjectWithProperties(dbus.service.Object):

862

"""A D-Bus object with properties.

863

864

Classes inheriting from this can use the dbus_service_property

865

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

866

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

867

"""

868

869

@staticmethod

870

def _is_dbus_thing(thing):

871

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

872

873

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

874

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

875

"""

876

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

877

False)

878

879

def _get_all_dbus_things(self, thing):

880

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

881

"""

882

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

883

athing.__get__(self))

884

for cls in self.__class__.__mro__

885

for name, athing in

886

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

887

888

def _get_dbus_property(self, interface_name, property_name):

889

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

890

property with the specified name and interface.

891

"""

892

for cls in self.__class__.__mro__:

893

for name, value in inspect.getmembers(

894

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

895

if (value._dbus_name == property_name

896

and value._dbus_interface == interface_name):

897

return value.__get__(self)

898

899

# No such property

900

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

901

self.dbus_object_path, interface_name, property_name))

902

903

@dbus.service.method(dbus.PROPERTIES_IFACE,

904

in_signature="ss",

905

out_signature="v")

906

def Get(self, interface_name, property_name):

907

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

908

"""

909

prop = self._get_dbus_property(interface_name, property_name)

910

if prop._dbus_access == "write":

911

raise DBusPropertyAccessException(property_name)

912

value = prop()

913

if not hasattr(value, "variant_level"):

914

return value

915

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

916

917

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

918

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

919

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

920

"""

921

prop = self._get_dbus_property(interface_name, property_name)

922

if prop._dbus_access == "read":

923

raise DBusPropertyAccessException(property_name)

924

if prop._dbus_get_args_options["byte_arrays"]:

925

# The byte_arrays option is not supported yet on

926

# signatures other than "ay".

927

if prop._dbus_signature != "ay":

928

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

929

"'ay' signature {!r}"

930

.format(prop._dbus_signature))

931

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

932

for byte in value))

933

prop(value)

934

935

@dbus.service.method(dbus.PROPERTIES_IFACE,

936

in_signature="s",

937

out_signature="a{sv}")

938

def GetAll(self, interface_name):

939

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

940

standard.

941

942

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

943

"""

944

properties = {}

945

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

946

if (interface_name

947

and interface_name != prop._dbus_interface):

948

# Interface non-empty but did not match

949

continue

950

# Ignore write-only properties

951

if prop._dbus_access == "write":

952

continue

953

value = prop()

954

if not hasattr(value, "variant_level"):

955

properties[name] = value

956

continue

957

properties[name] = type(value)(

958

value, variant_level = value.variant_level + 1)

959

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

960

961

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

962

def PropertiesChanged(self, interface_name, changed_properties,

963

invalidated_properties):

964

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

965

standard.

966

"""

967

pass

968

969

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

970

out_signature="s",

971

path_keyword='object_path',

972

connection_keyword='connection')

973

def Introspect(self, object_path, connection):

974

"""Overloading of standard D-Bus method.

975

976

Inserts property tags and interface annotation tags.

977

"""

978

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

979

connection)

980

try:

981

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

982

983

def make_tag(document, name, prop):

984

e = document.createElement("property")

985

e.setAttribute("name", name)

986

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

987

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

988

return e

989

990

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

991

# Add property tags

992

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

993

for name, prop

994

in self._get_all_dbus_things("property")

995

if prop._dbus_interface

996

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

997

if_tag.appendChild(tag)

998

# Add annotation tags

999

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

1000

for tag in if_tag.getElementsByTagName(typ):

1001

annots = dict()

1002

for name, prop in (self.

1003

_get_all_dbus_things(typ)):

1004

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

1005

and prop._dbus_interface

1006

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

1007

annots.update(getattr(

1008

prop, "_dbus_annotations", {}))

1009

for name, value in annots.items():

1010

ann_tag = document.createElement(

1011

"annotation")

1012

ann_tag.setAttribute("name", name)

1013

ann_tag.setAttribute("value", value)

1014

tag.appendChild(ann_tag)

1015

# Add interface annotation tags

1016

for annotation, value in dict(

1017

itertools.chain.from_iterable(

1018

annotations().items()

1019

for name, annotations

1020

in self._get_all_dbus_things("interface")

1021

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

1022

)).items():

1023

ann_tag = document.createElement("annotation")

1024

ann_tag.setAttribute("name", annotation)

1025

ann_tag.setAttribute("value", value)

1026

if_tag.appendChild(ann_tag)

1027

# Add the names to the return values for the

1028

# "org.freedesktop.DBus.Properties" methods

1029

if (if_tag.getAttribute("name")

1030

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

1031

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

1032

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

1033

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

1034

if (arg.getAttribute("direction")

1035

== "out"):

1036

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

1037

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

1038

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

1039

if (arg.getAttribute("direction")

1040

== "out"):

1041

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

1042

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

1043

document.unlink()

1044

except (AttributeError, xml.dom.DOMException,

1045

xml.parsers.expat.ExpatError) as error:

1046

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

1047

exc_info=error)

1048

return xmlstring

1049

1050

1051

def datetime_to_dbus(dt, variant_level=0):

1052

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

1053

if dt is None:

1054

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

1055

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

1056

1057

1058

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1059

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

1060

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

1061

interface names according to the "alt_interface_names" mapping.

1062

Usage:

1063

1064

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

1065

"net.example.AlternateInterface"})

1066

class SampleDBusObject(dbus.service.Object):

1067

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

1068

def SampleDBusMethod():

1069

pass

1070

1071

The above "SampleDBusMethod" on "SampleDBusObject" will be

1072

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

1073

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

1074

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

1075

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

1076

1077

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

1078

(from DBusObjectWithProperties) and interfaces (from the

1079

dbus_interface_annotations decorator).

1080

"""

1081

1082

def wrapper(cls):

1083

for orig_interface_name, alt_interface_name in (

1084

alt_interface_names.items()):

1085

attr = {}

1086

interface_names = set()

1087

# Go though all attributes of the class

1088

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

1089

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

1090

# with the wrong interface name

1091

if (not hasattr(attribute, "_dbus_interface")

1092

or not attribute._dbus_interface.startswith(

1093

orig_interface_name)):

1094

continue

1095

# Create an alternate D-Bus interface name based on

1096

# the current name

1097

alt_interface = attribute._dbus_interface.replace(

1098

orig_interface_name, alt_interface_name)

1099

interface_names.add(alt_interface)

1100

# Is this a D-Bus signal?

1101

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

1102

if sys.version_info.major == 2:

1103

# Extract the original non-method undecorated

1104

# function by black magic

1105

nonmethod_func = (dict(

1106

zip(attribute.func_code.co_freevars,

1107

attribute.__closure__))

1108

["func"].cell_contents)

1109

else:

1110

nonmethod_func = attribute

1111

# Create a new, but exactly alike, function

1112

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

1113

# with the alternate D-Bus interface name

1114

if sys.version_info.major == 2:

1115

new_function = types.FunctionType(

1116

nonmethod_func.func_code,

1117

nonmethod_func.func_globals,

1118

nonmethod_func.func_name,

1119

nonmethod_func.func_defaults,

1120

nonmethod_func.func_closure)

1121

else:

1122

new_function = types.FunctionType(

1123

nonmethod_func.__code__,

1124

nonmethod_func.__globals__,

1125

nonmethod_func.__name__,

1126

nonmethod_func.__defaults__,

1127

nonmethod_func.__closure__)

1128

new_function = (dbus.service.signal(

1129

alt_interface,

1130

attribute._dbus_signature)(new_function))

1131

# Copy annotations, if any

1132

try:

1133

new_function._dbus_annotations = dict(

1134

attribute._dbus_annotations)

1135

except AttributeError:

1136

pass

1137

# Define a creator of a function to call both the

1138

# original and alternate functions, so both the

1139

# original and alternate signals gets sent when

1140

# the function is called

1141

def fixscope(func1, func2):

1142

"""This function is a scope container to pass

1143

func1 and func2 to the "call_both" function

1144

outside of its arguments"""

1145

1146

def call_both(*args, **kwargs):

1147

"""This function will emit two D-Bus

1148

signals by calling func1 and func2"""

1149

func1(*args, **kwargs)

1150

func2(*args, **kwargs)

1151

1152

return call_both

1153

# Create the "call_both" function and add it to

1154

# the class

1155

attr[attrname] = fixscope(attribute, new_function)

1156

# Is this a D-Bus method?

1157

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

1158

# Create a new, but exactly alike, function

1159

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

1160

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

1161

# to the class.

1162

attr[attrname] = (

1163

dbus.service.method(

1164

alt_interface,

1165

attribute._dbus_in_signature,

1166

attribute._dbus_out_signature)

1167

(types.FunctionType(attribute.func_code,

1168

attribute.func_globals,

1169

attribute.func_name,

1170

attribute.func_defaults,

1171

attribute.func_closure)))

1172

# Copy annotations, if any

1173

try:

1174

attr[attrname]._dbus_annotations = dict(

1175

attribute._dbus_annotations)

1176

except AttributeError:

1177

pass

1178

# Is this a D-Bus property?

1179

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

1180

# Create a new, but exactly alike, function

1181

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

1182

# property with the alternate D-Bus interface

1183

# name. Add it to the class.

1184

attr[attrname] = (dbus_service_property(

1185

alt_interface, attribute._dbus_signature,

1186

attribute._dbus_access,

1187

attribute._dbus_get_args_options

1188

["byte_arrays"])

1189

(types.FunctionType(

1190

attribute.func_code,

1191

attribute.func_globals,

1192

attribute.func_name,

1193

attribute.func_defaults,

1194

attribute.func_closure)))

1195

# Copy annotations, if any

1196

try:

1197

attr[attrname]._dbus_annotations = dict(

1198

attribute._dbus_annotations)

1199

except AttributeError:

1200

pass

1201

# Is this a D-Bus interface?

1202

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

1203

# Create a new, but exactly alike, function

1204

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

1205

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

1206

# to the class.

1207

attr[attrname] = (

1208

dbus_interface_annotations(alt_interface)

1209

(types.FunctionType(attribute.func_code,

1210

attribute.func_globals,

1211

attribute.func_name,

1212

attribute.func_defaults,

1213

attribute.func_closure)))

1214

if deprecate:

1215

# Deprecate all alternate interfaces

1216

iname="_AlternateDBusNames_interface_annotation{}"

1217

for interface_name in interface_names:

1218

1219

@dbus_interface_annotations(interface_name)

1220

def func(self):

1221

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

1222

"true" }

1223

# Find an unused name

1224

for aname in (iname.format(i)

1225

for i in itertools.count()):

1226

if aname not in attr:

1227

attr[aname] = func

1228

break

1229

if interface_names:

1230

# Replace the class with a new subclass of it with

1231

# methods, signals, etc. as created above.

1232

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

1233

(cls, ), attr)

1234

return cls

1235

1236

return wrapper

1237

1238

1239

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

1240

"se.bsnet.fukt.Mandos"})

1241

class ClientDBus(Client, DBusObjectWithProperties):

1242

"""A Client class using D-Bus

1243

1244

Attributes:

1245

dbus_object_path: dbus.ObjectPath

1246

bus: dbus.SystemBus()

1247

"""

1248

1249

runtime_expansions = (Client.runtime_expansions

1250

+ ("dbus_object_path", ))

1251

1252

_interface = "se.recompile.Mandos.Client"

1253

1254

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

1255

1256

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

1257

self.bus = bus

1258

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

1259

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

1260

# the D-Bus

1261

client_object_name = str(self.name).translate(

1262

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

1263

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

1264

self.dbus_object_path = dbus.ObjectPath(

1265

"/clients/" + client_object_name)

1266

DBusObjectWithProperties.__init__(self, self.bus,

1267

self.dbus_object_path)

1268

1269

def notifychangeproperty(transform_func, dbus_name,

1270

type_func=lambda x: x,

1271

variant_level=1,

1272

invalidate_only=False,

1273

_interface=_interface):

1274

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

1275

its changes to DBus.

1276

1277

transform_fun: Function that takes a value and a variant_level

1278

and transforms it to a D-Bus type.

1279

dbus_name: D-Bus name of the variable

1280

type_func: Function that transform the value before sending it

1281

to the D-Bus. Default: no transform

1282

variant_level: D-Bus variant level. Default: 1

1283

"""

1284

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

1285

1286

def setter(self, value):

1287

if hasattr(self, "dbus_object_path"):

1288

if (not hasattr(self, attrname) or

1289

type_func(getattr(self, attrname, None))

1290

!= type_func(value)):

1291

if invalidate_only:

1292

self.PropertiesChanged(

1293

_interface, dbus.Dictionary(),

1294

dbus.Array((dbus_name, )))

1295

else:

1296

dbus_value = transform_func(

1297

type_func(value),

1298

variant_level = variant_level)

1299

self.PropertyChanged(dbus.String(dbus_name),

1300

dbus_value)

1301

self.PropertiesChanged(

1302

_interface,

1303

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

1304

dbus_value }),

1305

dbus.Array())

1306

setattr(self, attrname, value)

1307

1308

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

1309

1310

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1311

approvals_pending = notifychangeproperty(dbus.Boolean,

1312

"ApprovalPending",

1313

type_func = bool)

1314

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

1315

last_enabled = notifychangeproperty(datetime_to_dbus,

1316

"LastEnabled")

1317

checker = notifychangeproperty(

1318

dbus.Boolean, "CheckerRunning",

1319

type_func = lambda checker: checker is not None)

1320

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1321

"LastCheckedOK")

1322

last_checker_status = notifychangeproperty(dbus.Int16,

1323

"LastCheckerStatus")

1324

last_approval_request = notifychangeproperty(

1325

datetime_to_dbus, "LastApprovalRequest")

1326

approved_by_default = notifychangeproperty(dbus.Boolean,

1327

"ApprovedByDefault")

1328

approval_delay = notifychangeproperty(

1329

dbus.UInt64, "ApprovalDelay",

1330

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

1331

approval_duration = notifychangeproperty(

1332

dbus.UInt64, "ApprovalDuration",

1333

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

1334

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

1335

timeout = notifychangeproperty(

1336

dbus.UInt64, "Timeout",

1337

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

1338

extended_timeout = notifychangeproperty(

1339

dbus.UInt64, "ExtendedTimeout",

1340

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

1341

interval = notifychangeproperty(

1342

dbus.UInt64, "Interval",

1343

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

1344

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

1345

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

1346

invalidate_only=True)

1347

1348

del notifychangeproperty

1349

1350

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

1351

try:

1352

self.remove_from_connection()

1353

except LookupError:

1354

pass

1355

if hasattr(DBusObjectWithProperties, "__del__"):

1356

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

1357

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

1358

1359

def checker_callback(self, source, condition,

1360

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

1361

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

1362

connection, command, *args,

1363

**kwargs)

1364

exitstatus = self.last_checker_status

1365

if exitstatus >= 0:

1366

# Emit D-Bus signal

1367

self.CheckerCompleted(dbus.Int16(exitstatus),

1368

dbus.Int64(0),

1369

dbus.String(command))

1370

else:

1371

# Emit D-Bus signal

1372

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

1373

dbus.Int64(

1374

self.last_checker_signal),

1375

dbus.String(command))

1376

return ret

1377

1378

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

1379

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

1380

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

1381

# Only if new checker process was started

1382

if (self.checker is not None

1383

and old_checker_pid != self.checker.pid):

1384

# Emit D-Bus signal

1385

self.CheckerStarted(self.current_checker_command)

1386

return r

1387

1388

def _reset_approved(self):

1389

self.approved = None

1390

return False

1391

1392

def approve(self, value=True):

1393

self.approved = value

1394

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

1395

* 1000), self._reset_approved)

1396

self.send_changedstate()

1397

1398

## D-Bus methods, signals & properties

1399

1400

## Interfaces

1401

1402

## Signals

1403

1404

# CheckerCompleted - signal

1405

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

1406

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

1407

"D-Bus signal"

1408

pass

1409

1410

# CheckerStarted - signal

1411

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

1412

def CheckerStarted(self, command):

1413

"D-Bus signal"

1414

pass

1415

1416

# PropertyChanged - signal

1417

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

1418

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

1419

def PropertyChanged(self, property, value):

1420

"D-Bus signal"

1421

pass

1422

1423

# GotSecret - signal

1424

@dbus.service.signal(_interface)

1425

def GotSecret(self):

1426

"""D-Bus signal

1427

Is sent after a successful transfer of secret from the Mandos

1428

server to mandos-client

1429

"""

1430

pass

1431

1432

# Rejected - signal

1433

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

1434

def Rejected(self, reason):

1435

"D-Bus signal"

1436

pass

1437

1438

# NeedApproval - signal

1439

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

1440

def NeedApproval(self, timeout, default):

1441

"D-Bus signal"

1442

return self.need_approval()

1443

1444

## Methods

1445

1446

# Approve - method

1447

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

1448

def Approve(self, value):

1449

self.approve(value)

1450

1451

# CheckedOK - method

1452

@dbus.service.method(_interface)

1453

def CheckedOK(self):

1454

self.checked_ok()

1455

1456

# Enable - method

1457

@dbus.service.method(_interface)

1458

def Enable(self):

1459

"D-Bus method"

1460

self.enable()

1461

1462

# StartChecker - method

1463

@dbus.service.method(_interface)

1464

def StartChecker(self):

1465

"D-Bus method"

1466

self.start_checker()

1467

1468

# Disable - method

1469

@dbus.service.method(_interface)

1470

def Disable(self):

1471

"D-Bus method"

1472

self.disable()

1473

1474

# StopChecker - method

1475

@dbus.service.method(_interface)

1476

def StopChecker(self):

1477

self.stop_checker()

1478

1479

## Properties

1480

1481

# ApprovalPending - property

1482

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

1483

def ApprovalPending_dbus_property(self):

1484

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

1485

1486

# ApprovedByDefault - property

1487

@dbus_service_property(_interface,

1488

signature="b",

1489

access="readwrite")

1490

def ApprovedByDefault_dbus_property(self, value=None):

1491

if value is None: # get

1492

return dbus.Boolean(self.approved_by_default)

1493

self.approved_by_default = bool(value)

1494

1495

# ApprovalDelay - property

1496

@dbus_service_property(_interface,

1497

signature="t",

1498

access="readwrite")

1499

def ApprovalDelay_dbus_property(self, value=None):

1500

if value is None: # get

1501

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

1502

* 1000)

1503

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

1504

1505

# ApprovalDuration - property

1506

@dbus_service_property(_interface,

1507

signature="t",

1508

access="readwrite")

1509

def ApprovalDuration_dbus_property(self, value=None):

1510

if value is None: # get

1511

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

1512

* 1000)

1513

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

1514

1515

# Name - property

1516

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

1517

def Name_dbus_property(self):

1518

return dbus.String(self.name)

1519

1520

# Fingerprint - property

1521

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

1522

def Fingerprint_dbus_property(self):

1523

return dbus.String(self.fingerprint)

1524

1525

# Host - property

1526

@dbus_service_property(_interface,

1527

signature="s",

1528

access="readwrite")

1529

def Host_dbus_property(self, value=None):

1530

if value is None: # get

1531

return dbus.String(self.host)

1532

self.host = str(value)

1533

1534

# Created - property

1535

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

1536

def Created_dbus_property(self):

1537

return datetime_to_dbus(self.created)

1538

1539

# LastEnabled - property

1540

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

1541

def LastEnabled_dbus_property(self):

1542

return datetime_to_dbus(self.last_enabled)

1543

1544

# Enabled - property

1545

@dbus_service_property(_interface,

1546

signature="b",

1547

access="readwrite")

1548

def Enabled_dbus_property(self, value=None):

1549

if value is None: # get

1550

return dbus.Boolean(self.enabled)

1551

if value:

1552

self.enable()

1553

else:

1554

self.disable()

1555

1556

# LastCheckedOK - property

1557

@dbus_service_property(_interface,

1558

signature="s",

1559

access="readwrite")

1560

def LastCheckedOK_dbus_property(self, value=None):

1561

if value is not None:

1562

self.checked_ok()

1563

return

1564

return datetime_to_dbus(self.last_checked_ok)

1565

1566

# LastCheckerStatus - property

1567

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

1568

def LastCheckerStatus_dbus_property(self):

1569

return dbus.Int16(self.last_checker_status)

1570

1571

# Expires - property

1572

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

1573

def Expires_dbus_property(self):

1574

return datetime_to_dbus(self.expires)

1575

1576

# LastApprovalRequest - property

1577

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

1578

def LastApprovalRequest_dbus_property(self):

1579

return datetime_to_dbus(self.last_approval_request)

1580

1581

# Timeout - property

1582

@dbus_service_property(_interface,

1583

signature="t",

1584

access="readwrite")

1585

def Timeout_dbus_property(self, value=None):

1586

if value is None: # get

1587

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

1588

old_timeout = self.timeout

1589

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

1590

# Reschedule disabling

1591

if self.enabled:

1592

now = datetime.datetime.utcnow()

1593

self.expires += self.timeout - old_timeout

1594

if self.expires <= now:

1595

# The timeout has passed

1596

self.disable()

1597

else:

1598

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

1599

is None):

1600

return

1601

gobject.source_remove(self.disable_initiator_tag)

1602

self.disable_initiator_tag = gobject.timeout_add(

1603

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

1604

self.disable)

1605

1606

# ExtendedTimeout - property

1607

@dbus_service_property(_interface,

1608

signature="t",

1609

access="readwrite")

1610

def ExtendedTimeout_dbus_property(self, value=None):

1611

if value is None: # get

1612

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

1613

* 1000)

1614

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

1615

1616

# Interval - property

1617

@dbus_service_property(_interface,

1618

signature="t",

1619

access="readwrite")

1620

def Interval_dbus_property(self, value=None):

1621

if value is None: # get

1622

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

1623

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

1624

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

1625

return

1626

if self.enabled:

1627

# Reschedule checker run

1628

gobject.source_remove(self.checker_initiator_tag)

1629

self.checker_initiator_tag = gobject.timeout_add(

1630

value, self.start_checker)

1631

self.start_checker() # Start one now, too

1632

1633

# Checker - property

1634

@dbus_service_property(_interface,

1635

signature="s",

1636

access="readwrite")

1637

def Checker_dbus_property(self, value=None):

1638

if value is None: # get

1639

return dbus.String(self.checker_command)

1640

self.checker_command = str(value)

1641

1642

# CheckerRunning - property

1643

@dbus_service_property(_interface,

1644

signature="b",

1645

access="readwrite")

1646

def CheckerRunning_dbus_property(self, value=None):

1647

if value is None: # get

1648

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

1649

if value:

1650

self.start_checker()

1651

else:

1652

self.stop_checker()

1653

1654

# ObjectPath - property

1655

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

1656

def ObjectPath_dbus_property(self):

1657

return self.dbus_object_path # is already a dbus.ObjectPath

1658

1659

# Secret = property

1660

@dbus_service_property(_interface,

1661

signature="ay",

1662

access="write",

1663

byte_arrays=True)

1664

def Secret_dbus_property(self, value):

1665

self.secret = bytes(value)

1666

1667

del _interface

1668

1669

1670

class ProxyClient(object):

1671

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

1672

self._pipe = child_pipe

1673

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

1674

if not self._pipe.recv():

1675

raise KeyError(fpr)

1676

1677

def __getattribute__(self, name):

1678

if name == '_pipe':

1679

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

1680

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

1681

data = self._pipe.recv()

1682

if data[0] == 'data':

1683

return data[1]

1684

if data[0] == 'function':

1685

1686

def func(*args, **kwargs):

1687

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

1688

return self._pipe.recv()[1]

1689

1690

return func

1691

1692

def __setattr__(self, name, value):

1693

if name == '_pipe':

1694

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

1695

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

1696

1697

1698

class ClientHandler(socketserver.BaseRequestHandler, object):

1699

"""A class to handle client connections.

1700

1701

Instantiated once for each connection to handle it.

1702

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

1703

1704

def handle(self):

1705

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

1706

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

1707

str(self.client_address))

1708

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

1709

self.server.child_pipe.fileno())

1710

1711

session = gnutls.connection.ClientSession(

1712

self.request, gnutls.connection .X509Credentials())

1713

1714

# Note: gnutls.connection.X509Credentials is really a

1715

# generic GnuTLS certificate credentials object so long as

1716

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

1717

# here despite using OpenPGP certificates.

1718

1719

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

1720

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

1721

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

1722

# "+DHE-DSS"))

1723

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

1724

priority = self.server.gnutls_priority

1725

if priority is None:

1726

priority = "NORMAL"

1727

gnutls.library.functions.gnutls_priority_set_direct(

1728

session._c_object, priority, None)

1729

1730

# Start communication using the Mandos protocol

1731

# Get protocol number

1732

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

1733

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

1734

try:

1735

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

1736

raise RuntimeError(line)

1737

except (ValueError, IndexError, RuntimeError) as error:

1738

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

1739

return

1740

1741

# Start GnuTLS connection

1742

try:

1743

session.handshake()

1744

except gnutls.errors.GNUTLSError as error:

1745

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

1746

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

1747

# established. Just abandon the request.

1748

return

1749

logger.debug("Handshake succeeded")

1750

1751

approval_required = False

1752

try:

1753

try:

1754

fpr = self.fingerprint(

1755

self.peer_certificate(session))

1756

except (TypeError,

1757

gnutls.errors.GNUTLSError) as error:

1758

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

1759

return

1760

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

1761

1762

try:

1763

client = ProxyClient(child_pipe, fpr,

1764

self.client_address)

1765

except KeyError:

1766

return

1767

1768

if client.approval_delay:

1769

delay = client.approval_delay

1770

client.approvals_pending += 1

1771

approval_required = True

1772

1773

while True:

1774

if not client.enabled:

1775

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

1776

client.name)

1777

if self.server.use_dbus:

1778

# Emit D-Bus signal

1779

client.Rejected("Disabled")

1780

return

1781

1782

if client.approved or not client.approval_delay:

1783

#We are approved or approval is disabled

1784

break

1785

elif client.approved is None:

1786

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

1787

client.name)

1788

if self.server.use_dbus:

1789

# Emit D-Bus signal

1790

client.NeedApproval(

1791

client.approval_delay.total_seconds()

1792

* 1000, client.approved_by_default)

1793

else:

1794

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

1795

client.name)

1796

if self.server.use_dbus:

1797

# Emit D-Bus signal

1798

client.Rejected("Denied")

1799

return

1800

1801

#wait until timeout or approved

1802

time = datetime.datetime.now()

1803

client.changedstate.acquire()

1804

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

1805

client.changedstate.release()

1806

time2 = datetime.datetime.now()

1807

if (time2 - time) >= delay:

1808

if not client.approved_by_default:

1809

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

1810

" waiting for approval",

1811

client.name)

1812

if self.server.use_dbus:

1813

# Emit D-Bus signal

1814

client.Rejected("Approval timed out")

1815

return

1816

else:

1817

break

1818

else:

1819

delay -= time2 - time

1820

1821

sent_size = 0

1822

while sent_size < len(client.secret):

1823

try:

1824

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

1825

except gnutls.errors.GNUTLSError as error:

1826

logger.warning("gnutls send failed",

1827

exc_info=error)

1828

return

1829

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

1830

len(client.secret) - (sent_size

1831

+ sent))

1832

sent_size += sent

1833

1834

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

1835

# bump the timeout using extended_timeout

1836

client.bump_timeout(client.extended_timeout)

1837

if self.server.use_dbus:

1838

# Emit D-Bus signal

1839

client.GotSecret()

1840

1841

finally:

1842

if approval_required:

1843

client.approvals_pending -= 1

1844

try:

1845

session.bye()

1846

except gnutls.errors.GNUTLSError as error:

1847

logger.warning("GnuTLS bye failed",

1848

exc_info=error)

1849

1850

@staticmethod

1851

def peer_certificate(session):

1852

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

1853

# If not an OpenPGP certificate...

1854

if (gnutls.library.functions.gnutls_certificate_type_get(

1855

session._c_object)

1856

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1857

# ...do the normal thing

1858

return session.peer_certificate

1859

list_size = ctypes.c_uint(1)

1860

cert_list = (gnutls.library.functions

1861

.gnutls_certificate_get_peers

1862

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

1863

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

1864

raise gnutls.errors.GNUTLSError("error getting peer"

1865

" certificate")

1866

if list_size.value == 0:

1867

return None

1868

cert = cert_list[0]

1869

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

1870

1871

@staticmethod

1872

def fingerprint(openpgp):

1873

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

1874

# New GnuTLS "datum" with the OpenPGP public key

1875

datum = gnutls.library.types.gnutls_datum_t(

1876

ctypes.cast(ctypes.c_char_p(openpgp),

1877

ctypes.POINTER(ctypes.c_ubyte)),

1878

ctypes.c_uint(len(openpgp)))

1879

# New empty GnuTLS certificate

1880

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1881

gnutls.library.functions.gnutls_openpgp_crt_init(

1882

ctypes.byref(crt))

1883

# Import the OpenPGP public key into the certificate

1884

gnutls.library.functions.gnutls_openpgp_crt_import(

1885

crt, ctypes.byref(datum),

1886

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

1887

# Verify the self signature in the key

1888

crtverify = ctypes.c_uint()

1889

gnutls.library.functions.gnutls_openpgp_crt_verify_self(

1890

crt, 0, ctypes.byref(crtverify))

1891

if crtverify.value != 0:

1892

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1893

raise gnutls.errors.CertificateSecurityError(

1894

"Verify failed")

1895

# New buffer for the fingerprint

1896

buf = ctypes.create_string_buffer(20)

1897

buf_len = ctypes.c_size_t()

1898

# Get the fingerprint from the certificate into the buffer

1899

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(

1900

crt, ctypes.byref(buf), ctypes.byref(buf_len))

1901

# Deinit the certificate

1902

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1903

# Convert the buffer to a Python bytestring

1904

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

1905

# Convert the bytestring to hexadecimal notation

1906

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

1907

return hex_fpr

1908

1909

1910

class MultiprocessingMixIn(object):

1911

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

1912

1913

def sub_process_main(self, request, address):

1914

try:

1915

self.finish_request(request, address)

1916

except Exception:

1917

self.handle_error(request, address)

1918

self.close_request(request)

1919

1920

def process_request(self, request, address):

1921

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

1922

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

1923

args = (request, address))

1924

proc.start()

1925

return proc

1926

1927

1928

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1929

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

1930

1931

def process_request(self, request, client_address):

1932

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

1933

1934

This function creates a new pipe in self.pipe

1935

"""

1936

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1937

1938

proc = MultiprocessingMixIn.process_request(self, request,

1939

client_address)

1940

self.child_pipe.close()

1941

self.add_pipe(parent_pipe, proc)

1942

1943

def add_pipe(self, parent_pipe, proc):

1944

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

1945

raise NotImplementedError()

1946

1947

1948

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1949

socketserver.TCPServer, object):

1950

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

1951

1952

Attributes:

1953

enabled: Boolean; whether this server is activated yet

1954

interface: None or a network interface name (string)

1955

use_ipv6: Boolean; to use IPv6 or not

1956

"""

1957

1958

def __init__(self, server_address, RequestHandlerClass,

1959

interface=None,

1960

use_ipv6=True,

1961

socketfd=None):

1962

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

1963

creating a new one with socket.socket().

1964

"""

1965

self.interface = interface

1966

if use_ipv6:

1967

self.address_family = socket.AF_INET6

1968

if socketfd is not None:

1969

# Save the file descriptor

1970

self.socketfd = socketfd

1971

# Save the original socket.socket() function

1972

self.socket_socket = socket.socket

1973

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

1974

#

1975

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

1976

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

1977

# patching socket.socket.)

1978

#

1979

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

1980

@functools.wraps(socket.socket)

1981

def socket_wrapper(*args, **kwargs):

1982

# Restore original function so subsequent calls are

1983

# not affected.

1984

socket.socket = self.socket_socket

1985

del self.socket_socket

1986

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

1987

# saved file descriptor.

1988

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

1989

# Replace socket.socket() function with wrapper

1990

socket.socket = socket_wrapper

1991

# The socketserver.TCPServer.__init__ will call

1992

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

1993

# socket_wrapper(), if socketfd was set.

1994

socketserver.TCPServer.__init__(self, server_address,

1995

RequestHandlerClass)

1996

1997

def server_bind(self):

1998

"""This overrides the normal server_bind() function

1999

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

2000

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

2001

if self.interface is not None:

2002

if SO_BINDTODEVICE is None:

2003

logger.error("SO_BINDTODEVICE does not exist;"

2004

" cannot bind to interface %s",

2005

self.interface)

2006

else:

2007

try:

2008

self.socket.setsockopt(

2009

socket.SOL_SOCKET, SO_BINDTODEVICE,

2010

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

2011

except socket.error as error:

2012

if error.errno == errno.EPERM:

2013

logger.error("No permission to bind to"

2014

" interface %s", self.interface)

2015

elif error.errno == errno.ENOPROTOOPT:

2016

logger.error("SO_BINDTODEVICE not available;"

2017

" cannot bind to interface %s",

2018

self.interface)

2019

elif error.errno == errno.ENODEV:

2020

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

2021

" cannot bind", self.interface)

2022

else:

2023

raise

2024

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

2025

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

2026

if not self.server_address[0]:

2027

if self.address_family == socket.AF_INET6:

2028

any_address = "::" # in6addr_any

2029

else:

2030

any_address = "0.0.0.0" # INADDR_ANY

2031

self.server_address = (any_address,

2032

self.server_address[1])

2033

elif not self.server_address[1]:

2034

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

2035

# if self.interface:

2036

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

2037

# 0, # port

2038

# 0, # flowinfo

2039

# if_nametoindex

2040

# (self.interface))

2041

return socketserver.TCPServer.server_bind(self)

2042

2043

2044

class MandosServer(IPv6_TCPServer):

2045

"""Mandos server.

2046

2047

Attributes:

2048

clients: set of Client objects

2049

gnutls_priority GnuTLS priority string

2050

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

2051

2052

Assumes a gobject.MainLoop event loop.

2053

"""

2054

2055

def __init__(self, server_address, RequestHandlerClass,

2056

interface=None,

2057

use_ipv6=True,

2058

clients=None,

2059

gnutls_priority=None,

2060

use_dbus=True,

2061

socketfd=None):

2062

self.enabled = False

2063

self.clients = clients

2064

if self.clients is None:

2065

self.clients = {}

2066

self.use_dbus = use_dbus

2067

self.gnutls_priority = gnutls_priority

2068

IPv6_TCPServer.__init__(self, server_address,

2069

RequestHandlerClass,

2070

interface = interface,

2071

use_ipv6 = use_ipv6,

2072

socketfd = socketfd)

2073

2074

def server_activate(self):

2075

if self.enabled:

2076

return socketserver.TCPServer.server_activate(self)

2077

2078

def enable(self):

2079

self.enabled = True

2080

2081

def add_pipe(self, parent_pipe, proc):

2082

# Call "handle_ipc" for both data and EOF events

2083

gobject.io_add_watch(

2084

parent_pipe.fileno(),

2085

gobject.IO_IN | gobject.IO_HUP,

2086

functools.partial(self.handle_ipc,

2087

parent_pipe = parent_pipe,

2088

proc = proc))

2089

2090

def handle_ipc(self, source, condition,

2091

parent_pipe=None,

2092

proc = None,

2093

client_object=None):

2094

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

2095

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

2096

# Wait for other process to exit

2097

proc.join()

2098

return False

2099

2100

# Read a request from the child

2101

request = parent_pipe.recv()

2102

command = request[0]

2103

2104

if command == 'init':

2105

fpr = request[1]

2106

address = request[2]

2107

2108

for c in self.clients.itervalues():

2109

if c.fingerprint == fpr:

2110

client = c

2111

break

2112

else:

2113

logger.info("Client not found for fingerprint: %s, ad"

2114

"dress: %s", fpr, address)

2115

if self.use_dbus:

2116

# Emit D-Bus signal

2117

mandos_dbus_service.ClientNotFound(fpr,

2118

address[0])

2119

parent_pipe.send(False)

2120

return False

2121

2122

gobject.io_add_watch(

2123

parent_pipe.fileno(),

2124

gobject.IO_IN | gobject.IO_HUP,

2125

functools.partial(self.handle_ipc,

2126

parent_pipe = parent_pipe,

2127

proc = proc,

2128

client_object = client))

2129

parent_pipe.send(True)

2130

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

2131

# same fileno

2132

return False

2133

if command == 'funcall':

2134

funcname = request[1]

2135

args = request[2]

2136

kwargs = request[3]

2137

2138

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

2139

funcname)(*args,

2140

**kwargs)))

2141

2142

if command == 'getattr':

2143

attrname = request[1]

2144

if isinstance(client_object.__getattribute__(attrname),

2145

collections.Callable):

2146

parent_pipe.send(('function', ))

2147

else:

2148

parent_pipe.send((

2149

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

2150

2151

if command == 'setattr':

2152

attrname = request[1]

2153

value = request[2]

2154

setattr(client_object, attrname, value)

2155

2156

return True

2157

2158

2159

def rfc3339_duration_to_delta(duration):

2160

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

2161

2162

>>> rfc3339_duration_to_delta("P7D")

2163

datetime.timedelta(7)

2164

>>> rfc3339_duration_to_delta("PT60S")

2165

datetime.timedelta(0, 60)

2166

>>> rfc3339_duration_to_delta("PT60M")

2167

datetime.timedelta(0, 3600)

2168

>>> rfc3339_duration_to_delta("PT24H")

2169

datetime.timedelta(1)

2170

>>> rfc3339_duration_to_delta("P1W")

2171

datetime.timedelta(7)

2172

>>> rfc3339_duration_to_delta("PT5M30S")

2173

datetime.timedelta(0, 330)

2174

>>> rfc3339_duration_to_delta("P1DT3M20S")

2175

datetime.timedelta(1, 200)

2176

"""

2177

2178

# Parsing an RFC 3339 duration with regular expressions is not

2179

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

2180

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

2181

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

2182

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

2183

# avoid excessive use of external libraries.

2184

2185

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

2186

Token = collections.namedtuple("Token", (

2187

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

2188

# a "group" containing digits

2189

"value", # datetime.timedelta or None

2190

"followers")) # Tokens valid after this token

2191

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

2192

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

2193

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

2194

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

2195

datetime.timedelta(seconds=1),

2196

frozenset((token_end, )))

2197

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

2198

datetime.timedelta(minutes=1),

2199

frozenset((token_second, token_end)))

2200

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

2201

datetime.timedelta(hours=1),

2202

frozenset((token_minute, token_end)))

2203

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

2204

None,

2205

frozenset((token_hour, token_minute,

2206

token_second)))

2207

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

2208

datetime.timedelta(days=1),

2209

frozenset((token_time, token_end)))

2210

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

2211

datetime.timedelta(weeks=4),

2212

frozenset((token_day, token_end)))

2213

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

2214

datetime.timedelta(weeks=52),

2215

frozenset((token_month, token_end)))

2216

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

2217

datetime.timedelta(weeks=1),

2218

frozenset((token_end, )))

2219

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

2220

frozenset((token_year, token_month,

2221

token_day, token_time,

2222

token_week)))

2223

# Define starting values

2224

value = datetime.timedelta() # Value so far

2225

found_token = None

2226

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

2227

s = duration # String left to parse

2228

# Loop until end token is found

2229

while found_token is not token_end:

2230

# Search for any currently valid tokens

2231

for token in followers:

2232

match = token.regexp.match(s)

2233

if match is not None:

2234

# Token found

2235

if token.value is not None:

2236

# Value found, parse digits

2237

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

2238

# Add to value so far

2239

value += factor * token.value

2240

# Strip token from string

2241

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

2242

# Go to found token

2243

found_token = token

2244

# Set valid next tokens

2245

followers = found_token.followers

2246

break

2247

else:

2248

# No currently valid tokens were found

2249

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

2250

.format(duration))

2251

# End token found

2252

return value

2253

2254

2255

def string_to_delta(interval):

2256

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

2257

2258

>>> string_to_delta('7d')

2259

datetime.timedelta(7)

2260

>>> string_to_delta('60s')

2261

datetime.timedelta(0, 60)

2262

>>> string_to_delta('60m')

2263

datetime.timedelta(0, 3600)

2264

>>> string_to_delta('24h')

2265

datetime.timedelta(1)

2266

>>> string_to_delta('1w')

2267

datetime.timedelta(7)

2268

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

2269

datetime.timedelta(0, 330)

2270

"""

2271

2272

try:

2273

return rfc3339_duration_to_delta(interval)

2274

except ValueError:

2275

pass

2276

2277

timevalue = datetime.timedelta(0)

2278

for s in interval.split():

2279

try:

2280

suffix = s[-1]

2281

value = int(s[:-1])

2282

if suffix == "d":

2283

delta = datetime.timedelta(value)

2284

elif suffix == "s":

2285

delta = datetime.timedelta(0, value)

2286

elif suffix == "m":

2287

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

2288

elif suffix == "h":

2289

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

2290

elif suffix == "w":

2291

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

2292

else:

2293

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

2294

except IndexError as e:

2295

raise ValueError(*(e.args))

2296

timevalue += delta

2297

return timevalue

2298

2299

2300

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

2301

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

2302

2303

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

2304

if os.fork():

2305

sys.exit()

2306

os.setsid()

2307

if not nochdir:

2308

os.chdir("/")

2309

if os.fork():

2310

sys.exit()

2311

if not noclose:

2312

# Close all standard open file descriptors

2313

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

2314

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

2315

raise OSError(errno.ENODEV,

2316

"{} not a character device"

2317

.format(os.devnull))

2318

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

2319

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

2320

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

2321

if null > 2:

2322

os.close(null)

2323

2324

2325

def main():

2326

2327

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

2328

# Parsing of options, both command line and config file

2329

2330

parser = argparse.ArgumentParser()

2331

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

2332

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

2333

help="show version number and exit")

2334

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

2335

help="Bind to interface IF")

2336

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

2337

help="Address to listen for requests on")

2338

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

2339

help="Port number to receive requests on")

2340

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

2341

help="Run self-test")

2342

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

2343

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

2344

" to terminal", default=None)

2345

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

2346

help="Debug level for stdout output")

2347

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

2348

" priority string (see GnuTLS documentation)")

2349

parser.add_argument("--servicename",

2350

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

2351

parser.add_argument("--configdir",

2352

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

2353

help="Directory to search for configuration"

2354

" files")

2355

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

2356

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

2357

" system bus interface", default=None)

2358

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

2359

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

2360

default=None)

2361

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

2362

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

2363

" state", default=None)

2364

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

2365

help="Specify a file descriptor to a network"

2366

" socket to use instead of creating one")

2367

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

2368

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

2369

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

2370

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

2371

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

2372

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

2373

default=None)

2374

2375

options = parser.parse_args()

2376

2377

if options.check:

2378

import doctest

2379

fail_count, test_count = doctest.testmod()

2380

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

2381

2382

# Default values for config file for server-global settings

2383

server_defaults = { "interface": "",

2384

"address": "",

2385

"port": "",

2386

"debug": "False",

2387

"priority":

2388

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

2389

":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

2390

"servicename": "Mandos",

2391

"use_dbus": "True",

2392

"use_ipv6": "True",

2393

"debuglevel": "",

2394

"restore": "True",

2395

"socket": "",

2396

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

2397

"foreground": "False",

2398

"zeroconf": "True",

2399

}

2400

2401

# Parse config file for server-global settings

2402

server_config = configparser.SafeConfigParser(server_defaults)

2403

del server_defaults

2404

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

2405

# Convert the SafeConfigParser object to a dict

2406

server_settings = server_config.defaults()

2407

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

2408

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

2409

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

2410

option)

2411

if server_settings["port"]:

2412

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

2413

"port")

2414

if server_settings["socket"]:

2415

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

2416

"socket")

2417

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

2418

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

2419

# happen with a supplied network socket.

2420

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

2421

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

2422

["socket"])

2423

del server_config

2424

2425

# Override the settings from the config file with command line

2426

# options, if set.

2427

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

2428

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

2429

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

2430

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

2431

value = getattr(options, option)

2432

if value is not None:

2433

server_settings[option] = value

2434

del options

2435

# Force all strings to be unicode

2436

for option in server_settings.keys():

2437

if isinstance(server_settings[option], bytes):

2438

server_settings[option] = (server_settings[option]

2439

.decode("utf-8"))

2440

# Force all boolean options to be boolean

2441

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

2442

"foreground", "zeroconf"):

2443

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

2444

# Debug implies foreground

2445

if server_settings["debug"]:

2446

server_settings["foreground"] = True

2447

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

2448

2449

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

2450

2451

if (not server_settings["zeroconf"]

2452

and not (server_settings["port"]

2453

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

2454

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

2455

2456

# For convenience

2457

debug = server_settings["debug"]

2458

debuglevel = server_settings["debuglevel"]

2459

use_dbus = server_settings["use_dbus"]

2460

use_ipv6 = server_settings["use_ipv6"]

2461

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

2462

stored_state_file)

2463

foreground = server_settings["foreground"]

2464

zeroconf = server_settings["zeroconf"]

2465

2466

if debug:

2467

initlogger(debug, logging.DEBUG)

2468

else:

2469

if not debuglevel:

2470

initlogger(debug)

2471

else:

2472

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

2473

initlogger(debug, level)

2474

2475

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

2476

syslogger.setFormatter(

2477

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

2478

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

2479

server_settings["servicename"])))

2480

2481

# Parse config file with clients

2482

client_config = configparser.SafeConfigParser(Client

2483

.client_defaults)

2484

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

2485

"clients.conf"))

2486

2487

global mandos_dbus_service

2488

mandos_dbus_service = None

2489

2490

socketfd = None

2491

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

2492

socketfd = server_settings["socket"]

2493

tcp_server = MandosServer(

2494

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

2495

ClientHandler,

2496

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

2497

use_ipv6=use_ipv6,

2498

gnutls_priority=server_settings["priority"],

2499

use_dbus=use_dbus,

2500

socketfd=socketfd)

2501

if not foreground:

2502

pidfilename = "/run/mandos.pid"

2503

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

2504

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

2505

pidfile = None

2506

try:

2507

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

2508

except IOError as e:

2509

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

2510

exc_info=e)

2511

2512

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

2513

try:

2514

uid = pwd.getpwnam(name).pw_uid

2515

gid = pwd.getpwnam(name).pw_gid

2516

break

2517

except KeyError:

2518

continue

2519

else:

2520

uid = 65534

2521

gid = 65534

2522

try:

2523

os.setgid(gid)

2524

os.setuid(uid)

2525

except OSError as error:

2526

if error.errno != errno.EPERM:

2527

raise

2528

2529

if debug:

2530

# Enable all possible GnuTLS debugging

2531

2532

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

2533

# - GnuTLS manual

2534

gnutls.library.functions.gnutls_global_set_log_level(11)

2535

2536

@gnutls.library.types.gnutls_log_func

2537

def debug_gnutls(level, string):

2538

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

2539

2540

gnutls.library.functions.gnutls_global_set_log_function(

2541

debug_gnutls)

2542

2543

# Redirect stdin so all checkers get /dev/null

2544

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

2545

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

2546

if null > 2:

2547

os.close(null)

2548

2549

# Need to fork before connecting to D-Bus

2550

if not foreground:

2551

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

2552

daemon()

2553

2554

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

2555

# need to inform gobject that threads will be used.

2556

gobject.threads_init()

2557

2558

global main_loop

2559

# From the Avahi example code

2560

DBusGMainLoop(set_as_default=True)

2561

main_loop = gobject.MainLoop()

2562

bus = dbus.SystemBus()

2563

# End of Avahi example code

2564

if use_dbus:

2565

try:

2566

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

2567

bus,

2568

do_not_queue=True)

2569

old_bus_name = dbus.service.BusName(

2570

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

2571

do_not_queue=True)

2572

except dbus.exceptions.DBusException as e:

2573

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

2574

use_dbus = False

2575

server_settings["use_dbus"] = False

2576

tcp_server.use_dbus = False

2577

if zeroconf:

2578

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2579

service = AvahiServiceToSyslog(

2580

name = server_settings["servicename"],

2581

servicetype = "_mandos._tcp",

2582

protocol = protocol,

2583

bus = bus)

2584

if server_settings["interface"]:

2585

service.interface = if_nametoindex(

2586

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

2587

2588

global multiprocessing_manager

2589

multiprocessing_manager = multiprocessing.Manager()

2590

2591

client_class = Client

2592

if use_dbus:

2593

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

2594

2595

client_settings = Client.config_parser(client_config)

2596

old_client_settings = {}

2597

clients_data = {}

2598

2599

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

2600

global wnull

2601

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

2602

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

2603

# mode

2604

if debug or not foreground:

2605

wnull.close()

2606

2607

# Get client data and settings from last running state.

2608

if server_settings["restore"]:

2609

try:

2610

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

2611

clients_data, old_client_settings = pickle.load(

2612

stored_state)

2613

os.remove(stored_state_path)

2614

except IOError as e:

2615

if e.errno == errno.ENOENT:

2616

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

2617

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

2618

else:

2619

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

2620

exc_info=e)

2621

raise

2622

except EOFError as e:

2623

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

2624

"EOFError:",

2625

exc_info=e)

2626

2627

with PGPEngine() as pgp:

2628

for client_name, client in clients_data.items():

2629

# Skip removed clients

2630

if client_name not in client_settings:

2631

continue

2632

2633

# Decide which value to use after restoring saved state.

2634

# We have three different values: Old config file,

2635

# new config file, and saved state.

2636

# New config value takes precedence if it differs from old

2637

# config value, otherwise use saved state.

2638

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

2639

try:

2640

# For each value in new config, check if it

2641

# differs from the old config value (Except for

2642

# the "secret" attribute)

2643

if (name != "secret"

2644

and (value !=

2645

old_client_settings[client_name][name])):

2646

client[name] = value

2647

except KeyError:

2648

pass

2649

2650

# Clients who has passed its expire date can still be

2651

# enabled if its last checker was successful. A Client

2652

# whose checker succeeded before we stored its state is

2653

# assumed to have successfully run all checkers during

2654

# downtime.

2655

if client["enabled"]:

2656

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

2657

if not client["last_checked_ok"]:

2658

logger.warning(

2659

"disabling client {} - Client never "

2660

"performed a successful checker".format(

2661

client_name))

2662

client["enabled"] = False

2663

elif client["last_checker_status"] != 0:

2664

logger.warning(

2665

"disabling client {} - Client last"

2666

" checker failed with error code"

2667

" {}".format(

2668

client_name,

2669

client["last_checker_status"]))

2670

client["enabled"] = False

2671

else:

2672

client["expires"] = (

2673

datetime.datetime.utcnow()

2674

+ client["timeout"])

2675

logger.debug("Last checker succeeded,"

2676

" keeping {} enabled".format(

2677

client_name))

2678

try:

2679

client["secret"] = pgp.decrypt(

2680

client["encrypted_secret"],

2681

client_settings[client_name]["secret"])

2682

except PGPError:

2683

# If decryption fails, we use secret from new settings

2684

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

2685

client_name))

2686

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

2687

["secret"])

2688

2689

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

2690

for client_name in (set(old_client_settings)

2691

- set(client_settings)):

2692

del clients_data[client_name]

2693

for client_name in (set(client_settings)

2694

- set(old_client_settings)):

2695

clients_data[client_name] = client_settings[client_name]

2696

2697

# Create all client objects

2698

for client_name, client in clients_data.items():

2699

tcp_server.clients[client_name] = client_class(

2700

name = client_name,

2701

settings = client,

2702

server_settings = server_settings)

2703

2704

if not tcp_server.clients:

2705

logger.warning("No clients defined")

2706

2707

if not foreground:

2708

if pidfile is not None:

2709

pid = os.getpid()

2710

try:

2711

with pidfile:

2712

print(pid, file=pidfile)

2713

except IOError:

2714

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

2715

pidfilename, pid)

2716

del pidfile

2717

del pidfilename

2718

2719

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

2720

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

2721

2722

if use_dbus:

2723

2724

@alternate_dbus_interfaces(

2725

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

2726

class MandosDBusService(DBusObjectWithProperties):

2727

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

2728

2729

def __init__(self):

2730

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

2731

2732

_interface = "se.recompile.Mandos"

2733

2734

@dbus_interface_annotations(_interface)

2735

def _foo(self):

2736

return {

2737

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

2738

"false" }

2739

2740

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

2741

def ClientAdded(self, objpath):

2742

"D-Bus signal"

2743

pass

2744

2745

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

2746

def ClientNotFound(self, fingerprint, address):

2747

"D-Bus signal"

2748

pass

2749

2750

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

2751

def ClientRemoved(self, objpath, name):

2752

"D-Bus signal"

2753

pass

2754

2755

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

2756

def GetAllClients(self):

2757

"D-Bus method"

2758

return dbus.Array(c.dbus_object_path for c in

2759

tcp_server.clients.itervalues())

2760

2761

@dbus.service.method(_interface,

2762

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

2763

def GetAllClientsWithProperties(self):

2764

"D-Bus method"

2765

return dbus.Dictionary(

2766

{ c.dbus_object_path: c.GetAll("")

2767

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

2768

signature="oa{sv}")

2769

2770

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

2771

def RemoveClient(self, object_path):

2772

"D-Bus method"

2773

for c in tcp_server.clients.itervalues():

2774

if c.dbus_object_path == object_path:

2775

del tcp_server.clients[c.name]

2776

c.remove_from_connection()

2777

# Don't signal anything except ClientRemoved

2778

c.disable(quiet=True)

2779

# Emit D-Bus signal

2780

self.ClientRemoved(object_path, c.name)

2781

return

2782

raise KeyError(object_path)

2783

2784

del _interface

2785

2786

mandos_dbus_service = MandosDBusService()

2787

2788

def cleanup():

2789

"Cleanup function; run on exit"

2790

if zeroconf:

2791

service.cleanup()

2792

2793

multiprocessing.active_children()

2794

wnull.close()

2795

if not (tcp_server.clients or client_settings):

2796

return

2797

2798

# Store client before exiting. Secrets are encrypted with key

2799

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

2800

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

2801

clients = {}

2802

with PGPEngine() as pgp:

2803

for client in tcp_server.clients.itervalues():

2804

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

2805

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

2806

key)

2807

client_dict = {}

2808

2809

# A list of attributes that can not be pickled

2810

# + secret.

2811

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

2812

"checker", "server_settings" }

2813

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

2814

.Object):

2815

exclude.add(name)

2816

2817

client_dict["encrypted_secret"] = (client

2818

.encrypted_secret)

2819

for attr in client.client_structure:

2820

if attr not in exclude:

2821

client_dict[attr] = getattr(client, attr)

2822

2823

clients[client.name] = client_dict

2824

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

2825

2826

try:

2827

with tempfile.NamedTemporaryFile(

2828

mode='wb',

2829

suffix=".pickle",

2830

prefix='clients-',

2831

dir=os.path.dirname(stored_state_path),

2832

delete=False) as stored_state:

2833

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

2834

tempname = stored_state.name

2835

os.rename(tempname, stored_state_path)

2836

except (IOError, OSError) as e:

2837

if not debug:

2838

try:

2839

os.remove(tempname)

2840

except NameError:

2841

pass

2842

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

2843

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

2844

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

2845

else:

2846

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

2847

exc_info=e)

2848

raise

2849

2850

# Delete all clients, and settings from config

2851

while tcp_server.clients:

2852

name, client = tcp_server.clients.popitem()

2853

if use_dbus:

2854

client.remove_from_connection()

2855

# Don't signal anything except ClientRemoved

2856

client.disable(quiet=True)

2857

if use_dbus:

2858

# Emit D-Bus signal

2859

mandos_dbus_service.ClientRemoved(

2860

client.dbus_object_path, client.name)

2861

client_settings.clear()

2862

2863

atexit.register(cleanup)

2864

2865

for client in tcp_server.clients.itervalues():

2866

if use_dbus:

2867

# Emit D-Bus signal

2868

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2869

# Need to initiate checking of clients

2870

if client.enabled:

2871

client.init_checker()

2872

2873

tcp_server.enable()

2874

tcp_server.server_activate()

2875

2876

# Find out what port we got

2877

if zeroconf:

2878

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

2879

if use_ipv6:

2880

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

2881

" flowinfo %d, scope_id %d",

2882

*tcp_server.socket.getsockname())

2883

else: # IPv4

2884

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

2885

*tcp_server.socket.getsockname())

2886

2887

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

2888

2889

try:

2890

if zeroconf:

2891

# From the Avahi example code

2892

try:

2893

service.activate()

2894

except dbus.exceptions.DBusException as error:

2895

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

2896

cleanup()

2897

sys.exit(1)

2898

# End of Avahi example code

2899

2900

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

2901

lambda *args, **kwargs:

2902

(tcp_server.handle_request

2903

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

2904

2905

logger.debug("Starting main loop")

2906

main_loop.run()

2907

except AvahiError as error:

2908

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

2909

cleanup()

2910

sys.exit(1)

2911

except KeyboardInterrupt:

2912

if debug:

2913

print("", file=sys.stderr)

2914

logger.debug("Server received KeyboardInterrupt")

2915

logger.debug("Server exiting")

2916

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

2917

cleanup()

2918

2919

2920

if __name__ == '__main__':

2921

main()