/mandos/trunk : revision 749.1.1

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

2

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

3

#

4

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

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

import SocketServer as socketserver

37

from future_builtins import *

38

39

try:

40

import SocketServer as socketserver

41

except ImportError:

42

import socketserver

38

43

import socket

39

44

import argparse

40

45

import datetime

45

50

import gnutls.library.functions

46

51

import gnutls.library.constants

47

52

import gnutls.library.types

48

import ConfigParser as configparser

53

try:

54

import ConfigParser as configparser

55

except ImportError:

56

import configparser

49

57

import sys

50

58

import re

51

59

import os

60

68

import struct

61

69

import fcntl

62

70

import functools

63

import cPickle as pickle

71

try:

72

import cPickle as pickle

73

except ImportError:

74

import pickle

64

75

import multiprocessing

65

76

import types

66

77

import binascii

67

78

import tempfile

79

import itertools

80

import collections

68

81

69

82

import dbus

70

83

import dbus.service

71

import gobject

84

try:

85

import gobject

86

except ImportError:

87

from gi.repository import GObject as gobject

72

88

import avahi

73

89

from dbus.mainloop.glib import DBusGMainLoop

74

90

import ctypes

75

91

import ctypes.util

76

92

import xml.dom.minidom

77

93

import inspect

78

import GnuPGInterface

79

94

80

95

try:

81

96

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

85

100

except ImportError:

86

101

SO_BINDTODEVICE = None

87

102

88

version = "1.5.3"

103

if sys.version_info.major == 2:

104

str = unicode

105

106

version = "1.6.9"

89

107

stored_state_file = "clients.pickle"

90

108

91

109

logger = logging.getLogger()

92

syslogger = (logging.handlers.SysLogHandler

93

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

94

address = str("/dev/log")))

110

syslogger = None

95

111

96

112

try:

97

if_nametoindex = (ctypes.cdll.LoadLibrary

98

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

99

.if_nametoindex)

113

if_nametoindex = ctypes.cdll.LoadLibrary(

114

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

100

115

except (OSError, AttributeError):

116

101

117

def if_nametoindex(interface):

102

118

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

103

119

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

104

120

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

105

121

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

106

struct.pack(str("16s16x"),

107

interface))

108

interface_index = struct.unpack(str("I"),

109

ifreq[16:20])[0]

122

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

123

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

110

124

return interface_index

111

125

112

126

113

127

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

114

128

"""init logger and add loglevel"""

115

129

130

global syslogger

131

syslogger = (logging.handlers.SysLogHandler(

132

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

133

address = "/dev/log"))

116

134

syslogger.setFormatter(logging.Formatter

117

135

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

118

136

' %(message)s'))

135

153

136

154

class PGPEngine(object):

137

155

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

156

138

157

def __init__(self):

139

self.gnupg = GnuPGInterface.GnuPG()

140

158

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

141

self.gnupg = GnuPGInterface.GnuPG()

142

self.gnupg.options.meta_interactive = False

143

self.gnupg.options.homedir = self.tempdir

144

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

145

'--quiet',

146

'--no-use-agent'])

159

self.gnupgargs = ['--batch',

160

'--home', self.tempdir,

161

'--force-mdc',

162

'--quiet',

163

'--no-use-agent']

147

164

148

165

def __enter__(self):

149

166

return self

150

167

151

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

168

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

152

169

self._cleanup()

153

170

return False

154

171

188

def password_encode(self, password):

172

189

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

173

190

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

174

return b"mandos" + binascii.hexlify(password)

191

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

192

if len(encoded) > 2048:

193

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

194

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

195

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

196

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

197

return encoded

175

198

176

199

def encrypt(self, data, password):

177

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

178

with open(os.devnull) as devnull:

179

try:

180

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

181

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

182

attach_fhs={'stderr': devnull})

183

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

184

f.write(data)

185

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

186

ciphertext = f.read()

187

proc.wait()

188

except IOError as e:

189

raise PGPError(e)

190

self.gnupg.passphrase = None

200

passphrase = self.password_encode(password)

201

with tempfile.NamedTemporaryFile(

202

dir=self.tempdir) as passfile:

203

passfile.write(passphrase)

204

passfile.flush()

205

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

206

'--passphrase-file',

207

passfile.name]

208

+ self.gnupgargs,

209

stdin = subprocess.PIPE,

210

stdout = subprocess.PIPE,

211

stderr = subprocess.PIPE)

212

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

213

if proc.returncode != 0:

214

raise PGPError(err)

191

215

return ciphertext

192

216

193

217

def decrypt(self, data, password):

194

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

195

with open(os.devnull) as devnull:

196

try:

197

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

198

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

199

attach_fhs={'stderr': devnull})

200

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

201

f.write(data)

202

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

203

decrypted_plaintext = f.read()

204

proc.wait()

205

except IOError as e:

206

raise PGPError(e)

207

self.gnupg.passphrase = None

218

passphrase = self.password_encode(password)

219

with tempfile.NamedTemporaryFile(

220

dir = self.tempdir) as passfile:

221

passfile.write(passphrase)

222

passfile.flush()

223

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

224

'--passphrase-file',

225

passfile.name]

226

+ self.gnupgargs,

227

stdin = subprocess.PIPE,

228

stdout = subprocess.PIPE,

229

stderr = subprocess.PIPE)

230

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

231

if proc.returncode != 0:

232

raise PGPError(err)

208

233

return decrypted_plaintext

209

234

210

235

211

212

236

class AvahiError(Exception):

213

237

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

214

238

self.value = value

215

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

216

def __unicode__(self):

217

return unicode(repr(self.value))

239

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

240

**kwargs)

241

218

242

219

243

class AvahiServiceError(AvahiError):

220

244

pass

221

245

246

222

247

class AvahiGroupError(AvahiError):

223

248

pass

224

249

231

256

Used to optionally bind to the specified interface.

232

257

name: string; Example: 'Mandos'

233

258

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

234

See <http://www.dns-sd.org/ServiceTypes.html>

259

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

235

260

port: integer; what port to announce

236

261

TXT: list of strings; TXT record for the service

237

262

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

243

268

server: D-Bus Server

244

269

bus: dbus.SystemBus()

245

270

"""

246

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

247

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

248

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

249

protocol = avahi.PROTO_UNSPEC, bus = None):

271

272

def __init__(self,

273

interface = avahi.IF_UNSPEC,

274

name = None,

275

servicetype = None,

276

port = None,

277

TXT = None,

278

domain = "",

279

host = "",

280

max_renames = 32768,

281

protocol = avahi.PROTO_UNSPEC,

282

bus = None):

250

283

self.interface = interface

251

284

self.name = name

252

285

self.type = servicetype

261

294

self.server = None

262

295

self.bus = bus

263

296

self.entry_group_state_changed_match = None

264

def rename(self):

297

298

def rename(self, remove=True):

265

299

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

266

300

if self.rename_count >= self.max_renames:

267

301

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

268

302

" after %i retries, exiting.",

269

303

self.rename_count)

270

304

raise AvahiServiceError("Too many renames")

271

self.name = unicode(self.server

272

.GetAlternativeServiceName(self.name))

305

self.name = str(

306

self.server.GetAlternativeServiceName(self.name))

307

self.rename_count += 1

273

308

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

274

309

self.name)

275

self.remove()

310

if remove:

311

self.remove()

276

312

try:

277

313

self.add()

278

314

except dbus.exceptions.DBusException as error:

279

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

280

self.cleanup()

281

os._exit(1)

282

self.rename_count += 1

315

if (error.get_dbus_name()

316

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

317

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

318

return self.rename(remove=False)

319

else:

320

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

321

self.cleanup()

322

os._exit(1)

323

283

324

def remove(self):

284

325

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

285

326

if self.entry_group_state_changed_match is not None:

287

328

self.entry_group_state_changed_match = None

288

329

if self.group is not None:

289

330

self.group.Reset()

331

290

332

def add(self):

291

333

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

292

334

self.remove()

309

351

dbus.UInt16(self.port),

310

352

avahi.string_array_to_txt_array(self.TXT))

311

353

self.group.Commit()

354

312

355

def entry_group_state_changed(self, state, error):

313

356

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

314

357

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

320

363

self.rename()

321

364

elif state == avahi.ENTRY_GROUP_FAILURE:

322

365

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

323

unicode(error))

324

raise AvahiGroupError("State changed: %s"

325

% unicode(error))

366

str(error))

367

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

368

326

369

def cleanup(self):

327

370

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

328

371

if self.group is not None:

333

376

pass

334

377

self.group = None

335

378

self.remove()

379

336

380

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

337

381

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

338

382

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

339

bad_states = { avahi.SERVER_INVALID:

340

"Zeroconf server invalid",

341

avahi.SERVER_REGISTERING: None,

342

avahi.SERVER_COLLISION:

343

"Zeroconf server name collision",

344

avahi.SERVER_FAILURE:

345

"Zeroconf server failure" }

383

bad_states = {

384

avahi.SERVER_INVALID: "Zeroconf server invalid",

385

avahi.SERVER_REGISTERING: None,

386

avahi.SERVER_COLLISION: "Zeroconf server name collision",

387

avahi.SERVER_FAILURE: "Zeroconf server failure",

388

}

346

389

if state in bad_states:

347

390

if bad_states[state] is not None:

348

391

if error is None:

357

400

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

358

401

else:

359

402

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

403

360

404

def activate(self):

361

405

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

362

406

if self.server is None:

366

410

follow_name_owner_changes=True),

367

411

avahi.DBUS_INTERFACE_SERVER)

368

412

self.server.connect_to_signal("StateChanged",

369

self.server_state_changed)

413

self.server_state_changed)

370

414

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

371

415

416

372

417

class AvahiServiceToSyslog(AvahiService):

373

def rename(self):

418

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

374

419

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

375

ret = AvahiService.rename(self)

376

syslogger.setFormatter(logging.Formatter

377

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

378

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

379

% self.name))

420

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

421

syslogger.setFormatter(logging.Formatter(

422

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

423

.format(self.name)))

380

424

return ret

381

425

382

def timedelta_to_milliseconds(td):

383

"Convert a datetime.timedelta() to milliseconds"

384

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

385

+ (td.seconds * 1000)

386

+ (td.microseconds // 1000))

387

426

def subprocess_call_pipe(connection, # : multiprocessing.Connection

427

*args, **kwargs):

428

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

429

430

This function runs a synchronous subprocess.call(), and writes the

431

resulting return code on the provided multiprocessing.Connection.

432

"""

433

connection.send(subprocess.call(*args, **kwargs))

434

connection.close()

435

388

436

class Client(object):

389

437

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

390

438

416

464

last_checker_status: integer between 0 and 255 reflecting exit

417

465

status of last checker. -1 reflects crashed

418

466

checker, -2 means no checker completed yet.

467

last_checker_signal: The signal which killed the last checker, if

468

last_checker_status is -1

419

469

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

420

470

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

421

471

D-Bus identifiers

426

476

runtime_expansions: Allowed attributes for runtime expansion.

427

477

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

428

478

disabled, or None

479

server_settings: The server_settings dict from main()

429

480

"""

430

481

431

482

runtime_expansions = ("approval_delay", "approval_duration",

432

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

433

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

483

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

484

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

485

"last_approval_request", "last_checked_ok",

434

486

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

435

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

436

"extended_timeout": "15m",

437

"interval": "2m",

438

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

439

"host": "",

440

"approval_delay": "0s",

441

"approval_duration": "1s",

442

"approved_by_default": "True",

443

"enabled": "True",

444

}

445

446

def timeout_milliseconds(self):

447

"Return the 'timeout' attribute in milliseconds"

448

return timedelta_to_milliseconds(self.timeout)

449

450

def extended_timeout_milliseconds(self):

451

"Return the 'extended_timeout' attribute in milliseconds"

452

return timedelta_to_milliseconds(self.extended_timeout)

453

454

def interval_milliseconds(self):

455

"Return the 'interval' attribute in milliseconds"

456

return timedelta_to_milliseconds(self.interval)

457

458

def approval_delay_milliseconds(self):

459

return timedelta_to_milliseconds(self.approval_delay)

460

487

client_defaults = {

488

"timeout": "PT5M",

489

"extended_timeout": "PT15M",

490

"interval": "PT2M",

491

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

492

"host": "",

493

"approval_delay": "PT0S",

494

"approval_duration": "PT1S",

495

"approved_by_default": "True",

496

"enabled": "True",

497

}

498

461

499

@staticmethod

462

500

def config_parser(config):

463

501

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

478

516

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

479

517

"enabled")

480

518

519

# Uppercase and remove spaces from fingerprint for later

520

# comparison purposes with return value from the

521

# fingerprint() function

481

522

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

482

523

.replace(" ", ""))

483

524

if "secret" in section:

488

529

"rb") as secfile:

489

530

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

490

531

else:

491

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

492

% section)

532

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

533

.format(section))

493

534

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

494

535

client["extended_timeout"] = string_to_delta(

495

536

section["extended_timeout"])

504

545

client["last_checker_status"] = -2

505

546

506

547

return settings

507

508

509

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

510

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

511

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

512

attribute."""

548

549

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

513

550

self.name = name

551

if server_settings is None:

552

server_settings = {}

553

self.server_settings = server_settings

514

554

# adding all client settings

515

for setting, value in settings.iteritems():

555

for setting, value in settings.items():

516

556

setattr(self, setting, value)

517

557

518

558

if self.enabled:

524

564

else:

525

565

self.last_enabled = None

526

566

self.expires = None

527

567

528

568

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

529

# Uppercase and remove spaces from fingerprint for later

530

# comparison purposes with return value from the fingerprint()

531

# function

532

569

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

533

570

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

534

571

datetime.datetime.utcnow())

535

572

536

573

# attributes specific for this server instance

537

574

self.checker = None

538

575

self.checker_initiator_tag = None

541

578

self.current_checker_command = None

542

579

self.approved = None

543

580

self.approvals_pending = 0

544

self.changedstate = (multiprocessing_manager

545

.Condition(multiprocessing_manager

546

.Lock()))

547

self.client_structure = [attr for attr in

548

self.__dict__.iterkeys()

581

self.changedstate = multiprocessing_manager.Condition(

582

multiprocessing_manager.Lock())

583

self.client_structure = [attr

584

for attr in self.__dict__.iterkeys()

549

585

if not attr.startswith("_")]

550

586

self.client_structure.append("client_structure")

551

587

552

for name, t in inspect.getmembers(type(self),

553

lambda obj:

554

isinstance(obj,

555

property)):

588

for name, t in inspect.getmembers(

589

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

556

590

if not name.startswith("_"):

557

591

self.client_structure.append(name)

558

592

566

600

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

567

601

# Already enabled

568

602

return

569

self.send_changedstate()

570

603

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

571

604

self.enabled = True

572

605

self.last_enabled = datetime.datetime.utcnow()

573

606

self.init_checker()

607

self.send_changedstate()

574

608

575

609

def disable(self, quiet=True):

576

610

"""Disable this client."""

577

611

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

578

612

return False

579

613

if not quiet:

580

self.send_changedstate()

581

if not quiet:

582

614

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

583

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

615

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

584

616

gobject.source_remove(self.disable_initiator_tag)

585

617

self.disable_initiator_tag = None

586

618

self.expires = None

587

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

619

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

588

620

gobject.source_remove(self.checker_initiator_tag)

589

621

self.checker_initiator_tag = None

590

622

self.stop_checker()

591

623

self.enabled = False

624

if not quiet:

625

self.send_changedstate()

592

626

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

593

627

return False

594

628

598

632

def init_checker(self):

599

633

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

600

634

# and every interval from then on.

601

self.checker_initiator_tag = (gobject.timeout_add

602

(self.interval_milliseconds(),

603

self.start_checker))

635

if self.checker_initiator_tag is not None:

636

gobject.source_remove(self.checker_initiator_tag)

637

self.checker_initiator_tag = gobject.timeout_add(

638

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

639

self.start_checker)

604

640

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

605

self.disable_initiator_tag = (gobject.timeout_add

606

(self.timeout_milliseconds(),

607

self.disable))

641

if self.disable_initiator_tag is not None:

642

gobject.source_remove(self.disable_initiator_tag)

643

self.disable_initiator_tag = gobject.timeout_add(

644

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

608

645

# Also start a new checker *right now*.

609

646

self.start_checker()

610

647

611

def checker_callback(self, pid, condition, command):

648

def checker_callback(self, source, condition,

649

(connection, command)):

612

650

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

613

651

self.checker_callback_tag = None

614

652

self.checker = None

615

if os.WIFEXITED(condition):

616

self.last_checker_status = os.WEXITSTATUS(condition)

653

# Read return code from connection (see subprocess_call_pipe)

654

returncode = connection.recv()

655

connection.close()

656

657

if returncode >= 0:

658

self.last_checker_status = returncode

659

self.last_checker_signal = None

617

660

if self.last_checker_status == 0:

618

661

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

619

662

vars(self))

620

663

self.checked_ok()

621

664

else:

622

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

623

vars(self))

665

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

624

666

else:

625

667

self.last_checker_status = -1

668

self.last_checker_signal = -returncode

626

669

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

627

670

vars(self))

671

return False

628

672

629

673

def checked_ok(self):

630

674

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

631

675

self.last_checked_ok = datetime.datetime.utcnow()

632

676

self.last_checker_status = 0

677

self.last_checker_signal = None

633

678

self.bump_timeout()

634

679

635

680

def bump_timeout(self, timeout=None):

638

683

timeout = self.timeout

639

684

if self.disable_initiator_tag is not None:

640

685

gobject.source_remove(self.disable_initiator_tag)

686

self.disable_initiator_tag = None

641

687

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

642

self.disable_initiator_tag = (gobject.timeout_add

643

(timedelta_to_milliseconds

644

(timeout), self.disable))

688

self.disable_initiator_tag = gobject.timeout_add(

689

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

645

690

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

646

691

647

692

def need_approval(self):

653

698

If a checker already exists, leave it running and do

654

699

nothing."""

655

700

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

656

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

657

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

658

# client would inevitably timeout, since no checker would get

659

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

701

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

702

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

703

# would inevitably timeout, since no checker would get a

704

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

660

705

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

661

706

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

662

707

# should be.

663

708

664

# If a checker exists, make sure it is not a zombie

665

try:

666

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

667

except (AttributeError, OSError) as error:

668

if (isinstance(error, OSError)

669

and error.errno != errno.ECHILD):

670

raise error

671

else:

672

if pid:

673

logger.warning("Checker was a zombie")

674

gobject.source_remove(self.checker_callback_tag)

675

self.checker_callback(pid, status,

676

self.current_checker_command)

709

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

710

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

711

self.checker.join()

712

self.checker = None

677

713

# Start a new checker if needed

678

714

if self.checker is None:

715

# Escape attributes for the shell

716

escaped_attrs = {

717

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

718

for attr in self.runtime_expansions }

679

719

try:

680

# In case checker_command has exactly one % operator

681

command = self.checker_command % self.host

682

except TypeError:

683

# Escape attributes for the shell

684

escaped_attrs = dict(

685

(attr,

686

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

687

errors=

688

'replace')))

689

for attr in

690

self.runtime_expansions)

691

692

try:

693

command = self.checker_command % escaped_attrs

694

except TypeError as error:

695

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

696

' %s', self.checker_command, error)

697

return True # Try again later

720

command = self.checker_command % escaped_attrs

721

except TypeError as error:

722

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

723

self.checker_command,

724

exc_info=error)

725

return True # Try again later

698

726

self.current_checker_command = command

699

try:

700

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

701

command, self.name)

702

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

703

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

704

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

705

# always replaced by /dev/null.)

706

self.checker = subprocess.Popen(command,

707

close_fds=True,

708

shell=True, cwd="/")

709

self.checker_callback_tag = (gobject.child_watch_add

710

(self.checker.pid,

711

self.checker_callback,

712

data=command))

713

# The checker may have completed before the gobject

714

# watch was added. Check for this.

715

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

716

if pid:

717

gobject.source_remove(self.checker_callback_tag)

718

self.checker_callback(pid, status, command)

719

except OSError as error:

720

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

721

error)

727

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

728

self.name)

729

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

730

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

731

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

732

# always replaced by /dev/null.)

733

# The exception is when not debugging but nevertheless

734

# running in the foreground; use the previously

735

# created wnull.

736

popen_args = { "close_fds": True,

737

"shell": True,

738

"cwd": "/" }

739

if (not self.server_settings["debug"]

740

and self.server_settings["foreground"]):

741

popen_args.update({"stdout": wnull,

742

"stderr": wnull })

743

pipe = multiprocessing.Pipe(duplex=False)

744

self.checker = multiprocessing.Process(

745

target=subprocess_call_pipe, args=(pipe[1], command),

746

kwargs=popen_args)

747

self.checker.start()

748

self.checker_callback_tag = gobject.io_add_watch(

749

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

750

self.checker_callback, (pipe[0], command))

722

751

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

723

752

return True

724

753

730

759

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

731

760

return

732

761

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

733

try:

734

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

735

#time.sleep(0.5)

736

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

737

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

738

except OSError as error:

739

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

740

raise

762

self.checker.terminate()

741

763

self.checker = None

742

764

743

765

744

def dbus_service_property(dbus_interface, signature="v",

745

access="readwrite", byte_arrays=False):

766

def dbus_service_property(dbus_interface,

767

signature="v",

768

access="readwrite",

769

byte_arrays=False):

746

770

"""Decorators for marking methods of a DBusObjectWithProperties to

747

771

become properties on the D-Bus.

748

772

757

781

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

758

782

if byte_arrays and signature != "ay":

759

783

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

760

" signature %r" % signature)

784

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

785

761

786

def decorator(func):

762

787

func._dbus_is_property = True

763

788

func._dbus_interface = dbus_interface

768

793

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

769

794

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

770

795

return func

796

797

return decorator

798

799

800

def dbus_interface_annotations(dbus_interface):

801

"""Decorator for marking functions returning interface annotations

802

803

Usage:

804

805

@dbus_interface_annotations("org.example.Interface")

806

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

807

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

808

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

809

"false"}

810

"""

811

812

def decorator(func):

813

func._dbus_is_interface = True

814

func._dbus_interface = dbus_interface

815

func._dbus_name = dbus_interface

816

return func

817

818

return decorator

819

820

821

def dbus_annotations(annotations):

822

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

823

Usage:

824

825

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

826

"org.freedesktop.DBus.Property."

827

"EmitsChangedSignal": "false"})

828

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

829

access="r")

830

def Property_dbus_property(self):

831

return dbus.Boolean(False)

832

"""

833

834

def decorator(func):

835

func._dbus_annotations = annotations

836

return func

837

771

838

return decorator

772

839

773

840

774

841

class DBusPropertyException(dbus.exceptions.DBusException):

775

842

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

776

843

"""

777

def __unicode__(self):

778

return unicode(str(self))

844

pass

779

845

780

846

781

847

class DBusPropertyAccessException(DBusPropertyException):

799

865

"""

800

866

801

867

@staticmethod

802

def _is_dbus_property(obj):

803

return getattr(obj, "_dbus_is_property", False)

868

def _is_dbus_thing(thing):

869

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

870

871

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

872

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

873

"""

874

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

875

False)

804

876

805

def _get_all_dbus_properties(self):

877

def _get_all_dbus_things(self, thing):

806

878

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

807

879

"""

808

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

880

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

881

athing.__get__(self))

809

882

for cls in self.__class__.__mro__

810

for name, prop in

811

inspect.getmembers(cls, self._is_dbus_property))

883

for name, athing in

884

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

812

885

813

886

def _get_dbus_property(self, interface_name, property_name):

814

887

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

815

888

property with the specified name and interface.

816

889

"""

817

for cls in self.__class__.__mro__:

818

for name, value in (inspect.getmembers

819

(cls, self._is_dbus_property)):

890

for cls in self.__class__.__mro__:

891

for name, value in inspect.getmembers(

892

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

820

893

if (value._dbus_name == property_name

821

894

and value._dbus_interface == interface_name):

822

895

return value.__get__(self)

823

896

824

897

# No such property

825

raise DBusPropertyNotFound(self.dbus_object_path + ":"

826

+ interface_name + "."

827

+ property_name)

898

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

899

self.dbus_object_path, interface_name, property_name))

828

900

829

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

901

@dbus.service.method(dbus.PROPERTIES_IFACE,

902

in_signature="ss",

830

903

out_signature="v")

831

904

def Get(self, interface_name, property_name):

832

905

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

850

923

# The byte_arrays option is not supported yet on

851

924

# signatures other than "ay".

852

925

if prop._dbus_signature != "ay":

853

raise ValueError

926

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

927

"'ay' signature {!r}"

928

.format(prop._dbus_signature))

854

929

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

855

930

for byte in value))

856

931

prop(value)

857

932

858

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

933

@dbus.service.method(dbus.PROPERTIES_IFACE,

934

in_signature="s",

859

935

out_signature="a{sv}")

860

936

def GetAll(self, interface_name):

861

937

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

864

940

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

865

941

"""

866

942

properties = {}

867

for name, prop in self._get_all_dbus_properties():

943

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

868

944

if (interface_name

869

945

and interface_name != prop._dbus_interface):

870

946

# Interface non-empty but did not match

876

952

if not hasattr(value, "variant_level"):

877

953

properties[name] = value

878

954

continue

879

properties[name] = type(value)(value, variant_level=

880

value.variant_level+1)

955

properties[name] = type(value)(

956

value, variant_level = value.variant_level + 1)

881

957

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

882

958

959

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

960

def PropertiesChanged(self, interface_name, changed_properties,

961

invalidated_properties):

962

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

963

standard.

964

"""

965

pass

966

883

967

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

884

968

out_signature="s",

885

969

path_keyword='object_path',

886

970

connection_keyword='connection')

887

971

def Introspect(self, object_path, connection):

888

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

972

"""Overloading of standard D-Bus method.

973

974

Inserts property tags and interface annotation tags.

889

975

"""

890

976

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

891

977

connection)

892

978

try:

893

979

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

980

894

981

def make_tag(document, name, prop):

895

982

e = document.createElement("property")

896

983

e.setAttribute("name", name)

897

984

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

898

985

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

899

986

return e

987

900

988

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

989

# Add property tags

901

990

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

902

991

for name, prop

903

in self._get_all_dbus_properties()

992

in self._get_all_dbus_things("property")

904

993

if prop._dbus_interface

905

994

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

906

995

if_tag.appendChild(tag)

996

# Add annotation tags

997

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

998

for tag in if_tag.getElementsByTagName(typ):

999

annots = dict()

1000

for name, prop in (self.

1001

_get_all_dbus_things(typ)):

1002

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

1003

and prop._dbus_interface

1004

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

1005

annots.update(getattr(

1006

prop, "_dbus_annotations", {}))

1007

for name, value in annots.items():

1008

ann_tag = document.createElement(

1009

"annotation")

1010

ann_tag.setAttribute("name", name)

1011

ann_tag.setAttribute("value", value)

1012

tag.appendChild(ann_tag)

1013

# Add interface annotation tags

1014

for annotation, value in dict(

1015

itertools.chain.from_iterable(

1016

annotations().items()

1017

for name, annotations

1018

in self._get_all_dbus_things("interface")

1019

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

1020

)).items():

1021

ann_tag = document.createElement("annotation")

1022

ann_tag.setAttribute("name", annotation)

1023

ann_tag.setAttribute("value", value)

1024

if_tag.appendChild(ann_tag)

907

1025

# Add the names to the return values for the

908

1026

# "org.freedesktop.DBus.Properties" methods

909

1027

if (if_tag.getAttribute("name")

924

1042

except (AttributeError, xml.dom.DOMException,

925

1043

xml.parsers.expat.ExpatError) as error:

926

1044

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

927

error)

1045

exc_info=error)

928

1046

return xmlstring

929

1047

930

1048

931

def datetime_to_dbus (dt, variant_level=0):

1049

def datetime_to_dbus(dt, variant_level=0):

932

1050

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

933

1051

if dt is None:

934

1052

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

935

return dbus.String(dt.isoformat(),

936

variant_level=variant_level)

937

938

939

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

940

.__metaclass__):

941

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

942

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

1053

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

1054

1055

1056

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1057

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

1058

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

1059

interface names according to the "alt_interface_names" mapping.

1060

Usage:

1061

1062

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

1063

"net.example.AlternateInterface"})

1064

class SampleDBusObject(dbus.service.Object):

1065

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

1066

def SampleDBusMethod():

1067

pass

1068

1069

The above "SampleDBusMethod" on "SampleDBusObject" will be

1070

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

1071

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

1072

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

1073

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

1074

1075

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

1076

(from DBusObjectWithProperties) and interfaces (from the

1077

dbus_interface_annotations decorator).

943

1078

"""

944

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

945

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

946

# methods, signals, or properties in them

947

for base in (b for b in bases

948

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

949

# Go though all attributes of the base class

950

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

1079

1080

def wrapper(cls):

1081

for orig_interface_name, alt_interface_name in (

1082

alt_interface_names.items()):

1083

attr = {}

1084

interface_names = set()

1085

# Go though all attributes of the class

1086

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

951

1087

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

952

1088

# with the wrong interface name

953

1089

if (not hasattr(attribute, "_dbus_interface")

954

or not attribute._dbus_interface

955

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

1090

or not attribute._dbus_interface.startswith(

1091

orig_interface_name)):

956

1092

continue

957

1093

# Create an alternate D-Bus interface name based on

958

1094

# the current name

959

alt_interface = (attribute._dbus_interface

960

.replace("se.recompile.Mandos",

961

"se.bsnet.fukt.Mandos"))

1095

alt_interface = attribute._dbus_interface.replace(

1096

orig_interface_name, alt_interface_name)

1097

interface_names.add(alt_interface)

962

1098

# Is this a D-Bus signal?

963

1099

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

964

# Extract the original non-method function by

965

# black magic

1100

# Extract the original non-method undecorated

1101

# function by black magic

966

1102

nonmethod_func = (dict(

967

zip(attribute.func_code.co_freevars,

968

attribute.__closure__))["func"]

969

.cell_contents)

1103

zip(attribute.func_code.co_freevars,

1104

attribute.__closure__))

1105

["func"].cell_contents)

970

1106

# Create a new, but exactly alike, function

971

1107

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

972

1108

# with the alternate D-Bus interface name

973

new_function = (dbus.service.signal

974

(alt_interface,

975

attribute._dbus_signature)

1109

new_function = (dbus.service.signal(

1110

alt_interface, attribute._dbus_signature)

976

1111

(types.FunctionType(

977

nonmethod_func.func_code,

978

nonmethod_func.func_globals,

979

nonmethod_func.func_name,

980

nonmethod_func.func_defaults,

981

nonmethod_func.func_closure)))

1112

nonmethod_func.func_code,

1113

nonmethod_func.func_globals,

1114

nonmethod_func.func_name,

1115

nonmethod_func.func_defaults,

1116

nonmethod_func.func_closure)))

1117

# Copy annotations, if any

1118

try:

1119

new_function._dbus_annotations = dict(

1120

attribute._dbus_annotations)

1121

except AttributeError:

1122

pass

982

1123

# Define a creator of a function to call both the

983

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

984

# signals gets sent when the function is called

1124

# original and alternate functions, so both the

1125

# original and alternate signals gets sent when

1126

# the function is called

985

1127

def fixscope(func1, func2):

986

1128

"""This function is a scope container to pass

987

1129

func1 and func2 to the "call_both" function

988

1130

outside of its arguments"""

1131

989

1132

def call_both(*args, **kwargs):

990

1133

"""This function will emit two D-Bus

991

1134

signals by calling func1 and func2"""

992

1135

func1(*args, **kwargs)

993

1136

func2(*args, **kwargs)

1137

994

1138

return call_both

995

1139

# Create the "call_both" function and add it to

996

1140

# the class

997

attr[attrname] = fixscope(attribute,

998

new_function)

1141

attr[attrname] = fixscope(attribute, new_function)

999

1142

# Is this a D-Bus method?

1000

1143

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

1001

1144

# Create a new, but exactly alike, function

1002

1145

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

1003

1146

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

1004

1147

# to the class.

1005

attr[attrname] = (dbus.service.method

1006

(alt_interface,

1007

attribute._dbus_in_signature,

1008

attribute._dbus_out_signature)

1009

(types.FunctionType

1010

(attribute.func_code,

1011

attribute.func_globals,

1012

attribute.func_name,

1013

attribute.func_defaults,

1014

attribute.func_closure)))

1148

attr[attrname] = (

1149

dbus.service.method(

1150

alt_interface,

1151

attribute._dbus_in_signature,

1152

attribute._dbus_out_signature)

1153

(types.FunctionType(attribute.func_code,

1154

attribute.func_globals,

1155

attribute.func_name,

1156

attribute.func_defaults,

1157

attribute.func_closure)))

1158

# Copy annotations, if any

1159

try:

1160

attr[attrname]._dbus_annotations = dict(

1161

attribute._dbus_annotations)

1162

except AttributeError:

1163

pass

1015

1164

# Is this a D-Bus property?

1016

1165

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

1017

1166

# Create a new, but exactly alike, function

1018

1167

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

1019

1168

# property with the alternate D-Bus interface

1020

1169

# name. Add it to the class.

1021

attr[attrname] = (dbus_service_property

1022

(alt_interface,

1023

attribute._dbus_signature,

1024

attribute._dbus_access,

1025

attribute

1026

._dbus_get_args_options

1027

["byte_arrays"])

1028

(types.FunctionType

1029

(attribute.func_code,

1030

attribute.func_globals,

1031

attribute.func_name,

1032

attribute.func_defaults,

1033

attribute.func_closure)))

1034

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

1035

1036

1170

attr[attrname] = (dbus_service_property(

1171

alt_interface, attribute._dbus_signature,

1172

attribute._dbus_access,

1173

attribute._dbus_get_args_options

1174

["byte_arrays"])

1175

(types.FunctionType(

1176

attribute.func_code,

1177

attribute.func_globals,

1178

attribute.func_name,

1179

attribute.func_defaults,

1180

attribute.func_closure)))

1181

# Copy annotations, if any

1182

try:

1183

attr[attrname]._dbus_annotations = dict(

1184

attribute._dbus_annotations)

1185

except AttributeError:

1186

pass

1187

# Is this a D-Bus interface?

1188

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

1189

# Create a new, but exactly alike, function

1190

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

1191

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

1192

# to the class.

1193

attr[attrname] = (

1194

dbus_interface_annotations(alt_interface)

1195

(types.FunctionType(attribute.func_code,

1196

attribute.func_globals,

1197

attribute.func_name,

1198

attribute.func_defaults,

1199

attribute.func_closure)))

1200

if deprecate:

1201

# Deprecate all alternate interfaces

1202

iname="_AlternateDBusNames_interface_annotation{}"

1203

for interface_name in interface_names:

1204

1205

@dbus_interface_annotations(interface_name)

1206

def func(self):

1207

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

1208

"true" }

1209

# Find an unused name

1210

for aname in (iname.format(i)

1211

for i in itertools.count()):

1212

if aname not in attr:

1213

attr[aname] = func

1214

break

1215

if interface_names:

1216

# Replace the class with a new subclass of it with

1217

# methods, signals, etc. as created above.

1218

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

1219

(cls, ), attr)

1220

return cls

1221

1222

return wrapper

1223

1224

1225

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

1226

"se.bsnet.fukt.Mandos"})

1037

1227

class ClientDBus(Client, DBusObjectWithProperties):

1038

1228

"""A Client class using D-Bus

1039

1229

1043

1233

"""

1044

1234

1045

1235

runtime_expansions = (Client.runtime_expansions

1046

+ ("dbus_object_path",))

1236

+ ("dbus_object_path", ))

1237

1238

_interface = "se.recompile.Mandos.Client"

1047

1239

1048

1240

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

1049

1241

1052

1244

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

1053

1245

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

1054

1246

# the D-Bus

1055

client_object_name = unicode(self.name).translate(

1247

client_object_name = str(self.name).translate(

1056

1248

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

1057

1249

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

1058

self.dbus_object_path = (dbus.ObjectPath

1059

("/clients/" + client_object_name))

1250

self.dbus_object_path = dbus.ObjectPath(

1251

"/clients/" + client_object_name)

1060

1252

DBusObjectWithProperties.__init__(self, self.bus,

1061

1253

self.dbus_object_path)

1062

1063

def notifychangeproperty(transform_func,

1064

dbus_name, type_func=lambda x: x,

1065

variant_level=1):

1254

1255

def notifychangeproperty(transform_func, dbus_name,

1256

type_func=lambda x: x,

1257

variant_level=1,

1258

invalidate_only=False,

1259

_interface=_interface):

1066

1260

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

1067

1261

its changes to DBus.

1068

1262

1073

1267

to the D-Bus. Default: no transform

1074

1268

variant_level: D-Bus variant level. Default: 1

1075

1269

"""

1076

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

1270

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

1271

1077

1272

def setter(self, value):

1078

1273

if hasattr(self, "dbus_object_path"):

1079

1274

if (not hasattr(self, attrname) or

1080

1275

type_func(getattr(self, attrname, None))

1081

1276

!= type_func(value)):

1082

dbus_value = transform_func(type_func(value),

1083

variant_level

1084

=variant_level)

1085

self.PropertyChanged(dbus.String(dbus_name),

1086

dbus_value)

1277

if invalidate_only:

1278

self.PropertiesChanged(

1279

_interface, dbus.Dictionary(),

1280

dbus.Array((dbus_name, )))

1281

else:

1282

dbus_value = transform_func(

1283

type_func(value),

1284

variant_level = variant_level)

1285

self.PropertyChanged(dbus.String(dbus_name),

1286

dbus_value)

1287

self.PropertiesChanged(

1288

_interface,

1289

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

1290

dbus_value }),

1291

dbus.Array())

1087

1292

setattr(self, attrname, value)

1088

1293

1089

1294

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

1090

1295

1091

1092

1296

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1093

1297

approvals_pending = notifychangeproperty(dbus.Boolean,

1094

1298

"ApprovalPending",

1096

1300

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

1097

1301

last_enabled = notifychangeproperty(datetime_to_dbus,

1098

1302

"LastEnabled")

1099

checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",

1100

type_func = lambda checker:

1101

checker is not None)

1303

checker = notifychangeproperty(

1304

dbus.Boolean, "CheckerRunning",

1305

type_func = lambda checker: checker is not None)

1102

1306

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1103

1307

"LastCheckedOK")

1104

1308

last_checker_status = notifychangeproperty(dbus.Int16,

1107

1311

datetime_to_dbus, "LastApprovalRequest")

1108

1312

approved_by_default = notifychangeproperty(dbus.Boolean,

1109

1313

"ApprovedByDefault")

1110

approval_delay = notifychangeproperty(dbus.UInt64,

1111

"ApprovalDelay",

1112

type_func =

1113

timedelta_to_milliseconds)

1314

approval_delay = notifychangeproperty(

1315

dbus.UInt64, "ApprovalDelay",

1316

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

1114

1317

approval_duration = notifychangeproperty(

1115

1318

dbus.UInt64, "ApprovalDuration",

1116

type_func = timedelta_to_milliseconds)

1319

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

1117

1320

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

1118

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

1119

type_func =

1120

timedelta_to_milliseconds)

1321

timeout = notifychangeproperty(

1322

dbus.UInt64, "Timeout",

1323

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

1121

1324

extended_timeout = notifychangeproperty(

1122

1325

dbus.UInt64, "ExtendedTimeout",

1123

type_func = timedelta_to_milliseconds)

1124

interval = notifychangeproperty(dbus.UInt64,

1125

"Interval",

1126

type_func =

1127

timedelta_to_milliseconds)

1326

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

1327

interval = notifychangeproperty(

1328

dbus.UInt64, "Interval",

1329

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

1128

1330

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

1331

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

1332

invalidate_only=True)

1129

1333

1130

1334

del notifychangeproperty

1131

1335

1138

1342

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

1139

1343

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

1140

1344

1141

def checker_callback(self, pid, condition, command,

1142

*args, **kwargs):

1143

self.checker_callback_tag = None

1144

self.checker = None

1145

if os.WIFEXITED(condition):

1146

exitstatus = os.WEXITSTATUS(condition)

1345

def checker_callback(self, source, condition,

1346

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

1347

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

1348

(connection, command), *args,

1349

**kwargs)

1350

exitstatus = self.last_checker_status

1351

if exitstatus >= 0:

1147

1352

# Emit D-Bus signal

1148

1353

self.CheckerCompleted(dbus.Int16(exitstatus),

1149

dbus.Int64(condition),

1354

dbus.Int64(0),

1150

1355

dbus.String(command))

1151

1356

else:

1152

1357

# Emit D-Bus signal

1153

1358

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

1154

dbus.Int64(condition),

1359

dbus.Int64(

1360

self.last_checker_signal),

1155

1361

dbus.String(command))

1156

1157

return Client.checker_callback(self, pid, condition, command,

1158

*args, **kwargs)

1362

return ret

1159

1363

1160

1364

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

1161

old_checker = self.checker

1162

if self.checker is not None:

1163

old_checker_pid = self.checker.pid

1164

else:

1165

old_checker_pid = None

1365

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

1166

1366

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

1167

1367

# Only if new checker process was started

1168

1368

if (self.checker is not None

1176

1376

return False

1177

1377

1178

1378

def approve(self, value=True):

1179

self.send_changedstate()

1180

1379

self.approved = value

1181

gobject.timeout_add(timedelta_to_milliseconds

1182

(self.approval_duration),

1183

self._reset_approved)

1184

1380

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

1381

* 1000), self._reset_approved)

1382

self.send_changedstate()

1185

1383

1186

1384

## D-Bus methods, signals & properties

1187

_interface = "se.recompile.Mandos.Client"

1385

1386

## Interfaces

1188

1387

1189

1388

## Signals

1190

1389

1201

1400

pass

1202

1401

1203

1402

# PropertyChanged - signal

1403

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

1204

1404

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

1205

1405

def PropertyChanged(self, property, value):

1206

1406

"D-Bus signal"

1270

1470

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

1271

1471

1272

1472

# ApprovedByDefault - property

1273

@dbus_service_property(_interface, signature="b",

1473

@dbus_service_property(_interface,

1474

signature="b",

1274

1475

access="readwrite")

1275

1476

def ApprovedByDefault_dbus_property(self, value=None):

1276

1477

if value is None: # get

1278

1479

self.approved_by_default = bool(value)

1279

1480

1280

1481

# ApprovalDelay - property

1281

@dbus_service_property(_interface, signature="t",

1482

@dbus_service_property(_interface,

1483

signature="t",

1282

1484

access="readwrite")

1283

1485

def ApprovalDelay_dbus_property(self, value=None):

1284

1486

if value is None: # get

1285

return dbus.UInt64(self.approval_delay_milliseconds())

1487

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

1488

* 1000)

1286

1489

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

1287

1490

1288

1491

# ApprovalDuration - property

1289

@dbus_service_property(_interface, signature="t",

1492

@dbus_service_property(_interface,

1493

signature="t",

1290

1494

access="readwrite")

1291

1495

def ApprovalDuration_dbus_property(self, value=None):

1292

1496

if value is None: # get

1293

return dbus.UInt64(timedelta_to_milliseconds(

1294

self.approval_duration))

1497

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

1498

* 1000)

1295

1499

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

1296

1500

1297

1501

# Name - property

1305

1509

return dbus.String(self.fingerprint)

1306

1510

1307

1511

# Host - property

1308

@dbus_service_property(_interface, signature="s",

1512

@dbus_service_property(_interface,

1513

signature="s",

1309

1514

access="readwrite")

1310

1515

def Host_dbus_property(self, value=None):

1311

1516

if value is None: # get

1312

1517

return dbus.String(self.host)

1313

self.host = unicode(value)

1518

self.host = str(value)

1314

1519

1315

1520

# Created - property

1316

1521

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

1323

1528

return datetime_to_dbus(self.last_enabled)

1324

1529

1325

1530

# Enabled - property

1326

@dbus_service_property(_interface, signature="b",

1531

@dbus_service_property(_interface,

1532

signature="b",

1327

1533

access="readwrite")

1328

1534

def Enabled_dbus_property(self, value=None):

1329

1535

if value is None: # get

1334

1540

self.disable()

1335

1541

1336

1542

# LastCheckedOK - property

1337

@dbus_service_property(_interface, signature="s",

1543

@dbus_service_property(_interface,

1544

signature="s",

1338

1545

access="readwrite")

1339

1546

def LastCheckedOK_dbus_property(self, value=None):

1340

1547

if value is not None:

1343

1550

return datetime_to_dbus(self.last_checked_ok)

1344

1551

1345

1552

# LastCheckerStatus - property

1346

@dbus_service_property(_interface, signature="n",

1347

access="read")

1553

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

1348

1554

def LastCheckerStatus_dbus_property(self):

1349

1555

return dbus.Int16(self.last_checker_status)

1350

1556

1359

1565

return datetime_to_dbus(self.last_approval_request)

1360

1566

1361

1567

# Timeout - property

1362

@dbus_service_property(_interface, signature="t",

1568

@dbus_service_property(_interface,

1569

signature="t",

1363

1570

access="readwrite")

1364

1571

def Timeout_dbus_property(self, value=None):

1365

1572

if value is None: # get

1366

return dbus.UInt64(self.timeout_milliseconds())

1573

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

1574

old_timeout = self.timeout

1367

1575

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

1368

# Reschedule timeout

1576

# Reschedule disabling

1369

1577

if self.enabled:

1370

1578

now = datetime.datetime.utcnow()

1371

time_to_die = timedelta_to_milliseconds(

1372

(self.last_checked_ok + self.timeout) - now)

1373

if time_to_die <= 0:

1579

self.expires += self.timeout - old_timeout

1580

if self.expires <= now:

1374

1581

# The timeout has passed

1375

1582

self.disable()

1376

1583

else:

1377

self.expires = (now +

1378

datetime.timedelta(milliseconds =

1379

time_to_die))

1380

1584

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

1381

1585

is None):

1382

1586

return

1383

1587

gobject.source_remove(self.disable_initiator_tag)

1384

self.disable_initiator_tag = (gobject.timeout_add

1385

(time_to_die,

1386

self.disable))

1588

self.disable_initiator_tag = gobject.timeout_add(

1589

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

1590

self.disable)

1387

1591

1388

1592

# ExtendedTimeout - property

1389

@dbus_service_property(_interface, signature="t",

1593

@dbus_service_property(_interface,

1594

signature="t",

1390

1595

access="readwrite")

1391

1596

def ExtendedTimeout_dbus_property(self, value=None):

1392

1597

if value is None: # get

1393

return dbus.UInt64(self.extended_timeout_milliseconds())

1598

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

1599

* 1000)

1394

1600

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

1395

1601

1396

1602

# Interval - property

1397

@dbus_service_property(_interface, signature="t",

1603

@dbus_service_property(_interface,

1604

signature="t",

1398

1605

access="readwrite")

1399

1606

def Interval_dbus_property(self, value=None):

1400

1607

if value is None: # get

1401

return dbus.UInt64(self.interval_milliseconds())

1608

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

1402

1609

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

1403

1610

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

1404

1611

return

1405

1612

if self.enabled:

1406

1613

# Reschedule checker run

1407

1614

gobject.source_remove(self.checker_initiator_tag)

1408

self.checker_initiator_tag = (gobject.timeout_add

1409

(value, self.start_checker))

1410

self.start_checker() # Start one now, too

1615

self.checker_initiator_tag = gobject.timeout_add(

1616

value, self.start_checker)

1617

self.start_checker() # Start one now, too

1411

1618

1412

1619

# Checker - property

1413

@dbus_service_property(_interface, signature="s",

1620

@dbus_service_property(_interface,

1621

signature="s",

1414

1622

access="readwrite")

1415

1623

def Checker_dbus_property(self, value=None):

1416

1624

if value is None: # get

1417

1625

return dbus.String(self.checker_command)

1418

self.checker_command = unicode(value)

1626

self.checker_command = str(value)

1419

1627

1420

1628

# CheckerRunning - property

1421

@dbus_service_property(_interface, signature="b",

1629

@dbus_service_property(_interface,

1630

signature="b",

1422

1631

access="readwrite")

1423

1632

def CheckerRunning_dbus_property(self, value=None):

1424

1633

if value is None: # get

1434

1643

return self.dbus_object_path # is already a dbus.ObjectPath

1435

1644

1436

1645

# Secret = property

1437

@dbus_service_property(_interface, signature="ay",

1438

access="write", byte_arrays=True)

1646

@dbus_service_property(_interface,

1647

signature="ay",

1648

access="write",

1649

byte_arrays=True)

1439

1650

def Secret_dbus_property(self, value):

1440

self.secret = str(value)

1651

self.secret = bytes(value)

1441

1652

1442

1653

del _interface

1443

1654

1457

1668

if data[0] == 'data':

1458

1669

return data[1]

1459

1670

if data[0] == 'function':

1671

1460

1672

def func(*args, **kwargs):

1461

1673

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

1462

1674

return self._pipe.recv()[1]

1675

1463

1676

return func

1464

1677

1465

1678

def __setattr__(self, name, value):

1468

1681

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

1469

1682

1470

1683

1471

class ClientDBusTransitional(ClientDBus):

1472

__metaclass__ = AlternateDBusNamesMetaclass

1473

1474

1475

1684

class ClientHandler(socketserver.BaseRequestHandler, object):

1476

1685

"""A class to handle client connections.

1477

1686

1481

1690

def handle(self):

1482

1691

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

1483

1692

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

1484

unicode(self.client_address))

1693

str(self.client_address))

1485

1694

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

1486

1695

self.server.child_pipe.fileno())

1487

1696

1488

session = (gnutls.connection

1489

.ClientSession(self.request,

1490

gnutls.connection

1491

.X509Credentials()))

1697

session = gnutls.connection.ClientSession(

1698

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

1492

1699

1493

1700

# Note: gnutls.connection.X509Credentials is really a

1494

1701

# generic GnuTLS certificate credentials object so long as

1503

1710

priority = self.server.gnutls_priority

1504

1711

if priority is None:

1505

1712

priority = "NORMAL"

1506

(gnutls.library.functions

1507

.gnutls_priority_set_direct(session._c_object,

1508

priority, None))

1713

gnutls.library.functions.gnutls_priority_set_direct(

1714

session._c_object, priority, None)

1509

1715

1510

1716

# Start communication using the Mandos protocol

1511

1717

# Get protocol number

1513

1719

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

1514

1720

try:

1515

1721

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

1516

raise RuntimeError

1722

raise RuntimeError(line)

1517

1723

except (ValueError, IndexError, RuntimeError) as error:

1518

1724

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

1519

1725

return

1531

1737

approval_required = False

1532

1738

try:

1533

1739

try:

1534

fpr = self.fingerprint(self.peer_certificate

1535

(session))

1740

fpr = self.fingerprint(

1741

self.peer_certificate(session))

1536

1742

except (TypeError,

1537

1743

gnutls.errors.GNUTLSError) as error:

1538

1744

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

1553

1759

while True:

1554

1760

if not client.enabled:

1555

1761

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

1556

client.name)

1762

client.name)

1557

1763

if self.server.use_dbus:

1558

1764

# Emit D-Bus signal

1559

1765

client.Rejected("Disabled")

1568

1774

if self.server.use_dbus:

1569

1775

# Emit D-Bus signal

1570

1776

client.NeedApproval(

1571

client.approval_delay_milliseconds(),

1572

client.approved_by_default)

1777

client.approval_delay.total_seconds()

1778

* 1000, client.approved_by_default)

1573

1779

else:

1574

1780

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

1575

1781

client.name)

1581

1787

#wait until timeout or approved

1582

1788

time = datetime.datetime.now()

1583

1789

client.changedstate.acquire()

1584

(client.changedstate.wait

1585

(float(client.timedelta_to_milliseconds(delay)

1586

/ 1000)))

1790

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

1587

1791

client.changedstate.release()

1588

1792

time2 = datetime.datetime.now()

1589

1793

if (time2 - time) >= delay:

1605

1809

try:

1606

1810

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

1607

1811

except gnutls.errors.GNUTLSError as error:

1608

logger.warning("gnutls send failed")

1812

logger.warning("gnutls send failed",

1813

exc_info=error)

1609

1814

return

1610

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

1611

sent, len(client.secret)

1612

- (sent_size + sent))

1815

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

1816

len(client.secret) - (sent_size

1817

+ sent))

1613

1818

sent_size += sent

1614

1819

1615

1820

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

1625

1830

try:

1626

1831

session.bye()

1627

1832

except gnutls.errors.GNUTLSError as error:

1628

logger.warning("GnuTLS bye failed")

1833

logger.warning("GnuTLS bye failed",

1834

exc_info=error)

1629

1835

1630

1836

@staticmethod

1631

1837

def peer_certificate(session):

1632

1838

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

1633

1839

# If not an OpenPGP certificate...

1634

if (gnutls.library.functions

1635

.gnutls_certificate_type_get(session._c_object)

1840

if (gnutls.library.functions.gnutls_certificate_type_get(

1841

session._c_object)

1636

1842

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1637

1843

# ...do the normal thing

1638

1844

return session.peer_certificate

1652

1858

def fingerprint(openpgp):

1653

1859

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

1654

1860

# New GnuTLS "datum" with the OpenPGP public key

1655

datum = (gnutls.library.types

1656

.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),

1657

ctypes.POINTER

1658

(ctypes.c_ubyte)),

1659

ctypes.c_uint(len(openpgp))))

1861

datum = gnutls.library.types.gnutls_datum_t(

1862

ctypes.cast(ctypes.c_char_p(openpgp),

1863

ctypes.POINTER(ctypes.c_ubyte)),

1864

ctypes.c_uint(len(openpgp)))

1660

1865

# New empty GnuTLS certificate

1661

1866

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1662

(gnutls.library.functions

1663

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

1867

gnutls.library.functions.gnutls_openpgp_crt_init(

1868

ctypes.byref(crt))

1664

1869

# Import the OpenPGP public key into the certificate

1665

(gnutls.library.functions

1666

.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),

1667

gnutls.library.constants

1668

.GNUTLS_OPENPGP_FMT_RAW))

1870

gnutls.library.functions.gnutls_openpgp_crt_import(

1871

crt, ctypes.byref(datum),

1872

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

1669

1873

# Verify the self signature in the key

1670

1874

crtverify = ctypes.c_uint()

1671

(gnutls.library.functions

1672

.gnutls_openpgp_crt_verify_self(crt, 0,

1673

ctypes.byref(crtverify)))

1875

gnutls.library.functions.gnutls_openpgp_crt_verify_self(

1876

crt, 0, ctypes.byref(crtverify))

1674

1877

if crtverify.value != 0:

1675

1878

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1676

raise (gnutls.errors.CertificateSecurityError

1677

("Verify failed"))

1879

raise gnutls.errors.CertificateSecurityError(

1880

"Verify failed")

1678

1881

# New buffer for the fingerprint

1679

1882

buf = ctypes.create_string_buffer(20)

1680

1883

buf_len = ctypes.c_size_t()

1681

1884

# Get the fingerprint from the certificate into the buffer

1682

(gnutls.library.functions

1683

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

1684

ctypes.byref(buf_len)))

1885

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(

1886

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

1685

1887

# Deinit the certificate

1686

1888

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1687

1889

# Convert the buffer to a Python bytestring

1693

1895

1694

1896

class MultiprocessingMixIn(object):

1695

1897

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

1898

1696

1899

def sub_process_main(self, request, address):

1697

1900

try:

1698

1901

self.finish_request(request, address)

1703

1906

def process_request(self, request, address):

1704

1907

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

1705

1908

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

1706

args = (request,

1707

address))

1909

args = (request, address))

1708

1910

proc.start()

1709

1911

return proc

1710

1912

1711

1913

1712

1914

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1713

1915

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

1916

1714

1917

def process_request(self, request, client_address):

1715

1918

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

1716

1919

1725

1928

1726

1929

def add_pipe(self, parent_pipe, proc):

1727

1930

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

1728

raise NotImplementedError

1931

raise NotImplementedError()

1729

1932

1730

1933

1731

1934

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1737

1940

interface: None or a network interface name (string)

1738

1941

use_ipv6: Boolean; to use IPv6 or not

1739

1942

"""

1943

1740

1944

def __init__(self, server_address, RequestHandlerClass,

1741

interface=None, use_ipv6=True):

1945

interface=None,

1946

use_ipv6=True,

1947

socketfd=None):

1948

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

1949

creating a new one with socket.socket().

1950

"""

1742

1951

self.interface = interface

1743

1952

if use_ipv6:

1744

1953

self.address_family = socket.AF_INET6

1954

if socketfd is not None:

1955

# Save the file descriptor

1956

self.socketfd = socketfd

1957

# Save the original socket.socket() function

1958

self.socket_socket = socket.socket

1959

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

1960

#

1961

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

1962

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

1963

# patching socket.socket.)

1964

#

1965

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

1966

@functools.wraps(socket.socket)

1967

def socket_wrapper(*args, **kwargs):

1968

# Restore original function so subsequent calls are

1969

# not affected.

1970

socket.socket = self.socket_socket

1971

del self.socket_socket

1972

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

1973

# saved file descriptor.

1974

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

1975

# Replace socket.socket() function with wrapper

1976

socket.socket = socket_wrapper

1977

# The socketserver.TCPServer.__init__ will call

1978

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

1979

# socket_wrapper(), if socketfd was set.

1745

1980

socketserver.TCPServer.__init__(self, server_address,

1746

1981

RequestHandlerClass)

1982

1747

1983

def server_bind(self):

1748

1984

"""This overrides the normal server_bind() function

1749

1985

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

1755

1991

self.interface)

1756

1992

else:

1757

1993

try:

1758

self.socket.setsockopt(socket.SOL_SOCKET,

1759

SO_BINDTODEVICE,

1760

str(self.interface

1761

+ '\0'))

1994

self.socket.setsockopt(

1995

socket.SOL_SOCKET, SO_BINDTODEVICE,

1996

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

1762

1997

except socket.error as error:

1763

if error[0] == errno.EPERM:

1764

logger.error("No permission to"

1765

" bind to interface %s",

1766

self.interface)

1767

elif error[0] == errno.ENOPROTOOPT:

1998

if error.errno == errno.EPERM:

1999

logger.error("No permission to bind to"

2000

" interface %s", self.interface)

2001

elif error.errno == errno.ENOPROTOOPT:

1768

2002

logger.error("SO_BINDTODEVICE not available;"

1769

2003

" cannot bind to interface %s",

1770

2004

self.interface)

2005

elif error.errno == errno.ENODEV:

2006

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

2007

" cannot bind", self.interface)

1771

2008

else:

1772

2009

raise

1773

2010

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

1776

2013

if self.address_family == socket.AF_INET6:

1777

2014

any_address = "::" # in6addr_any

1778

2015

else:

1779

any_address = socket.INADDR_ANY

2016

any_address = "0.0.0.0" # INADDR_ANY

1780

2017

self.server_address = (any_address,

1781

2018

self.server_address[1])

1782

2019

elif not self.server_address[1]:

1783

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

1784

0)

2020

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

1785

2021

# if self.interface:

1786

2022

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

1787

2023

# 0, # port

1801

2037

1802

2038

Assumes a gobject.MainLoop event loop.

1803

2039

"""

2040

1804

2041

def __init__(self, server_address, RequestHandlerClass,

1805

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

1806

gnutls_priority=None, use_dbus=True):

2042

interface=None,

2043

use_ipv6=True,

2044

clients=None,

2045

gnutls_priority=None,

2046

use_dbus=True,

2047

socketfd=None):

1807

2048

self.enabled = False

1808

2049

self.clients = clients

1809

2050

if self.clients is None:

1813

2054

IPv6_TCPServer.__init__(self, server_address,

1814

2055

RequestHandlerClass,

1815

2056

interface = interface,

1816

use_ipv6 = use_ipv6)

2057

use_ipv6 = use_ipv6,

2058

socketfd = socketfd)

2059

1817

2060

def server_activate(self):

1818

2061

if self.enabled:

1819

2062

return socketserver.TCPServer.server_activate(self)

1823

2066

1824

2067

def add_pipe(self, parent_pipe, proc):

1825

2068

# Call "handle_ipc" for both data and EOF events

1826

gobject.io_add_watch(parent_pipe.fileno(),

1827

gobject.IO_IN | gobject.IO_HUP,

1828

functools.partial(self.handle_ipc,

1829

parent_pipe =

1830

parent_pipe,

1831

proc = proc))

2069

gobject.io_add_watch(

2070

parent_pipe.fileno(),

2071

gobject.IO_IN | gobject.IO_HUP,

2072

functools.partial(self.handle_ipc,

2073

parent_pipe = parent_pipe,

2074

proc = proc))

1832

2075

1833

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

1834

proc = None, client_object=None):

1835

condition_names = {

1836

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

1837

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

1838

# blocking).

1839

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

1840

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

1841

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

1842

# broken, usually for pipes and

1843

# sockets).

1844

}

1845

conditions_string = ' | '.join(name

1846

for cond, name in

1847

condition_names.iteritems()

1848

if cond & condition)

2076

def handle_ipc(self, source, condition,

2077

parent_pipe=None,

2078

proc = None,

2079

client_object=None):

1849

2080

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

1850

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

2081

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

1851

2082

# Wait for other process to exit

1852

2083

proc.join()

1853

2084

return False

1874

2105

parent_pipe.send(False)

1875

2106

return False

1876

2107

1877

gobject.io_add_watch(parent_pipe.fileno(),

1878

gobject.IO_IN | gobject.IO_HUP,

1879

functools.partial(self.handle_ipc,

1880

parent_pipe =

1881

parent_pipe,

1882

proc = proc,

1883

client_object =

1884

client))

2108

gobject.io_add_watch(

2109

parent_pipe.fileno(),

2110

gobject.IO_IN | gobject.IO_HUP,

2111

functools.partial(self.handle_ipc,

2112

parent_pipe = parent_pipe,

2113

proc = proc,

2114

client_object = client))

1885

2115

parent_pipe.send(True)

1886

2116

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

1887

2117

# same fileno

1893

2123

1894

2124

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

1895

2125

funcname)(*args,

1896

**kwargs)))

2126

**kwargs)))

1897

2127

1898

2128

if command == 'getattr':

1899

2129

attrname = request[1]

1900

2130

if callable(client_object.__getattribute__(attrname)):

1901

parent_pipe.send(('function',))

2131

parent_pipe.send(('function', ))

1902

2132

else:

1903

parent_pipe.send(('data', client_object

1904

.__getattribute__(attrname)))

2133

parent_pipe.send((

2134

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

1905

2135

1906

2136

if command == 'setattr':

1907

2137

attrname = request[1]

1911

2141

return True

1912

2142

1913

2143

2144

def rfc3339_duration_to_delta(duration):

2145

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

2146

2147

>>> rfc3339_duration_to_delta("P7D")

2148

datetime.timedelta(7)

2149

>>> rfc3339_duration_to_delta("PT60S")

2150

datetime.timedelta(0, 60)

2151

>>> rfc3339_duration_to_delta("PT60M")

2152

datetime.timedelta(0, 3600)

2153

>>> rfc3339_duration_to_delta("PT24H")

2154

datetime.timedelta(1)

2155

>>> rfc3339_duration_to_delta("P1W")

2156

datetime.timedelta(7)

2157

>>> rfc3339_duration_to_delta("PT5M30S")

2158

datetime.timedelta(0, 330)

2159

>>> rfc3339_duration_to_delta("P1DT3M20S")

2160

datetime.timedelta(1, 200)

2161

"""

2162

2163

# Parsing an RFC 3339 duration with regular expressions is not

2164

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

2165

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

2166

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

2167

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

2168

# avoid excessive use of external libraries.

2169

2170

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

2171

Token = collections.namedtuple("Token",

2172

("regexp", # To match token; if

2173

# "value" is not None,

2174

# must have a "group"

2175

# containing digits

2176

"value", # datetime.timedelta or

2177

# None

2178

"followers")) # Tokens valid after

2179

# this token

2180

Token = collections.namedtuple("Token", (

2181

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

2182

# a "group" containing digits

2183

"value", # datetime.timedelta or None

2184

"followers")) # Tokens valid after this token

2185

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

2186

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

2187

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

2188

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

2189

datetime.timedelta(seconds=1),

2190

frozenset((token_end, )))

2191

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

2192

datetime.timedelta(minutes=1),

2193

frozenset((token_second, token_end)))

2194

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

2195

datetime.timedelta(hours=1),

2196

frozenset((token_minute, token_end)))

2197

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

2198

None,

2199

frozenset((token_hour, token_minute,

2200

token_second)))

2201

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

2202

datetime.timedelta(days=1),

2203

frozenset((token_time, token_end)))

2204

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

2205

datetime.timedelta(weeks=4),

2206

frozenset((token_day, token_end)))

2207

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

2208

datetime.timedelta(weeks=52),

2209

frozenset((token_month, token_end)))

2210

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

2211

datetime.timedelta(weeks=1),

2212

frozenset((token_end, )))

2213

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

2214

frozenset((token_year, token_month,

2215

token_day, token_time,

2216

token_week)))

2217

# Define starting values

2218

value = datetime.timedelta() # Value so far

2219

found_token = None

2220

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

2221

s = duration # String left to parse

2222

# Loop until end token is found

2223

while found_token is not token_end:

2224

# Search for any currently valid tokens

2225

for token in followers:

2226

match = token.regexp.match(s)

2227

if match is not None:

2228

# Token found

2229

if token.value is not None:

2230

# Value found, parse digits

2231

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

2232

# Add to value so far

2233

value += factor * token.value

2234

# Strip token from string

2235

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

2236

# Go to found token

2237

found_token = token

2238

# Set valid next tokens

2239

followers = found_token.followers

2240

break

2241

else:

2242

# No currently valid tokens were found

2243

raise ValueError("Invalid RFC 3339 duration")

2244

# End token found

2245

return value

2246

2247

1914

2248

def string_to_delta(interval):

1915

2249

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

1916

2250

1927

2261

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

1928

2262

datetime.timedelta(0, 330)

1929

2263

"""

2264

2265

try:

2266

return rfc3339_duration_to_delta(interval)

2267

except ValueError:

2268

pass

2269

1930

2270

timevalue = datetime.timedelta(0)

1931

2271

for s in interval.split():

1932

2272

try:

1933

suffix = unicode(s[-1])

2273

suffix = s[-1]

1934

2274

value = int(s[:-1])

1935

2275

if suffix == "d":

1936

2276

delta = datetime.timedelta(value)

1943

2283

elif suffix == "w":

1944

2284

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

1945

2285

else:

1946

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

1947

except (ValueError, IndexError) as e:

2286

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

2287

except IndexError as e:

1948

2288

raise ValueError(*(e.args))

1949

2289

timevalue += delta

1950

2290

return timevalue

1963

2303

sys.exit()

1964

2304

if not noclose:

1965

2305

# Close all standard open file descriptors

1966

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

2306

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

1967

2307

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

1968

2308

raise OSError(errno.ENODEV,

1969

"%s not a character device"

1970

% os.path.devnull)

2309

"{} not a character device"

2310

.format(os.devnull))

1971

2311

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

1972

2312

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

1973

2313

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

1982

2322

1983

2323

parser = argparse.ArgumentParser()

1984

2324

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

1985

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

2325

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

1986

2326

help="show version number and exit")

1987

2327

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

1988

2328

help="Bind to interface IF")

1994

2334

help="Run self-test")

1995

2335

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

1996

2336

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

1997

" to terminal")

2337

" to terminal", default=None)

1998

2338

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

1999

2339

help="Debug level for stdout output")

2000

2340

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

2007

2347

" files")

2008

2348

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

2009

2349

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

2010

" system bus interface")

2350

" system bus interface", default=None)

2011

2351

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

2012

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

2352

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

2353

default=None)

2013

2354

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

2014

2355

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

2015

" state")

2356

" state", default=None)

2357

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

2358

help="Specify a file descriptor to a network"

2359

" socket to use instead of creating one")

2016

2360

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

2017

2361

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

2362

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

2363

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

2364

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

2365

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

2366

default=None)

2018

2367

2019

2368

options = parser.parse_args()

2020

2369

2021

2370

if options.check:

2022

2371

import doctest

2023

doctest.testmod()

2024

sys.exit()

2372

fail_count, test_count = doctest.testmod()

2373

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

2025

2374

2026

2375

# Default values for config file for server-global settings

2027

2376

server_defaults = { "interface": "",

2029

2378

"port": "",

2030

2379

"debug": "False",

2031

2380

"priority":

2032

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

2381

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

2382

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

2033

2383

"servicename": "Mandos",

2034

2384

"use_dbus": "True",

2035

2385

"use_ipv6": "True",

2036

2386

"debuglevel": "",

2037

2387

"restore": "True",

2038

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

2039

}

2388

"socket": "",

2389

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

2390

"foreground": "False",

2391

"zeroconf": "True",

2392

}

2040

2393

2041

2394

# Parse config file for server-global settings

2042

2395

server_config = configparser.SafeConfigParser(server_defaults)

2043

2396

del server_defaults

2044

server_config.read(os.path.join(options.configdir,

2045

"mandos.conf"))

2397

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

2046

2398

# Convert the SafeConfigParser object to a dict

2047

2399

server_settings = server_config.defaults()

2048

2400

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

2049

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

2401

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

2050

2402

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

2051

2403

option)

2052

2404

if server_settings["port"]:

2053

2405

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

2054

2406

"port")

2407

if server_settings["socket"]:

2408

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

2409

"socket")

2410

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

2411

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

2412

# happen with a supplied network socket.

2413

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

2414

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

2415

["socket"])

2055

2416

del server_config

2056

2417

2057

2418

# Override the settings from the config file with command line

2058

2419

# options, if set.

2059

2420

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

2060

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

2061

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

2062

"statedir"):

2421

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

2422

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

2423

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

2063

2424

value = getattr(options, option)

2064

2425

if value is not None:

2065

2426

server_settings[option] = value

2066

2427

del options

2067

2428

# Force all strings to be unicode

2068

2429

for option in server_settings.keys():

2069

if type(server_settings[option]) is str:

2070

server_settings[option] = unicode(server_settings[option])

2430

if isinstance(server_settings[option], bytes):

2431

server_settings[option] = (server_settings[option]

2432

.decode("utf-8"))

2433

# Force all boolean options to be boolean

2434

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

2435

"foreground", "zeroconf"):

2436

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

2437

# Debug implies foreground

2438

if server_settings["debug"]:

2439

server_settings["foreground"] = True

2071

2440

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

2072

2441

2073

2442

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

2074

2443

2444

if (not server_settings["zeroconf"]

2445

and not (server_settings["port"]

2446

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

2447

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

2448

2075

2449

# For convenience

2076

2450

debug = server_settings["debug"]

2077

2451

debuglevel = server_settings["debuglevel"]

2079

2453

use_ipv6 = server_settings["use_ipv6"]

2080

2454

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

2081

2455

stored_state_file)

2456

foreground = server_settings["foreground"]

2457

zeroconf = server_settings["zeroconf"]

2082

2458

2083

2459

if debug:

2084

2460

initlogger(debug, logging.DEBUG)

2090

2466

initlogger(debug, level)

2091

2467

2092

2468

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

2093

syslogger.setFormatter(logging.Formatter

2094

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

2095

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

2096

% server_settings["servicename"]))

2469

syslogger.setFormatter(

2470

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

2471

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

2472

server_settings["servicename"])))

2097

2473

2098

2474

# Parse config file with clients

2099

2475

client_config = configparser.SafeConfigParser(Client

2104

2480

global mandos_dbus_service

2105

2481

mandos_dbus_service = None

2106

2482

2107

tcp_server = MandosServer((server_settings["address"],

2108

server_settings["port"]),

2109

ClientHandler,

2110

interface=(server_settings["interface"]

2111

or None),

2112

use_ipv6=use_ipv6,

2113

gnutls_priority=

2114

server_settings["priority"],

2115

use_dbus=use_dbus)

2116

if not debug:

2117

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

2483

socketfd = None

2484

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

2485

socketfd = server_settings["socket"]

2486

tcp_server = MandosServer(

2487

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

2488

ClientHandler,

2489

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

2490

use_ipv6=use_ipv6,

2491

gnutls_priority=server_settings["priority"],

2492

use_dbus=use_dbus,

2493

socketfd=socketfd)

2494

if not foreground:

2495

pidfilename = "/run/mandos.pid"

2496

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

2497

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

2498

pidfile = None

2118

2499

try:

2119

2500

pidfile = open(pidfilename, "w")

2120

except IOError:

2121

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

2501

except IOError as e:

2502

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

2503

exc_info=e)

2122

2504

2123

try:

2124

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

2125

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

2126

except KeyError:

2505

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

2127

2506

try:

2128

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

2129

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

2507

uid = pwd.getpwnam(name).pw_uid

2508

gid = pwd.getpwnam(name).pw_gid

2509

break

2130

2510

except KeyError:

2131

try:

2132

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

2133

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

2134

except KeyError:

2135

uid = 65534

2136

gid = 65534

2511

continue

2512

else:

2513

uid = 65534

2514

gid = 65534

2137

2515

try:

2138

2516

os.setgid(gid)

2139

2517

os.setuid(uid)

2140

2518

except OSError as error:

2141

if error[0] != errno.EPERM:

2142

raise error

2519

if error.errno != errno.EPERM:

2520

raise

2143

2521

2144

2522

if debug:

2145

2523

# Enable all possible GnuTLS debugging

2152

2530

def debug_gnutls(level, string):

2153

2531

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

2154

2532

2155

(gnutls.library.functions

2156

.gnutls_global_set_log_function(debug_gnutls))

2533

gnutls.library.functions.gnutls_global_set_log_function(

2534

debug_gnutls)

2157

2535

2158

2536

# Redirect stdin so all checkers get /dev/null

2159

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

2537

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

2160

2538

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

2161

2539

if null > 2:

2162

2540

os.close(null)

2163

2541

2164

2542

# Need to fork before connecting to D-Bus

2165

if not debug:

2543

if not foreground:

2166

2544

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

2167

2545

daemon()

2168

2546

2547

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

2548

# need to inform gobject that threads will be used.

2169

2549

gobject.threads_init()

2170

2550

2171

2551

global main_loop

2172

2552

# From the Avahi example code

2173

DBusGMainLoop(set_as_default=True )

2553

DBusGMainLoop(set_as_default=True)

2174

2554

main_loop = gobject.MainLoop()

2175

2555

bus = dbus.SystemBus()

2176

2556

# End of Avahi example code

2177

2557

if use_dbus:

2178

2558

try:

2179

2559

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

2180

bus, do_not_queue=True)

2181

old_bus_name = (dbus.service.BusName

2182

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

2183

do_not_queue=True))

2560

bus,

2561

do_not_queue=True)

2562

old_bus_name = dbus.service.BusName(

2563

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

2564

do_not_queue=True)

2184

2565

except dbus.exceptions.NameExistsException as e:

2185

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

2566

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

2186

2567

use_dbus = False

2187

2568

server_settings["use_dbus"] = False

2188

2569

tcp_server.use_dbus = False

2189

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2190

service = AvahiServiceToSyslog(name =

2191

server_settings["servicename"],

2192

servicetype = "_mandos._tcp",

2193

protocol = protocol, bus = bus)

2194

if server_settings["interface"]:

2195

service.interface = (if_nametoindex

2196

(str(server_settings["interface"])))

2570

if zeroconf:

2571

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2572

service = AvahiServiceToSyslog(

2573

name = server_settings["servicename"],

2574

servicetype = "_mandos._tcp",

2575

protocol = protocol,

2576

bus = bus)

2577

if server_settings["interface"]:

2578

service.interface = if_nametoindex(

2579

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

2197

2580

2198

2581

global multiprocessing_manager

2199

2582

multiprocessing_manager = multiprocessing.Manager()

2200

2583

2201

2584

client_class = Client

2202

2585

if use_dbus:

2203

client_class = functools.partial(ClientDBusTransitional,

2204

bus = bus)

2586

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

2205

2587

2206

2588

client_settings = Client.config_parser(client_config)

2207

2589

old_client_settings = {}

2208

2590

clients_data = {}

2209

2591

2592

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

2593

global wnull

2594

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

2595

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

2596

# mode

2597

if debug or not foreground:

2598

wnull.close()

2599

2210

2600

# Get client data and settings from last running state.

2211

2601

if server_settings["restore"]:

2212

2602

try:

2213

2603

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

2214

clients_data, old_client_settings = (pickle.load

2215

(stored_state))

2604

clients_data, old_client_settings = pickle.load(

2605

stored_state)

2216

2606

os.remove(stored_state_path)

2217

2607

except IOError as e:

2218

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

2219

.format(e))

2220

if e.errno != errno.ENOENT:

2608

if e.errno == errno.ENOENT:

2609

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

2610

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

2611

else:

2612

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

2613

exc_info=e)

2221

2614

raise

2222

2615

except EOFError as e:

2223

2616

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

2224

"EOFError: {0}".format(e))

2617

"EOFError:",

2618

exc_info=e)

2225

2619

2226

2620

with PGPEngine() as pgp:

2227

for client_name, client in clients_data.iteritems():

2621

for client_name, client in clients_data.items():

2622

# Skip removed clients

2623

if client_name not in client_settings:

2624

continue

2625

2228

2626

# Decide which value to use after restoring saved state.

2229

2627

# We have three different values: Old config file,

2230

2628

# new config file, and saved state.

2235

2633

# For each value in new config, check if it

2236

2634

# differs from the old config value (Except for

2237

2635

# the "secret" attribute)

2238

if (name != "secret" and

2239

value != old_client_settings[client_name]

2240

[name]):

2636

if (name != "secret"

2637

and (value !=

2638

old_client_settings[client_name][name])):

2241

2639

client[name] = value

2242

2640

except KeyError:

2243

2641

pass

2244

2642

2245

2643

# Clients who has passed its expire date can still be

2246

# enabled if its last checker was successful. Clients

2644

# enabled if its last checker was successful. A Client

2247

2645

# whose checker succeeded before we stored its state is

2248

2646

# assumed to have successfully run all checkers during

2249

2647

# downtime.

2251

2649

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

2252

2650

if not client["last_checked_ok"]:

2253

2651

logger.warning(

2254

"disabling client {0} - Client never "

2255

"performed a successful checker"

2256

.format(client_name))

2652

"disabling client {} - Client never "

2653

"performed a successful checker".format(

2654

client_name))

2257

2655

client["enabled"] = False

2258

2656

elif client["last_checker_status"] != 0:

2259

2657

logger.warning(

2260

"disabling client {0} - Client "

2261

"last checker failed with error code {1}"

2262

.format(client_name,

2263

client["last_checker_status"]))

2658

"disabling client {} - Client last"

2659

" checker failed with error code"

2660

" {}".format(

2661

client_name,

2662

client["last_checker_status"]))

2264

2663

client["enabled"] = False

2265

2664

else:

2266

client["expires"] = (datetime.datetime

2267

.utcnow()

2268

+ client["timeout"])

2665

client["expires"] = (

2666

datetime.datetime.utcnow()

2667

+ client["timeout"])

2269

2668

logger.debug("Last checker succeeded,"

2270

" keeping {0} enabled"

2271

.format(client_name))

2669

" keeping {} enabled".format(

2670

client_name))

2272

2671

try:

2273

client["secret"] = (

2274

pgp.decrypt(client["encrypted_secret"],

2275

client_settings[client_name]

2276

["secret"]))

2672

client["secret"] = pgp.decrypt(

2673

client["encrypted_secret"],

2674

client_settings[client_name]["secret"])

2277

2675

except PGPError:

2278

2676

# If decryption fails, we use secret from new settings

2279

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

2280

.format(client_name))

2281

client["secret"] = (

2282

client_settings[client_name]["secret"])

2283

2677

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

2678

client_name))

2679

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

2680

["secret"])

2284

2681

2285

2682

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

2286

2683

for client_name in (set(old_client_settings)

2289

2686

for client_name in (set(client_settings)

2290

2687

- set(old_client_settings)):

2291

2688

clients_data[client_name] = client_settings[client_name]

2292

2689

2293

2690

# Create all client objects

2294

for client_name, client in clients_data.iteritems():

2691

for client_name, client in clients_data.items():

2295

2692

tcp_server.clients[client_name] = client_class(

2296

name = client_name, settings = client)

2693

name = client_name,

2694

settings = client,

2695

server_settings = server_settings)

2297

2696

2298

2697

if not tcp_server.clients:

2299

2698

logger.warning("No clients defined")

2300

2301

if not debug:

2302

try:

2303

with pidfile:

2304

pid = os.getpid()

2305

pidfile.write(str(pid) + "\n".encode("utf-8"))

2306

del pidfile

2307

except IOError:

2308

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

2309

pidfilename, pid)

2310

except NameError:

2311

# "pidfile" was never created

2312

pass

2699

2700

if not foreground:

2701

if pidfile is not None:

2702

try:

2703

with pidfile:

2704

pid = os.getpid()

2705

pidfile.write("{}\n".format(pid).encode("utf-8"))

2706

except IOError:

2707

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

2708

pidfilename, pid)

2709

del pidfile

2313

2710

del pidfilename

2314

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

2315

2711

2316

2712

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

2317

2713

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

2318

2714

2319

2715

if use_dbus:

2320

class MandosDBusService(dbus.service.Object):

2716

2717

@alternate_dbus_interfaces(

2718

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

2719

class MandosDBusService(DBusObjectWithProperties):

2321

2720

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

2721

2322

2722

def __init__(self):

2323

2723

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

2724

2324

2725

_interface = "se.recompile.Mandos"

2325

2726

2727

@dbus_interface_annotations(_interface)

2728

def _foo(self):

2729

return {

2730

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

2731

"false" }

2732

2326

2733

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

2327

2734

def ClientAdded(self, objpath):

2328

2735

"D-Bus signal"

2341

2748

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

2342

2749

def GetAllClients(self):

2343

2750

"D-Bus method"

2344

return dbus.Array(c.dbus_object_path

2345

for c in

2751

return dbus.Array(c.dbus_object_path for c in

2346

2752

tcp_server.clients.itervalues())

2347

2753

2348

2754

@dbus.service.method(_interface,

2350

2756

def GetAllClientsWithProperties(self):

2351

2757

"D-Bus method"

2352

2758

return dbus.Dictionary(

2353

((c.dbus_object_path, c.GetAll(""))

2354

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

2759

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

2760

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

2355

2761

signature="oa{sv}")

2356

2762

2357

2763

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

2370

2776

2371

2777

del _interface

2372

2778

2373

class MandosDBusServiceTransitional(MandosDBusService):

2374

__metaclass__ = AlternateDBusNamesMetaclass

2375

mandos_dbus_service = MandosDBusServiceTransitional()

2779

mandos_dbus_service = MandosDBusService()

2376

2780

2377

2781

def cleanup():

2378

2782

"Cleanup function; run on exit"

2379

service.cleanup()

2783

if zeroconf:

2784

service.cleanup()

2380

2785

2381

2786

multiprocessing.active_children()

2787

wnull.close()

2382

2788

if not (tcp_server.clients or client_settings):

2383

2789

return

2384

2790

2395

2801

2396

2802

# A list of attributes that can not be pickled

2397

2803

# + secret.

2398

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

2399

"checker"))

2400

for name, typ in (inspect.getmembers

2401

(dbus.service.Object)):

2804

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

2805

"checker", "server_settings" }

2806

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

2807

.Object):

2402

2808

exclude.add(name)

2403

2809

2404

2810

client_dict["encrypted_secret"] = (client

2411

2817

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

2412

2818

2413

2819

try:

2414

tempfd, tempname = tempfile.mkstemp(suffix=".pickle",

2415

prefix="clients-",

2416

dir=os.path.dirname

2417

(stored_state_path))

2418

with os.fdopen(tempfd, "wb") as stored_state:

2820

with tempfile.NamedTemporaryFile(

2821

mode='wb',

2822

suffix=".pickle",

2823

prefix='clients-',

2824

dir=os.path.dirname(stored_state_path),

2825

delete=False) as stored_state:

2419

2826

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

2827

tempname = stored_state.name

2420

2828

os.rename(tempname, stored_state_path)

2421

2829

except (IOError, OSError) as e:

2422

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

2423

.format(e))

2424

2830

if not debug:

2425

2831

try:

2426

2832

os.remove(tempname)

2427

2833

except NameError:

2428

2834

pass

2429

if e.errno not in set((errno.ENOENT, errno.EACCES,

2430

errno.EEXIST)):

2431

raise e

2835

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

2836

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

2837

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

2838

else:

2839

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

2840

exc_info=e)

2841

raise

2432

2842

2433

2843

# Delete all clients, and settings from config

2434

2844

while tcp_server.clients:

2439

2849

client.disable(quiet=True)

2440

2850

if use_dbus:

2441

2851

# Emit D-Bus signal

2442

mandos_dbus_service.ClientRemoved(client

2443

.dbus_object_path,

2444

client.name)

2852

mandos_dbus_service.ClientRemoved(

2853

client.dbus_object_path, client.name)

2445

2854

client_settings.clear()

2446

2855

2447

2856

atexit.register(cleanup)

2458

2867

tcp_server.server_activate()

2459

2868

2460

2869

# Find out what port we got

2461

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

2870

if zeroconf:

2871

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

2462

2872

if use_ipv6:

2463

2873

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

2464

" flowinfo %d, scope_id %d"

2465

% tcp_server.socket.getsockname())

2874

" flowinfo %d, scope_id %d",

2875

*tcp_server.socket.getsockname())

2466

2876

else: # IPv4

2467

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

2468

% tcp_server.socket.getsockname())

2877

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

2878

*tcp_server.socket.getsockname())

2469

2879

2470

2880

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

2471

2881

2472

2882

try:

2473

# From the Avahi example code

2474

try:

2475

service.activate()

2476

except dbus.exceptions.DBusException as error:

2477

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

2478

cleanup()

2479

sys.exit(1)

2480

# End of Avahi example code

2883

if zeroconf:

2884

# From the Avahi example code

2885

try:

2886

service.activate()

2887

except dbus.exceptions.DBusException as error:

2888

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

2889

cleanup()

2890

sys.exit(1)

2891

# End of Avahi example code

2481

2892

2482

2893

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

2483

2894

lambda *args, **kwargs:

2487

2898

logger.debug("Starting main loop")

2488

2899

main_loop.run()

2489

2900

except AvahiError as error:

2490

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

2901

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

2491

2902

cleanup()

2492

2903

sys.exit(1)

2493

2904

except KeyboardInterrupt:

2498

2909

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

2499

2910

cleanup()

2500

2911

2912

2501

2913

if __name__ == '__main__':

2502

2914

main()