/mandos/trunk : revision 525

1

#!/usr/bin/python2.7

1

#!/usr/bin/python

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

from future_builtins import *

38

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

67

65

import types

68

66

import binascii

69

67

import tempfile

70

import itertools

71

import collections

72

68

73

69

import dbus

74

70

import dbus.service

79

75

import ctypes.util

80

76

import xml.dom.minidom

81

77

import inspect

78

import GnuPGInterface

82

79

83

80

try:

84

81

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

88

85

except ImportError:

89

86

SO_BINDTODEVICE = None

90

87

91

if sys.version_info.major == 2:

92

str = unicode

93

94

version = "1.6.9"

88

version = "1.4.1"

95

89

stored_state_file = "clients.pickle"

96

90

97

91

logger = logging.getLogger()

98

syslogger = None

92

syslogger = (logging.handlers.SysLogHandler

93

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

94

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

99

95

100

96

try:

101

97

if_nametoindex = (ctypes.cdll.LoadLibrary

107

103

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

108

104

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

109

105

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

110

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

111

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

106

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

107

interface))

108

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

109

ifreq[16:20])[0]

112

110

return interface_index

113

111

114

112

115

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

113

def initlogger(level=logging.WARNING):

116

114

"""init logger and add loglevel"""

117

115

118

global syslogger

119

syslogger = (logging.handlers.SysLogHandler

120

(facility =

121

logging.handlers.SysLogHandler.LOG_DAEMON,

122

address = "/dev/log"))

123

116

syslogger.setFormatter(logging.Formatter

124

117

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

125

118

' %(message)s'))

126

119

logger.addHandler(syslogger)

127

120

128

if debug:

129

console = logging.StreamHandler()

130

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

131

' [%(process)d]:'

132

' %(levelname)s:'

133

' %(message)s'))

134

logger.addHandler(console)

121

console = logging.StreamHandler()

122

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

123

' [%(process)d]:'

124

' %(levelname)s:'

125

' %(message)s'))

126

logger.addHandler(console)

135

127

logger.setLevel(level)

136

128

137

129

143

135

class PGPEngine(object):

144

136

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

145

137

def __init__(self):

138

self.gnupg = GnuPGInterface.GnuPG()

146

139

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

147

self.gnupgargs = ['--batch',

148

'--home', self.tempdir,

149

'--force-mdc',

150

'--quiet',

151

'--no-use-agent']

140

self.gnupg = GnuPGInterface.GnuPG()

141

self.gnupg.options.meta_interactive = False

142

self.gnupg.options.homedir = self.tempdir

143

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

144

'--quiet'])

152

145

153

146

def __enter__(self):

154

147

return self

155

148

156

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

149

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

157

150

self._cleanup()

158

151

return False

159

152

176

169

def password_encode(self, password):

177

170

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

178

171

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

179

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

180

if len(encoded) > 2048:

181

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

182

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

183

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

184

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

185

return encoded

172

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

186

173

187

174

def encrypt(self, data, password):

188

passphrase = self.password_encode(password)

189

with tempfile.NamedTemporaryFile(dir=self.tempdir

190

) as passfile:

191

passfile.write(passphrase)

192

passfile.flush()

193

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

194

'--passphrase-file',

195

passfile.name]

196

+ self.gnupgargs,

197

stdin = subprocess.PIPE,

198

stdout = subprocess.PIPE,

199

stderr = subprocess.PIPE)

200

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

201

if proc.returncode != 0:

202

raise PGPError(err)

175

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

176

with open(os.devnull) as devnull:

177

try:

178

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

179

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

180

attach_fhs={'stderr': devnull})

181

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

182

f.write(data)

183

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

184

ciphertext = f.read()

185

proc.wait()

186

except IOError as e:

187

raise PGPError(e)

188

self.gnupg.passphrase = None

203

189

return ciphertext

204

190

205

191

def decrypt(self, data, password):

206

passphrase = self.password_encode(password)

207

with tempfile.NamedTemporaryFile(dir = self.tempdir

208

) as passfile:

209

passfile.write(passphrase)

210

passfile.flush()

211

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

212

'--passphrase-file',

213

passfile.name]

214

+ self.gnupgargs,

215

stdin = subprocess.PIPE,

216

stdout = subprocess.PIPE,

217

stderr = subprocess.PIPE)

218

decrypted_plaintext, err = proc.communicate(input

219

= data)

220

if proc.returncode != 0:

221

raise PGPError(err)

192

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

193

with open(os.devnull) as devnull:

194

try:

195

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

196

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

197

attach_fhs={'stderr': devnull})

198

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

199

f.write(data)

200

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

201

decrypted_plaintext = f.read()

202

proc.wait()

203

except IOError as e:

204

raise PGPError(e)

205

self.gnupg.passphrase = None

222

206

return decrypted_plaintext

223

207

224

208

209

225

210

class AvahiError(Exception):

226

211

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

227

212

self.value = value

228

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

229

**kwargs)

213

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

214

def __unicode__(self):

215

return unicode(repr(self.value))

230

216

231

217

class AvahiServiceError(AvahiError):

232

218

pass

243

229

Used to optionally bind to the specified interface.

244

230

name: string; Example: 'Mandos'

245

231

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

246

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

232

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

247

233

port: integer; what port to announce

248

234

TXT: list of strings; TXT record for the service

249

235

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

255

241

server: D-Bus Server

256

242

bus: dbus.SystemBus()

257

243

"""

258

259

244

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

260

245

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

261

246

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

274

259

self.server = None

275

260

self.bus = bus

276

261

self.entry_group_state_changed_match = None

277

278

def rename(self, remove=True):

262

def rename(self):

279

263

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

280

264

if self.rename_count >= self.max_renames:

281

265

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

282

266

" after %i retries, exiting.",

283

267

self.rename_count)

284

268

raise AvahiServiceError("Too many renames")

285

self.name = str(self.server

286

.GetAlternativeServiceName(self.name))

287

self.rename_count += 1

269

self.name = unicode(self.server

270

.GetAlternativeServiceName(self.name))

288

271

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

289

272

self.name)

290

if remove:

291

self.remove()

273

self.remove()

292

274

try:

293

275

self.add()

294

276

except dbus.exceptions.DBusException as error:

295

if (error.get_dbus_name()

296

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

297

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

298

return self.rename(remove=False)

299

else:

300

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

301

self.cleanup()

302

os._exit(1)

303

277

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

278

self.cleanup()

279

os._exit(1)

280

self.rename_count += 1

304

281

def remove(self):

305

282

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

306

283

if self.entry_group_state_changed_match is not None:

308

285

self.entry_group_state_changed_match = None

309

286

if self.group is not None:

310

287

self.group.Reset()

311

312

288

def add(self):

313

289

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

314

290

self.remove()

331

307

dbus.UInt16(self.port),

332

308

avahi.string_array_to_txt_array(self.TXT))

333

309

self.group.Commit()

334

335

310

def entry_group_state_changed(self, state, error):

336

311

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

337

312

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

343

318

self.rename()

344

319

elif state == avahi.ENTRY_GROUP_FAILURE:

345

320

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

346

str(error))

347

raise AvahiGroupError("State changed: {!s}"

348

.format(error))

349

321

unicode(error))

322

raise AvahiGroupError("State changed: %s"

323

% unicode(error))

350

324

def cleanup(self):

351

325

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

352

326

if self.group is not None:

357

331

pass

358

332

self.group = None

359

333

self.remove()

360

361

334

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

362

335

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

363

336

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

382

355

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

383

356

else:

384

357

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

385

386

358

def activate(self):

387

359

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

388

360

if self.server is None:

395

367

self.server_state_changed)

396

368

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

397

369

398

399

370

class AvahiServiceToSyslog(AvahiService):

400

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

371

def rename(self):

401

372

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

402

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

373

ret = AvahiService.rename(self)

403

374

syslogger.setFormatter(logging.Formatter

404

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

405

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

406

.format(self.name)))

375

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

376

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

377

% self.name))

407

378

return ret

408

379

409

380

def timedelta_to_milliseconds(td):

381

"Convert a datetime.timedelta() to milliseconds"

382

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

383

+ (td.seconds * 1000)

384

+ (td.microseconds // 1000))

385

410

386

class Client(object):

411

387

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

412

388

437

413

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

438

414

last_checker_status: integer between 0 and 255 reflecting exit

439

415

status of last checker. -1 reflects crashed

440

checker, -2 means no checker completed yet.

416

checker, or None.

441

417

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

442

418

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

443

419

D-Bus identifiers

444

420

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

445

421

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

446

422

until this client is disabled

447

extended_timeout: extra long timeout when secret has been sent

423

extended_timeout: extra long timeout when password has been sent

448

424

runtime_expansions: Allowed attributes for runtime expansion.

449

425

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

450

426

disabled, or None

451

server_settings: The server_settings dict from main()

452

427

"""

453

428

454

429

runtime_expansions = ("approval_delay", "approval_duration",

455

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

456

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

457

"last_approval_request", "last_checked_ok",

430

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

431

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

458

432

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

459

client_defaults = { "timeout": "PT5M",

460

"extended_timeout": "PT15M",

461

"interval": "PT2M",

433

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

434

"extended_timeout": "15m",

435

"interval": "2m",

462

436

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

463

437

"host": "",

464

"approval_delay": "PT0S",

465

"approval_duration": "PT1S",

438

"approval_delay": "0s",

439

"approval_duration": "1s",

466

440

"approved_by_default": "True",

467

441

"enabled": "True",

468

442

}

469

443

444

def timeout_milliseconds(self):

445

"Return the 'timeout' attribute in milliseconds"

446

return timedelta_to_milliseconds(self.timeout)

447

448

def extended_timeout_milliseconds(self):

449

"Return the 'extended_timeout' attribute in milliseconds"

450

return timedelta_to_milliseconds(self.extended_timeout)

451

452

def interval_milliseconds(self):

453

"Return the 'interval' attribute in milliseconds"

454

return timedelta_to_milliseconds(self.interval)

455

456

def approval_delay_milliseconds(self):

457

return timedelta_to_milliseconds(self.approval_delay)

458

470

459

@staticmethod

471

460

def config_parser(config):

472

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

461

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

473

462

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

474

with exceptions for any special settings as defined above.

475

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

476

value given the same arguments.

477

"""

463

with exceptions for any special settings as defined above"""

478

464

settings = {}

479

465

for client_name in config.sections():

480

466

section = dict(config.items(client_name))

484

470

# Reformat values from string types to Python types

485

471

client["approved_by_default"] = config.getboolean(

486

472

client_name, "approved_by_default")

487

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

488

"enabled")

473

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

489

474

490

# Uppercase and remove spaces from fingerprint for later

491

# comparison purposes with return value from the

492

# fingerprint() function

493

475

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

494

476

.replace(" ", ""))

495

477

if "secret" in section:

500

482

"rb") as secfile:

501

483

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

502

484

else:

503

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

504

.format(section))

485

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

486

% section)

505

487

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

506

488

client["extended_timeout"] = string_to_delta(

507

489

section["extended_timeout"])

513

495

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

514

496

client["last_approval_request"] = None

515

497

client["last_checked_ok"] = None

516

client["last_checker_status"] = -2

517

498

client["last_checker_status"] = None

499

if client["enabled"]:

500

client["last_enabled"] = datetime.datetime.utcnow()

501

client["expires"] = (datetime.datetime.utcnow()

502

+ client["timeout"])

503

else:

504

client["last_enabled"] = None

505

client["expires"] = None

506

518

507

return settings

519

520

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

508

509

510

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

511

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

512

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

513

attribute."""

521

514

self.name = name

522

if server_settings is None:

523

server_settings = {}

524

self.server_settings = server_settings

525

515

# adding all client settings

526

for setting, value in settings.items():

516

for setting, value in settings.iteritems():

527

517

setattr(self, setting, value)

528

518

529

if self.enabled:

530

if not hasattr(self, "last_enabled"):

531

self.last_enabled = datetime.datetime.utcnow()

532

if not hasattr(self, "expires"):

533

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

534

+ self.timeout)

535

else:

536

self.last_enabled = None

537

self.expires = None

538

539

519

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

520

# Uppercase and remove spaces from fingerprint for later

521

# comparison purposes with return value from the fingerprint()

522

# function

540

523

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

541

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

542

datetime.datetime.utcnow())

543

524

self.created = settings.get("created", datetime.datetime.utcnow())

525

544

526

# attributes specific for this server instance

545

527

self.checker = None

546

528

self.checker_initiator_tag = None

574

556

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

575

557

# Already enabled

576

558

return

559

self.send_changedstate()

577

560

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

578

561

self.enabled = True

579

562

self.last_enabled = datetime.datetime.utcnow()

580

563

self.init_checker()

581

self.send_changedstate()

582

564

583

565

def disable(self, quiet=True):

584

566

"""Disable this client."""

585

567

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

586

568

return False

587

569

if not quiet:

570

self.send_changedstate()

571

if not quiet:

588

572

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

589

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

573

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

590

574

gobject.source_remove(self.disable_initiator_tag)

591

575

self.disable_initiator_tag = None

592

576

self.expires = None

593

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

577

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

594

578

gobject.source_remove(self.checker_initiator_tag)

595

579

self.checker_initiator_tag = None

596

580

self.stop_checker()

597

581

self.enabled = False

598

if not quiet:

599

self.send_changedstate()

600

582

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

601

583

return False

602

584

606

588

def init_checker(self):

607

589

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

608

590

# and every interval from then on.

609

if self.checker_initiator_tag is not None:

610

gobject.source_remove(self.checker_initiator_tag)

611

591

self.checker_initiator_tag = (gobject.timeout_add

612

(int(self.interval

613

.total_seconds() * 1000),

592

(self.interval_milliseconds(),

614

593

self.start_checker))

615

594

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

616

if self.disable_initiator_tag is not None:

617

gobject.source_remove(self.disable_initiator_tag)

618

595

self.disable_initiator_tag = (gobject.timeout_add

619

(int(self.timeout

620

.total_seconds() * 1000),

621

self.disable))

596

(self.timeout_milliseconds(),

597

self.disable))

622

598

# Also start a new checker *right now*.

623

599

self.start_checker()

624

600

640

616

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

641

617

vars(self))

642

618

643

def checked_ok(self):

644

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

645

self.last_checked_ok = datetime.datetime.utcnow()

646

self.last_checker_status = 0

647

self.bump_timeout()

648

649

def bump_timeout(self, timeout=None):

650

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

619

def checked_ok(self, timeout=None):

620

"""Bump up the timeout for this client.

621

622

This should only be called when the client has been seen,

623

alive and well.

624

"""

651

625

if timeout is None:

652

626

timeout = self.timeout

627

self.last_checked_ok = datetime.datetime.utcnow()

653

628

if self.disable_initiator_tag is not None:

654

629

gobject.source_remove(self.disable_initiator_tag)

655

self.disable_initiator_tag = None

656

630

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

657

631

self.disable_initiator_tag = (gobject.timeout_add

658

(int(timeout.total_seconds()

659

* 1000), self.disable))

632

(timedelta_to_milliseconds

633

(timeout), self.disable))

660

634

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

661

635

662

636

def need_approval(self):

668

642

If a checker already exists, leave it running and do

669

643

nothing."""

670

644

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

671

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

672

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

673

# would inevitably timeout, since no checker would get a

674

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

645

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

646

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

647

# client would inevitably timeout, since no checker would get

648

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

675

649

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

676

650

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

677

651

# should be.

679

653

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

680

654

try:

681

655

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

682

except AttributeError:

683

pass

684

except OSError as error:

685

if error.errno != errno.ECHILD:

686

raise

656

except (AttributeError, OSError) as error:

657

if (isinstance(error, OSError)

658

and error.errno != errno.ECHILD):

659

raise error

687

660

else:

688

661

if pid:

689

662

logger.warning("Checker was a zombie")

692

665

self.current_checker_command)

693

666

# Start a new checker if needed

694

667

if self.checker is None:

695

# Escape attributes for the shell

696

escaped_attrs = { attr:

697

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

698

for attr in self.runtime_expansions }

699

668

try:

700

command = self.checker_command % escaped_attrs

701

except TypeError as error:

702

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

703

self.checker_command, exc_info=error)

704

return True # Try again later

669

# In case checker_command has exactly one % operator

670

command = self.checker_command % self.host

671

except TypeError:

672

# Escape attributes for the shell

673

escaped_attrs = dict(

674

(attr,

675

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

676

errors=

677

'replace')))

678

for attr in

679

self.runtime_expansions)

680

681

try:

682

command = self.checker_command % escaped_attrs

683

except TypeError as error:

684

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

685

' %s', self.checker_command, error)

686

return True # Try again later

705

687

self.current_checker_command = command

706

688

try:

707

689

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

710

692

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

711

693

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

712

694

# always replaced by /dev/null.)

713

# The exception is when not debugging but nevertheless

714

# running in the foreground; use the previously

715

# created wnull.

716

popen_args = {}

717

if (not self.server_settings["debug"]

718

and self.server_settings["foreground"]):

719

popen_args.update({"stdout": wnull,

720

"stderr": wnull })

721

695

self.checker = subprocess.Popen(command,

722

696

close_fds=True,

723

shell=True, cwd="/",

724

**popen_args)

725

except OSError as error:

726

logger.error("Failed to start subprocess",

727

exc_info=error)

728

return True

729

self.checker_callback_tag = (gobject.child_watch_add

730

(self.checker.pid,

731

self.checker_callback,

732

data=command))

733

# The checker may have completed before the gobject

734

# watch was added. Check for this.

735

try:

697

shell=True, cwd="/")

698

self.checker_callback_tag = (gobject.child_watch_add

699

(self.checker.pid,

700

self.checker_callback,

701

data=command))

702

# The checker may have completed before the gobject

703

# watch was added. Check for this.

736

704

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

705

if pid:

706

gobject.source_remove(self.checker_callback_tag)

707

self.checker_callback(pid, status, command)

737

708

except OSError as error:

738

if error.errno == errno.ECHILD:

739

# This should never happen

740

logger.error("Child process vanished",

741

exc_info=error)

742

return True

743

raise

744

if pid:

745

gobject.source_remove(self.checker_callback_tag)

746

self.checker_callback(pid, status, command)

709

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

710

error)

747

711

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

748

712

return True

749

713

756

720

return

757

721

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

758

722

try:

759

self.checker.terminate()

723

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

760

724

#time.sleep(0.5)

761

725

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

762

# self.checker.kill()

726

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

763

727

except OSError as error:

764

728

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

765

729

raise

782

746

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

783

747

if byte_arrays and signature != "ay":

784

748

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

785

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

749

" signature %r" % signature)

786

750

def decorator(func):

787

751

func._dbus_is_property = True

788

752

func._dbus_interface = dbus_interface

796

760

return decorator

797

761

798

762

799

def dbus_interface_annotations(dbus_interface):

800

"""Decorator for marking functions returning interface annotations

801

802

Usage:

803

804

@dbus_interface_annotations("org.example.Interface")

805

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

806

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

807

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

808

"false"}

809

"""

810

def decorator(func):

811

func._dbus_is_interface = True

812

func._dbus_interface = dbus_interface

813

func._dbus_name = dbus_interface

814

return func

815

return decorator

816

817

818

def dbus_annotations(annotations):

819

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

820

Usage:

821

822

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

823

"org.freedesktop.DBus.Property."

824

"EmitsChangedSignal": "false"})

825

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

826

access="r")

827

def Property_dbus_property(self):

828

return dbus.Boolean(False)

829

"""

830

def decorator(func):

831

func._dbus_annotations = annotations

832

return func

833

return decorator

834

835

836

763

class DBusPropertyException(dbus.exceptions.DBusException):

837

764

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

838

765

"""

839

pass

766

def __unicode__(self):

767

return unicode(str(self))

768

840

769

841

770

class DBusPropertyAccessException(DBusPropertyException):

842

771

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

859

788

"""

860

789

861

790

@staticmethod

862

def _is_dbus_thing(thing):

863

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

864

865

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

866

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

867

"""

868

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

869

False)

791

def _is_dbus_property(obj):

792

return getattr(obj, "_dbus_is_property", False)

870

793

871

def _get_all_dbus_things(self, thing):

794

def _get_all_dbus_properties(self):

872

795

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

873

796

"""

874

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

875

name),

876

athing.__get__(self))

797

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

877

798

for cls in self.__class__.__mro__

878

for name, athing in

879

inspect.getmembers(cls,

880

self._is_dbus_thing(thing)))

799

for name, prop in

800

inspect.getmembers(cls, self._is_dbus_property))

881

801

882

802

def _get_dbus_property(self, interface_name, property_name):

883

803

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

885

805

"""

886

806

for cls in self.__class__.__mro__:

887

807

for name, value in (inspect.getmembers

888

(cls,

889

self._is_dbus_thing("property"))):

808

(cls, self._is_dbus_property)):

890

809

if (value._dbus_name == property_name

891

810

and value._dbus_interface == interface_name):

892

811

return value.__get__(self)

920

839

# The byte_arrays option is not supported yet on

921

840

# signatures other than "ay".

922

841

if prop._dbus_signature != "ay":

923

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

924

"'ay' signature {!r}"

925

.format(prop._dbus_signature))

926

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

927

for byte in value))

842

raise ValueError

843

value = dbus.ByteArray(''.join(unichr(byte)

844

for byte in value))

928

845

prop(value)

929

846

930

847

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

936

853

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

937

854

"""

938

855

properties = {}

939

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

856

for name, prop in self._get_all_dbus_properties():

940

857

if (interface_name

941

858

and interface_name != prop._dbus_interface):

942

859

# Interface non-empty but did not match

952

869

value.variant_level+1)

953

870

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

954

871

955

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

956

def PropertiesChanged(self, interface_name, changed_properties,

957

invalidated_properties):

958

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

959

standard.

960

"""

961

pass

962

963

872

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

964

873

out_signature="s",

965

874

path_keyword='object_path',

966

875

connection_keyword='connection')

967

876

def Introspect(self, object_path, connection):

968

"""Overloading of standard D-Bus method.

969

970

Inserts property tags and interface annotation tags.

877

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

971

878

"""

972

879

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

973

880

connection)

980

887

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

981

888

return e

982

889

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

983

# Add property tags

984

890

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

985

891

for name, prop

986

in self._get_all_dbus_things("property")

892

in self._get_all_dbus_properties()

987

893

if prop._dbus_interface

988

894

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

989

895

if_tag.appendChild(tag)

990

# Add annotation tags

991

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

992

for tag in if_tag.getElementsByTagName(typ):

993

annots = dict()

994

for name, prop in (self.

995

_get_all_dbus_things(typ)):

996

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

997

and prop._dbus_interface

998

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

999

annots.update(getattr

1000

(prop,

1001

"_dbus_annotations",

1002

{}))

1003

for name, value in annots.items():

1004

ann_tag = document.createElement(

1005

"annotation")

1006

ann_tag.setAttribute("name", name)

1007

ann_tag.setAttribute("value", value)

1008

tag.appendChild(ann_tag)

1009

# Add interface annotation tags

1010

for annotation, value in dict(

1011

itertools.chain.from_iterable(

1012

annotations().items()

1013

for name, annotations in

1014

self._get_all_dbus_things("interface")

1015

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

1016

)).items():

1017

ann_tag = document.createElement("annotation")

1018

ann_tag.setAttribute("name", annotation)

1019

ann_tag.setAttribute("value", value)

1020

if_tag.appendChild(ann_tag)

1021

896

# Add the names to the return values for the

1022

897

# "org.freedesktop.DBus.Properties" methods

1023

898

if (if_tag.getAttribute("name")

1038

913

except (AttributeError, xml.dom.DOMException,

1039

914

xml.parsers.expat.ExpatError) as error:

1040

915

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

1041

exc_info=error)

916

error)

1042

917

return xmlstring

1043

918

1044

919

1045

def datetime_to_dbus(dt, variant_level=0):

920

def datetime_to_dbus (dt, variant_level=0):

1046

921

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

1047

922

if dt is None:

1048

923

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

1050

925

variant_level=variant_level)

1051

926

1052

927

1053

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1054

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

1055

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

1056

interface names according to the "alt_interface_names" mapping.

1057

Usage:

1058

1059

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

1060

"net.example.AlternateInterface"})

1061

class SampleDBusObject(dbus.service.Object):

1062

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

1063

def SampleDBusMethod():

1064

pass

1065

1066

The above "SampleDBusMethod" on "SampleDBusObject" will be

1067

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

1068

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

1069

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

1070

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

1071

1072

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

1073

(from DBusObjectWithProperties) and interfaces (from the

1074

dbus_interface_annotations decorator).

928

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

929

.__metaclass__):

930

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

931

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

1075

932

"""

1076

def wrapper(cls):

1077

for orig_interface_name, alt_interface_name in (

1078

alt_interface_names.items()):

1079

attr = {}

1080

interface_names = set()

1081

# Go though all attributes of the class

1082

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

933

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

934

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

935

# methods, signals, or properties in them

936

for base in (b for b in bases

937

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

938

# Go though all attributes of the base class

939

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

1083

940

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

1084

941

# with the wrong interface name

1085

942

if (not hasattr(attribute, "_dbus_interface")

1086

943

or not attribute._dbus_interface

1087

.startswith(orig_interface_name)):

944

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

1088

945

continue

1089

946

# Create an alternate D-Bus interface name based on

1090

947

# the current name

1091

948

alt_interface = (attribute._dbus_interface

1092

.replace(orig_interface_name,

1093

alt_interface_name))

1094

interface_names.add(alt_interface)

949

.replace("se.recompile.Mandos",

950

"se.bsnet.fukt.Mandos"))

1095

951

# Is this a D-Bus signal?

1096

952

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

1097

# Extract the original non-method undecorated

1098

# function by black magic

953

# Extract the original non-method function by

954

# black magic

1099

955

nonmethod_func = (dict(

1100

956

zip(attribute.func_code.co_freevars,

1101

957

attribute.__closure__))["func"]

1112

968

nonmethod_func.func_name,

1113

969

nonmethod_func.func_defaults,

1114

970

nonmethod_func.func_closure)))

1115

# Copy annotations, if any

1116

try:

1117

new_function._dbus_annotations = (

1118

dict(attribute._dbus_annotations))

1119

except AttributeError:

1120

pass

1121

971

# Define a creator of a function to call both the

1122

# original and alternate functions, so both the

1123

# original and alternate signals gets sent when

1124

# the function is called

972

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

973

# signals gets sent when the function is called

1125

974

def fixscope(func1, func2):

1126

975

"""This function is a scope container to pass

1127

976

func1 and func2 to the "call_both" function

1134

983

return call_both

1135

984

# Create the "call_both" function and add it to

1136

985

# the class

1137

attr[attrname] = fixscope(attribute, new_function)

986

attr[attrname] = fixscope(attribute,

987

new_function)

1138

988

# Is this a D-Bus method?

1139

989

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

1140

990

# Create a new, but exactly alike, function

1151

1001

attribute.func_name,

1152

1002

attribute.func_defaults,

1153

1003

attribute.func_closure)))

1154

# Copy annotations, if any

1155

try:

1156

attr[attrname]._dbus_annotations = (

1157

dict(attribute._dbus_annotations))

1158

except AttributeError:

1159

pass

1160

1004

# Is this a D-Bus property?

1161

1005

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

1162

1006

# Create a new, but exactly alike, function

1176

1020

attribute.func_name,

1177

1021

attribute.func_defaults,

1178

1022

attribute.func_closure)))

1179

# Copy annotations, if any

1180

try:

1181

attr[attrname]._dbus_annotations = (

1182

dict(attribute._dbus_annotations))

1183

except AttributeError:

1184

pass

1185

# Is this a D-Bus interface?

1186

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

1187

# Create a new, but exactly alike, function

1188

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

1189

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

1190

# to the class.

1191

attr[attrname] = (dbus_interface_annotations

1192

(alt_interface)

1193

(types.FunctionType

1194

(attribute.func_code,

1195

attribute.func_globals,

1196

attribute.func_name,

1197

attribute.func_defaults,

1198

attribute.func_closure)))

1199

if deprecate:

1200

# Deprecate all alternate interfaces

1201

iname="_AlternateDBusNames_interface_annotation{}"

1202

for interface_name in interface_names:

1203

@dbus_interface_annotations(interface_name)

1204

def func(self):

1205

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

1206

"true" }

1207

# Find an unused name

1208

for aname in (iname.format(i)

1209

for i in itertools.count()):

1210

if aname not in attr:

1211

attr[aname] = func

1212

break

1213

if interface_names:

1214

# Replace the class with a new subclass of it with

1215

# methods, signals, etc. as created above.

1216

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

1217

(cls,), attr)

1218

return cls

1219

return wrapper

1220

1221

1222

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

1223

"se.bsnet.fukt.Mandos"})

1023

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

1024

1025

1224

1026

class ClientDBus(Client, DBusObjectWithProperties):

1225

1027

"""A Client class using D-Bus

1226

1028

1232

1034

runtime_expansions = (Client.runtime_expansions

1233

1035

+ ("dbus_object_path",))

1234

1036

1235

_interface = "se.recompile.Mandos.Client"

1236

1237

1037

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

1238

1038

1239

1039

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

1240

1040

self.bus = bus

1241

1041

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

1042

self._approvals_pending = 0

1043

1044

self._approvals_pending = 0

1242

1045

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

1243

1046

# the D-Bus

1244

client_object_name = str(self.name).translate(

1047

client_object_name = unicode(self.name).translate(

1245

1048

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

1246

1049

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

1247

1050

self.dbus_object_path = (dbus.ObjectPath

1248

1051

("/clients/" + client_object_name))

1249

1052

DBusObjectWithProperties.__init__(self, self.bus,

1250

1053

self.dbus_object_path)

1251

1054

1252

1055

def notifychangeproperty(transform_func,

1253

1056

dbus_name, type_func=lambda x: x,

1254

variant_level=1, invalidate_only=False,

1255

_interface=_interface):

1057

variant_level=1):

1256

1058

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

1257

1059

its changes to DBus.

1258

1060

1263

1065

to the D-Bus. Default: no transform

1264

1066

variant_level: D-Bus variant level. Default: 1

1265

1067

"""

1266

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

1068

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

1267

1069

def setter(self, value):

1268

1070

if hasattr(self, "dbus_object_path"):

1269

1071

if (not hasattr(self, attrname) or

1270

1072

type_func(getattr(self, attrname, None))

1271

1073

!= type_func(value)):

1272

if invalidate_only:

1273

self.PropertiesChanged(_interface,

1274

dbus.Dictionary(),

1275

dbus.Array

1276

((dbus_name,)))

1277

else:

1278

dbus_value = transform_func(type_func(value),

1279

variant_level

1280

=variant_level)

1281

self.PropertyChanged(dbus.String(dbus_name),

1282

dbus_value)

1283

self.PropertiesChanged(_interface,

1284

dbus.Dictionary({

1285

dbus.String(dbus_name):

1286

dbus_value }), dbus.Array())

1074

dbus_value = transform_func(type_func(value),

1075

variant_level

1076

=variant_level)

1077

self.PropertyChanged(dbus.String(dbus_name),

1078

dbus_value)

1287

1079

setattr(self, attrname, value)

1288

1080

1289

1081

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

1290

1082

1083

1291

1084

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1292

1085

approvals_pending = notifychangeproperty(dbus.Boolean,

1293

1086

"ApprovalPending",

1300

1093

checker is not None)

1301

1094

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1302

1095

"LastCheckedOK")

1303

last_checker_status = notifychangeproperty(dbus.Int16,

1304

"LastCheckerStatus")

1305

1096

last_approval_request = notifychangeproperty(

1306

1097

datetime_to_dbus, "LastApprovalRequest")

1307

1098

approved_by_default = notifychangeproperty(dbus.Boolean,

1309

1100

approval_delay = notifychangeproperty(dbus.UInt64,

1310

1101

"ApprovalDelay",

1311

1102

type_func =

1312

lambda td: td.total_seconds()

1313

* 1000)

1103

timedelta_to_milliseconds)

1314

1104

approval_duration = notifychangeproperty(

1315

1105

dbus.UInt64, "ApprovalDuration",

1316

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

1106

type_func = timedelta_to_milliseconds)

1317

1107

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

1318

1108

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

1319

type_func = lambda td:

1320

td.total_seconds() * 1000)

1109

type_func =

1110

timedelta_to_milliseconds)

1321

1111

extended_timeout = notifychangeproperty(

1322

1112

dbus.UInt64, "ExtendedTimeout",

1323

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

1113

type_func = timedelta_to_milliseconds)

1324

1114

interval = notifychangeproperty(dbus.UInt64,

1325

1115

"Interval",

1326

1116

type_func =

1327

lambda td: td.total_seconds()

1328

* 1000)

1117

timedelta_to_milliseconds)

1329

1118

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

1330

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

1331

invalidate_only=True)

1332

1119

1333

1120

del notifychangeproperty

1334

1121

1361

1148

*args, **kwargs)

1362

1149

1363

1150

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

1364

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

1151

old_checker = self.checker

1152

if self.checker is not None:

1153

old_checker_pid = self.checker.pid

1154

else:

1155

old_checker_pid = None

1365

1156

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

1366

1157

# Only if new checker process was started

1367

1158

if (self.checker is not None

1375

1166

return False

1376

1167

1377

1168

def approve(self, value=True):

1169

self.send_changedstate()

1378

1170

self.approved = value

1379

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

1380

* 1000), self._reset_approved)

1381

self.send_changedstate()

1171

gobject.timeout_add(timedelta_to_milliseconds

1172

(self.approval_duration),

1173

self._reset_approved)

1174

1382

1175

1383

1176

## D-Bus methods, signals & properties

1384

1385

## Interfaces

1177

_interface = "se.recompile.Mandos.Client"

1386

1178

1387

1179

## Signals

1388

1180

1399

1191

pass

1400

1192

1401

1193

# PropertyChanged - signal

1402

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

1403

1194

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

1404

1195

def PropertyChanged(self, property, value):

1405

1196

"D-Bus signal"

1426

1217

"D-Bus signal"

1427

1218

return self.need_approval()

1428

1219

1220

# NeRwequest - signal

1221

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

1222

def NewRequest(self, ip):

1223

"""D-Bus signal

1224

Is sent after a client request a password.

1225

"""

1226

pass

1227

1429

1228

## Methods

1430

1229

1431

1230

# Approve - method

1481

1280

access="readwrite")

1482

1281

def ApprovalDelay_dbus_property(self, value=None):

1483

1282

if value is None: # get

1484

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

1485

* 1000)

1283

return dbus.UInt64(self.approval_delay_milliseconds())

1486

1284

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

1487

1285

1488

1286

# ApprovalDuration - property

1490

1288

access="readwrite")

1491

1289

def ApprovalDuration_dbus_property(self, value=None):

1492

1290

if value is None: # get

1493

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

1494

* 1000)

1291

return dbus.UInt64(timedelta_to_milliseconds(

1292

self.approval_duration))

1495

1293

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

1496

1294

1497

1295

# Name - property

1510

1308

def Host_dbus_property(self, value=None):

1511

1309

if value is None: # get

1512

1310

return dbus.String(self.host)

1513

self.host = str(value)

1311

self.host = unicode(value)

1514

1312

1515

1313

# Created - property

1516

1314

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

1542

1340

return

1543

1341

return datetime_to_dbus(self.last_checked_ok)

1544

1342

1545

# LastCheckerStatus - property

1546

@dbus_service_property(_interface, signature="n",

1547

access="read")

1548

def LastCheckerStatus_dbus_property(self):

1549

return dbus.Int16(self.last_checker_status)

1550

1551

1343

# Expires - property

1552

1344

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

1553

1345

def Expires_dbus_property(self):

1563

1355

access="readwrite")

1564

1356

def Timeout_dbus_property(self, value=None):

1565

1357

if value is None: # get

1566

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

1567

old_timeout = self.timeout

1358

return dbus.UInt64(self.timeout_milliseconds())

1568

1359

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

1569

# Reschedule disabling

1570

if self.enabled:

1571

now = datetime.datetime.utcnow()

1572

self.expires += self.timeout - old_timeout

1573

if self.expires <= now:

1574

# The timeout has passed

1575

self.disable()

1576

else:

1577

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

1578

is None):

1579

return

1580

gobject.source_remove(self.disable_initiator_tag)

1581

self.disable_initiator_tag = (

1582

gobject.timeout_add(

1583

int((self.expires - now).total_seconds()

1584

* 1000), self.disable))

1360

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

1361

return

1362

# Reschedule timeout

1363

gobject.source_remove(self.disable_initiator_tag)

1364

self.disable_initiator_tag = None

1365

self.expires = None

1366

time_to_die = timedelta_to_milliseconds((self

1367

.last_checked_ok

1368

+ self.timeout)

1369

- datetime.datetime

1370

.utcnow())

1371

if time_to_die <= 0:

1372

# The timeout has passed

1373

self.disable()

1374

else:

1375

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

1376

+ datetime.timedelta(milliseconds =

1377

time_to_die))

1378

self.disable_initiator_tag = (gobject.timeout_add

1379

(time_to_die, self.disable))

1585

1380

1586

1381

# ExtendedTimeout - property

1587

1382

@dbus_service_property(_interface, signature="t",

1588

1383

access="readwrite")

1589

1384

def ExtendedTimeout_dbus_property(self, value=None):

1590

1385

if value is None: # get

1591

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

1592

* 1000)

1386

return dbus.UInt64(self.extended_timeout_milliseconds())

1593

1387

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

1594

1388

1595

1389

# Interval - property

1597

1391

access="readwrite")

1598

1392

def Interval_dbus_property(self, value=None):

1599

1393

if value is None: # get

1600

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

1394

return dbus.UInt64(self.interval_milliseconds())

1601

1395

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

1602

1396

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

1603

1397

return

1614

1408

def Checker_dbus_property(self, value=None):

1615

1409

if value is None: # get

1616

1410

return dbus.String(self.checker_command)

1617

self.checker_command = str(value)

1411

self.checker_command = unicode(value)

1618

1412

1619

1413

# CheckerRunning - property

1620

1414

@dbus_service_property(_interface, signature="b",

1636

1430

@dbus_service_property(_interface, signature="ay",

1637

1431

access="write", byte_arrays=True)

1638

1432

def Secret_dbus_property(self, value):

1639

self.secret = bytes(value)

1433

self.secret = str(value)

1640

1434

1641

1435

del _interface

1642

1436

1667

1461

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

1668

1462

1669

1463

1464

class ClientDBusTransitional(ClientDBus):

1465

__metaclass__ = AlternateDBusNamesMetaclass

1466

1467

1670

1468

class ClientHandler(socketserver.BaseRequestHandler, object):

1671

1469

"""A class to handle client connections.

1672

1470

1676

1474

def handle(self):

1677

1475

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

1678

1476

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

1679

str(self.client_address))

1477

unicode(self.client_address))

1680

1478

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

1681

1479

self.server.child_pipe.fileno())

1682

1480

1708

1506

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

1709

1507

try:

1710

1508

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

1711

raise RuntimeError(line)

1509

raise RuntimeError

1712

1510

except (ValueError, IndexError, RuntimeError) as error:

1713

1511

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

1714

1512

return

1740

1538

except KeyError:

1741

1539

return

1742

1540

1541

if self.server.use_dbus:

1542

# Emit D-Bus signal

1543

client.NewRequest(str(self.client_address))

1544

1743

1545

if client.approval_delay:

1744

1546

delay = client.approval_delay

1745

1547

client.approvals_pending += 1

1763

1565

if self.server.use_dbus:

1764

1566

# Emit D-Bus signal

1765

1567

client.NeedApproval(

1766

client.approval_delay.total_seconds()

1767

* 1000, client.approved_by_default)

1568

client.approval_delay_milliseconds(),

1569

client.approved_by_default)

1768

1570

else:

1769

1571

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

1770

1572

client.name)

1776

1578

#wait until timeout or approved

1777

1579

time = datetime.datetime.now()

1778

1580

client.changedstate.acquire()

1779

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

1581

(client.changedstate.wait

1582

(float(client.timedelta_to_milliseconds(delay)

1583

/ 1000)))

1780

1584

client.changedstate.release()

1781

1585

time2 = datetime.datetime.now()

1782

1586

if (time2 - time) >= delay:

1798

1602

try:

1799

1603

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

1800

1604

except gnutls.errors.GNUTLSError as error:

1801

logger.warning("gnutls send failed",

1802

exc_info=error)

1605

logger.warning("gnutls send failed")

1803

1606

return

1804

1607

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

1805

1608

sent, len(client.secret)

1808

1611

1809

1612

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

1810

1613

# bump the timeout using extended_timeout

1811

client.bump_timeout(client.extended_timeout)

1614

client.checked_ok(client.extended_timeout)

1812

1615

if self.server.use_dbus:

1813

1616

# Emit D-Bus signal

1814

1617

client.GotSecret()

1819

1622

try:

1820

1623

session.bye()

1821

1624

except gnutls.errors.GNUTLSError as error:

1822

logger.warning("GnuTLS bye failed",

1823

exc_info=error)

1625

logger.warning("GnuTLS bye failed")

1824

1626

1825

1627

@staticmethod

1826

1628

def peer_certificate(session):

1898

1700

def process_request(self, request, address):

1899

1701

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

1900

1702

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

1901

args = (request, address))

1703

args = (request,

1704

address))

1902

1705

proc.start()

1903

1706

return proc

1904

1707

1919

1722

1920

1723

def add_pipe(self, parent_pipe, proc):

1921

1724

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

1922

raise NotImplementedError()

1725

raise NotImplementedError

1923

1726

1924

1727

1925

1728

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1932

1735

use_ipv6: Boolean; to use IPv6 or not

1933

1736

"""

1934

1737

def __init__(self, server_address, RequestHandlerClass,

1935

interface=None, use_ipv6=True, socketfd=None):

1936

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

1937

creating a new one with socket.socket().

1938

"""

1738

interface=None, use_ipv6=True):

1939

1739

self.interface = interface

1940

1740

if use_ipv6:

1941

1741

self.address_family = socket.AF_INET6

1942

if socketfd is not None:

1943

# Save the file descriptor

1944

self.socketfd = socketfd

1945

# Save the original socket.socket() function

1946

self.socket_socket = socket.socket

1947

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

1948

#

1949

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

1950

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

1951

# patching socket.socket.)

1952

#

1953

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

1954

@functools.wraps(socket.socket)

1955

def socket_wrapper(*args, **kwargs):

1956

# Restore original function so subsequent calls are

1957

# not affected.

1958

socket.socket = self.socket_socket

1959

del self.socket_socket

1960

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

1961

# saved file descriptor.

1962

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

1963

# Replace socket.socket() function with wrapper

1964

socket.socket = socket_wrapper

1965

# The socketserver.TCPServer.__init__ will call

1966

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

1967

# socket_wrapper(), if socketfd was set.

1968

1742

socketserver.TCPServer.__init__(self, server_address,

1969

1743

RequestHandlerClass)

1970

1971

1744

def server_bind(self):

1972

1745

"""This overrides the normal server_bind() function

1973

1746

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

1981

1754

try:

1982

1755

self.socket.setsockopt(socket.SOL_SOCKET,

1983

1756

SO_BINDTODEVICE,

1984

(self.interface + "\0")

1985

.encode("utf-8"))

1757

str(self.interface

1758

+ '\0'))

1986

1759

except socket.error as error:

1987

if error.errno == errno.EPERM:

1988

logger.error("No permission to bind to"

1989

" interface %s", self.interface)

1990

elif error.errno == errno.ENOPROTOOPT:

1760

if error[0] == errno.EPERM:

1761

logger.error("No permission to"

1762

" bind to interface %s",

1763

self.interface)

1764

elif error[0] == errno.ENOPROTOOPT:

1991

1765

logger.error("SO_BINDTODEVICE not available;"

1992

1766

" cannot bind to interface %s",

1993

1767

self.interface)

1994

elif error.errno == errno.ENODEV:

1995

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

1996

" cannot bind", self.interface)

1997

1768

else:

1998

1769

raise

1999

1770

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

2002

1773

if self.address_family == socket.AF_INET6:

2003

1774

any_address = "::" # in6addr_any

2004

1775

else:

2005

any_address = "0.0.0.0" # INADDR_ANY

1776

any_address = socket.INADDR_ANY

2006

1777

self.server_address = (any_address,

2007

1778

self.server_address[1])

2008

1779

elif not self.server_address[1]:

2029

1800

"""

2030

1801

def __init__(self, server_address, RequestHandlerClass,

2031

1802

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

2032

gnutls_priority=None, use_dbus=True, socketfd=None):

1803

gnutls_priority=None, use_dbus=True):

2033

1804

self.enabled = False

2034

1805

self.clients = clients

2035

1806

if self.clients is None:

2039

1810

IPv6_TCPServer.__init__(self, server_address,

2040

1811

RequestHandlerClass,

2041

1812

interface = interface,

2042

use_ipv6 = use_ipv6,

2043

socketfd = socketfd)

1813

use_ipv6 = use_ipv6)

2044

1814

def server_activate(self):

2045

1815

if self.enabled:

2046

1816

return socketserver.TCPServer.server_activate(self)

2059

1829

2060

1830

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

2061

1831

proc = None, client_object=None):

1832

condition_names = {

1833

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

1834

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

1835

# blocking).

1836

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

1837

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

1838

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

1839

# broken, usually for pipes and

1840

# sockets).

1841

}

1842

conditions_string = ' | '.join(name

1843

for cond, name in

1844

condition_names.iteritems()

1845

if cond & condition)

2062

1846

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

2063

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

1847

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

2064

1848

# Wait for other process to exit

2065

1849

proc.join()

2066

1850

return False

2124

1908

return True

2125

1909

2126

1910

2127

def rfc3339_duration_to_delta(duration):

2128

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

2129

2130

>>> rfc3339_duration_to_delta("P7D")

2131

datetime.timedelta(7)

2132

>>> rfc3339_duration_to_delta("PT60S")

2133

datetime.timedelta(0, 60)

2134

>>> rfc3339_duration_to_delta("PT60M")

2135

datetime.timedelta(0, 3600)

2136

>>> rfc3339_duration_to_delta("PT24H")

2137

datetime.timedelta(1)

2138

>>> rfc3339_duration_to_delta("P1W")

2139

datetime.timedelta(7)

2140

>>> rfc3339_duration_to_delta("PT5M30S")

2141

datetime.timedelta(0, 330)

2142

>>> rfc3339_duration_to_delta("P1DT3M20S")

2143

datetime.timedelta(1, 200)

2144

"""

2145

2146

# Parsing an RFC 3339 duration with regular expressions is not

2147

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

2148

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

2149

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

2150

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

2151

# avoid excessive use of external libraries.

2152

2153

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

2154

Token = collections.namedtuple("Token",

2155

("regexp", # To match token; if

2156

# "value" is not None,

2157

# must have a "group"

2158

# containing digits

2159

"value", # datetime.timedelta or

2160

# None

2161

"followers")) # Tokens valid after

2162

# this token

2163

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

2164

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

2165

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

2166

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

2167

datetime.timedelta(seconds=1),

2168

frozenset((token_end,)))

2169

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

2170

datetime.timedelta(minutes=1),

2171

frozenset((token_second, token_end)))

2172

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

2173

datetime.timedelta(hours=1),

2174

frozenset((token_minute, token_end)))

2175

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

2176

None,

2177

frozenset((token_hour, token_minute,

2178

token_second)))

2179

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

2180

datetime.timedelta(days=1),

2181

frozenset((token_time, token_end)))

2182

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

2183

datetime.timedelta(weeks=4),

2184

frozenset((token_day, token_end)))

2185

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

2186

datetime.timedelta(weeks=52),

2187

frozenset((token_month, token_end)))

2188

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

2189

datetime.timedelta(weeks=1),

2190

frozenset((token_end,)))

2191

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

2192

frozenset((token_year, token_month,

2193

token_day, token_time,

2194

token_week)))

2195

# Define starting values

2196

value = datetime.timedelta() # Value so far

2197

found_token = None

2198

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

2199

s = duration # String left to parse

2200

# Loop until end token is found

2201

while found_token is not token_end:

2202

# Search for any currently valid tokens

2203

for token in followers:

2204

match = token.regexp.match(s)

2205

if match is not None:

2206

# Token found

2207

if token.value is not None:

2208

# Value found, parse digits

2209

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

2210

# Add to value so far

2211

value += factor * token.value

2212

# Strip token from string

2213

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

2214

# Go to found token

2215

found_token = token

2216

# Set valid next tokens

2217

followers = found_token.followers

2218

break

2219

else:

2220

# No currently valid tokens were found

2221

raise ValueError("Invalid RFC 3339 duration")

2222

# End token found

2223

return value

2224

2225

2226

1911

def string_to_delta(interval):

2227

1912

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

2228

1913

2239

1924

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

2240

1925

datetime.timedelta(0, 330)

2241

1926

"""

2242

2243

try:

2244

return rfc3339_duration_to_delta(interval)

2245

except ValueError:

2246

pass

2247

2248

1927

timevalue = datetime.timedelta(0)

2249

1928

for s in interval.split():

2250

1929

try:

2251

suffix = s[-1]

1930

suffix = unicode(s[-1])

2252

1931

value = int(s[:-1])

2253

1932

if suffix == "d":

2254

1933

delta = datetime.timedelta(value)

2261

1940

elif suffix == "w":

2262

1941

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

2263

1942

else:

2264

raise ValueError("Unknown suffix {!r}"

2265

.format(suffix))

2266

except IndexError as e:

1943

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

1944

except (ValueError, IndexError) as e:

2267

1945

raise ValueError(*(e.args))

2268

1946

timevalue += delta

2269

1947

return timevalue

2282

1960

sys.exit()

2283

1961

if not noclose:

2284

1962

# Close all standard open file descriptors

2285

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

1963

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

2286

1964

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

2287

raise OSError(errno.ENODEV, "{} not a character device"

2288

.format(os.devnull))

1965

raise OSError(errno.ENODEV,

1966

"%s not a character device"

1967

% os.path.devnull)

2289

1968

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

2290

1969

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

2291

1970

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

2300

1979

2301

1980

parser = argparse.ArgumentParser()

2302

1981

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

2303

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

1982

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

2304

1983

help="show version number and exit")

2305

1984

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

2306

1985

help="Bind to interface IF")

2312

1991

help="Run self-test")

2313

1992

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

2314

1993

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

2315

" to terminal", default=None)

1994

" to terminal")

2316

1995

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

2317

1996

help="Debug level for stdout output")

2318

1997

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

2325

2004

" files")

2326

2005

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

2327

2006

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

2328

" system bus interface", default=None)

2007

" system bus interface")

2329

2008

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

2330

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

2331

default=None)

2009

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

2332

2010

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

2333

2011

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

2334

" state", default=None)

2335

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

2336

help="Specify a file descriptor to a network"

2337

" socket to use instead of creating one")

2012

" state")

2338

2013

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

2339

2014

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

2340

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

2341

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

2342

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

2343

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

2344

default=None)

2345

2015

2346

2016

options = parser.parse_args()

2347

2017

2348

2018

if options.check:

2349

2019

import doctest

2350

fail_count, test_count = doctest.testmod()

2351

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

2020

doctest.testmod()

2021

sys.exit()

2352

2022

2353

2023

# Default values for config file for server-global settings

2354

2024

server_defaults = { "interface": "",

2356

2026

"port": "",

2357

2027

"debug": "False",

2358

2028

"priority":

2359

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

2360

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

2029

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

2361

2030

"servicename": "Mandos",

2362

2031

"use_dbus": "True",

2363

2032

"use_ipv6": "True",

2364

2033

"debuglevel": "",

2365

2034

"restore": "True",

2366

"socket": "",

2367

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

2368

"foreground": "False",

2369

"zeroconf": "True",

2035

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

2370

2036

}

2371

2037

2372

2038

# Parse config file for server-global settings

2377

2043

# Convert the SafeConfigParser object to a dict

2378

2044

server_settings = server_config.defaults()

2379

2045

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

2380

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

2046

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

2381

2047

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

2382

2048

option)

2383

2049

if server_settings["port"]:

2384

2050

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

2385

2051

"port")

2386

if server_settings["socket"]:

2387

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

2388

"socket")

2389

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

2390

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

2391

# happen with a supplied network socket.

2392

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

2393

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

2394

["socket"])

2395

2052

del server_config

2396

2053

2397

2054

# Override the settings from the config file with command line

2399

2056

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

2400

2057

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

2401

2058

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

2402

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

2059

"statedir"):

2403

2060

value = getattr(options, option)

2404

2061

if value is not None:

2405

2062

server_settings[option] = value

2406

2063

del options

2407

2064

# Force all strings to be unicode

2408

2065

for option in server_settings.keys():

2409

if isinstance(server_settings[option], bytes):

2410

server_settings[option] = (server_settings[option]

2411

.decode("utf-8"))

2412

# Force all boolean options to be boolean

2413

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

2414

"foreground", "zeroconf"):

2415

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

2416

# Debug implies foreground

2417

if server_settings["debug"]:

2418

server_settings["foreground"] = True

2066

if type(server_settings[option]) is str:

2067

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

2419

2068

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

2420

2069

2421

2070

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

2422

2071

2423

if (not server_settings["zeroconf"] and

2424

not (server_settings["port"]

2425

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

2426

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

2427

" Zeroconf")

2428

2429

2072

# For convenience

2430

2073

debug = server_settings["debug"]

2431

2074

debuglevel = server_settings["debuglevel"]

2433

2076

use_ipv6 = server_settings["use_ipv6"]

2434

2077

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

2435

2078

stored_state_file)

2436

foreground = server_settings["foreground"]

2437

zeroconf = server_settings["zeroconf"]

2438

2079

2439

2080

if debug:

2440

initlogger(debug, logging.DEBUG)

2081

initlogger(logging.DEBUG)

2441

2082

else:

2442

2083

if not debuglevel:

2443

initlogger(debug)

2084

initlogger()

2444

2085

else:

2445

2086

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

2446

initlogger(debug, level)

2087

initlogger(level)

2447

2088

2448

2089

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

2449

2090

syslogger.setFormatter(logging.Formatter

2450

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

2451

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

2452

.format(server_settings

2453

["servicename"])))

2091

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

2092

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

2093

% server_settings["servicename"]))

2454

2094

2455

2095

# Parse config file with clients

2456

client_config = configparser.SafeConfigParser(Client

2457

.client_defaults)

2096

client_config = configparser.SafeConfigParser(Client.client_defaults)

2458

2097

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

2459

2098

"clients.conf"))

2460

2099

2461

2100

global mandos_dbus_service

2462

2101

mandos_dbus_service = None

2463

2102

2464

socketfd = None

2465

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

2466

socketfd = server_settings["socket"]

2467

2103

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

2468

2104

server_settings["port"]),

2469

2105

ClientHandler,

2472

2108

use_ipv6=use_ipv6,

2473

2109

gnutls_priority=

2474

2110

server_settings["priority"],

2475

use_dbus=use_dbus,

2476

socketfd=socketfd)

2477

if not foreground:

2478

pidfilename = "/run/mandos.pid"

2479

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

2480

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

2481

pidfile = None

2111

use_dbus=use_dbus)

2112

if not debug:

2113

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

2482

2114

try:

2483

2115

pidfile = open(pidfilename, "w")

2484

except IOError as e:

2485

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

2486

exc_info=e)

2116

except IOError:

2117

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

2487

2118

2488

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

2119

try:

2120

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

2121

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

2122

except KeyError:

2489

2123

try:

2490

uid = pwd.getpwnam(name).pw_uid

2491

gid = pwd.getpwnam(name).pw_gid

2492

break

2124

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

2125

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

2493

2126

except KeyError:

2494

continue

2495

else:

2496

uid = 65534

2497

gid = 65534

2127

try:

2128

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

2129

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

2130

except KeyError:

2131

uid = 65534

2132

gid = 65534

2498

2133

try:

2499

2134

os.setgid(gid)

2500

2135

os.setuid(uid)

2501

2136

except OSError as error:

2502

if error.errno != errno.EPERM:

2503

raise

2137

if error[0] != errno.EPERM:

2138

raise error

2504

2139

2505

2140

if debug:

2506

2141

# Enable all possible GnuTLS debugging

2517

2152

.gnutls_global_set_log_function(debug_gnutls))

2518

2153

2519

2154

# Redirect stdin so all checkers get /dev/null

2520

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

2155

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

2521

2156

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

2522

2157

if null > 2:

2523

2158

os.close(null)

2159

else:

2160

# No console logging

2161

logger.removeHandler(console)

2524

2162

2525

2163

# Need to fork before connecting to D-Bus

2526

if not foreground:

2164

if not debug:

2527

2165

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

2528

2166

daemon()

2529

2167

2530

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

2531

# need to inform gobject that threads will be used.

2532

gobject.threads_init()

2533

2534

2168

global main_loop

2535

2169

# From the Avahi example code

2536

DBusGMainLoop(set_as_default=True)

2170

DBusGMainLoop(set_as_default=True )

2537

2171

main_loop = gobject.MainLoop()

2538

2172

bus = dbus.SystemBus()

2539

2173

# End of Avahi example code

2545

2179

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

2546

2180

do_not_queue=True))

2547

2181

except dbus.exceptions.NameExistsException as e:

2548

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

2182

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

2549

2183

use_dbus = False

2550

2184

server_settings["use_dbus"] = False

2551

2185

tcp_server.use_dbus = False

2552

if zeroconf:

2553

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2554

service = AvahiServiceToSyslog(name =

2555

server_settings["servicename"],

2556

servicetype = "_mandos._tcp",

2557

protocol = protocol, bus = bus)

2558

if server_settings["interface"]:

2559

service.interface = (if_nametoindex

2560

(server_settings["interface"]

2561

.encode("utf-8")))

2186

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2187

service = AvahiServiceToSyslog(name =

2188

server_settings["servicename"],

2189

servicetype = "_mandos._tcp",

2190

protocol = protocol, bus = bus)

2191

if server_settings["interface"]:

2192

service.interface = (if_nametoindex

2193

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

2562

2194

2563

2195

global multiprocessing_manager

2564

2196

multiprocessing_manager = multiprocessing.Manager()

2565

2197

2566

2198

client_class = Client

2567

2199

if use_dbus:

2568

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

2200

client_class = functools.partial(ClientDBusTransitional,

2201

bus = bus)

2569

2202

2570

2203

client_settings = Client.config_parser(client_config)

2571

2204

old_client_settings = {}

2572

2205

clients_data = {}

2573

2206

2574

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

2575

global wnull

2576

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

2577

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

2578

# mode

2579

if debug or not foreground:

2580

wnull.close()

2581

2582

2207

# Get client data and settings from last running state.

2583

2208

if server_settings["restore"]:

2584

2209

try:

2587

2212

(stored_state))

2588

2213

os.remove(stored_state_path)

2589

2214

except IOError as e:

2590

if e.errno == errno.ENOENT:

2591

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

2592

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

2593

else:

2594

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

2595

exc_info=e)

2215

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

2216

.format(e))

2217

if e.errno != errno.ENOENT:

2596

2218

raise

2597

except EOFError as e:

2598

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

2599

"EOFError:", exc_info=e)

2600

2219

2601

2220

with PGPEngine() as pgp:

2602

for client_name, client in clients_data.items():

2603

# Skip removed clients

2604

if client_name not in client_settings:

2605

continue

2606

2221

for client_name, client in clients_data.iteritems():

2607

2222

# Decide which value to use after restoring saved state.

2608

2223

# We have three different values: Old config file,

2609

2224

# new config file, and saved state.

2623

2238

2624

2239

# Clients who has passed its expire date can still be

2625

2240

# enabled if its last checker was successful. Clients

2626

# whose checker succeeded before we stored its state is

2627

# assumed to have successfully run all checkers during

2628

# downtime.

2241

# whose checker failed before we stored its state is

2242

# assumed to have failed all checkers during downtime.

2629

2243

if client["enabled"]:

2630

2244

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

2631

2245

if not client["last_checked_ok"]:

2632

2246

logger.warning(

2633

"disabling client {} - Client never "

2634

"performed a successful checker"

2635

.format(client_name))

2247

"disabling client {0} - Client never "

2248

"performed a successfull checker"

2249

.format(client["name"]))

2636

2250

client["enabled"] = False

2637

2251

elif client["last_checker_status"] != 0:

2638

2252

logger.warning(

2639

"disabling client {} - Client last"

2640

" checker failed with error code {}"

2641

.format(client_name,

2253

"disabling client {0} - Client "

2254

"last checker failed with error code {1}"

2255

.format(client["name"],

2642

2256

client["last_checker_status"]))

2643

2257

client["enabled"] = False

2644

2258

else:

2645

2259

client["expires"] = (datetime.datetime

2646

2260

.utcnow()

2647

2261

+ client["timeout"])

2648

logger.debug("Last checker succeeded,"

2649

" keeping {} enabled"

2650

.format(client_name))

2262

2651

2263

try:

2652

2264

client["secret"] = (

2653

2265

pgp.decrypt(client["encrypted_secret"],

2655

2267

["secret"]))

2656

2268

except PGPError:

2657

2269

# If decryption fails, we use secret from new settings

2658

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

2270

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

2659

2271

.format(client_name))

2660

2272

client["secret"] = (

2661

2273

client_settings[client_name]["secret"])

2274

2662

2275

2663

2276

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

2664

for client_name in (set(old_client_settings)

2665

- set(client_settings)):

2277

for client_name in set(old_client_settings) - set(client_settings):

2666

2278

del clients_data[client_name]

2667

for client_name in (set(client_settings)

2668

- set(old_client_settings)):

2279

for client_name in set(client_settings) - set(old_client_settings):

2669

2280

clients_data[client_name] = client_settings[client_name]

2670

2671

# Create all client objects

2672

for client_name, client in clients_data.items():

2281

2282

# Create clients all clients

2283

for client_name, client in clients_data.iteritems():

2673

2284

tcp_server.clients[client_name] = client_class(

2674

name = client_name, settings = client,

2675

server_settings = server_settings)

2285

name = client_name, settings = client)

2676

2286

2677

2287

if not tcp_server.clients:

2678

2288

logger.warning("No clients defined")

2679

2680

if not foreground:

2681

if pidfile is not None:

2682

try:

2683

with pidfile:

2684

pid = os.getpid()

2685

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

2686

except IOError:

2687

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

2688

pidfilename, pid)

2689

del pidfile

2289

2290

if not debug:

2291

try:

2292

with pidfile:

2293

pid = os.getpid()

2294

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

2295

del pidfile

2296

except IOError:

2297

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

2298

pidfilename, pid)

2299

except NameError:

2300

# "pidfile" was never created

2301

pass

2690

2302

del pidfilename

2303

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

2691

2304

2692

2305

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

2693

2306

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

2694

2307

2695

2308

if use_dbus:

2696

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

2697

"se.bsnet.fukt.Mandos"})

2698

class MandosDBusService(DBusObjectWithProperties):

2309

class MandosDBusService(dbus.service.Object):

2699

2310

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

2700

2311

def __init__(self):

2701

2312

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

2702

2313

_interface = "se.recompile.Mandos"

2703

2314

2704

@dbus_interface_annotations(_interface)

2705

def _foo(self):

2706

return { "org.freedesktop.DBus.Property"

2707

".EmitsChangedSignal":

2708

"false"}

2709

2710

2315

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

2711

2316

def ClientAdded(self, objpath):

2712

2317

"D-Bus signal"

2734

2339

def GetAllClientsWithProperties(self):

2735

2340

"D-Bus method"

2736

2341

return dbus.Dictionary(

2737

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

2738

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

2342

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

2343

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

2739

2344

signature="oa{sv}")

2740

2345

2741

2346

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

2754

2359

2755

2360

del _interface

2756

2361

2757

mandos_dbus_service = MandosDBusService()

2362

class MandosDBusServiceTransitional(MandosDBusService):

2363

__metaclass__ = AlternateDBusNamesMetaclass

2364

mandos_dbus_service = MandosDBusServiceTransitional()

2758

2365

2759

2366

def cleanup():

2760

2367

"Cleanup function; run on exit"

2761

if zeroconf:

2762

service.cleanup()

2368

service.cleanup()

2763

2369

2764

2370

multiprocessing.active_children()

2765

wnull.close()

2766

2371

if not (tcp_server.clients or client_settings):

2767

2372

return

2768

2373

2779

2384

2780

2385

# A list of attributes that can not be pickled

2781

2386

# + secret.

2782

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

2783

"checker", "server_settings" }

2387

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

2388

"checker"))

2784

2389

for name, typ in (inspect.getmembers

2785

2390

(dbus.service.Object)):

2786

2391

exclude.add(name)

2795

2400

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

2796

2401

2797

2402

try:

2798

with (tempfile.NamedTemporaryFile

2799

(mode='wb', suffix=".pickle", prefix='clients-',

2800

dir=os.path.dirname(stored_state_path),

2801

delete=False)) as stored_state:

2403

with os.fdopen(os.open(stored_state_path,

2404

os.O_CREAT|os.O_WRONLY|os.O_TRUNC,

2405

0600), "wb") as stored_state:

2802

2406

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

2803

tempname=stored_state.name

2804

os.rename(tempname, stored_state_path)

2805

2407

except (IOError, OSError) as e:

2806

if not debug:

2807

try:

2808

os.remove(tempname)

2809

except NameError:

2810

pass

2811

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

2812

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

2813

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

2814

else:

2815

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

2816

exc_info=e)

2408

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

2409

.format(e))

2410

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

2817

2411

raise

2818

2412

2819

2413

# Delete all clients, and settings from config

2844

2438

tcp_server.server_activate()

2845

2439

2846

2440

# Find out what port we got

2847

if zeroconf:

2848

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

2441

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

2849

2442

if use_ipv6:

2850

2443

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

2851

" flowinfo %d, scope_id %d",

2852

*tcp_server.socket.getsockname())

2444

" flowinfo %d, scope_id %d"

2445

% tcp_server.socket.getsockname())

2853

2446

else: # IPv4

2854

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

2855

*tcp_server.socket.getsockname())

2447

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

2448

% tcp_server.socket.getsockname())

2856

2449

2857

2450

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

2858

2451

2859

2452

try:

2860

if zeroconf:

2861

# From the Avahi example code

2862

try:

2863

service.activate()

2864

except dbus.exceptions.DBusException as error:

2865

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

2866

cleanup()

2867

sys.exit(1)

2868

# End of Avahi example code

2453

# From the Avahi example code

2454

try:

2455

service.activate()

2456

except dbus.exceptions.DBusException as error:

2457

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

2458

cleanup()

2459

sys.exit(1)

2460

# End of Avahi example code

2869

2461

2870

2462

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

2871

2463

lambda *args, **kwargs:

2875

2467

logger.debug("Starting main loop")

2876

2468

main_loop.run()

2877

2469

except AvahiError as error:

2878

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

2470

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

2879

2471

cleanup()

2880

2472

sys.exit(1)

2881

2473

except KeyboardInterrupt: