/mandos/release : revision 237.7.281

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

from future_builtins import *

38

37

39

import SocketServer as socketserver

38

40

import socket

39

41

import argparse

65

67

import types

66

68

import binascii

67

69

import tempfile

70

import itertools

71

import collections

68

72

69

73

import dbus

70

74

import dbus.service

75

79

import ctypes.util

76

80

import xml.dom.minidom

77

81

import inspect

78

import GnuPGInterface

79

82

80

83

try:

81

84

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

85

88

except ImportError:

86

89

SO_BINDTODEVICE = None

87

90

88

version = "1.4.1"

91

if sys.version_info.major == 2:

92

str = unicode

93

94

version = "1.6.8"

89

95

stored_state_file = "clients.pickle"

90

96

91

97

logger = logging.getLogger()

92

syslogger = (logging.handlers.SysLogHandler

93

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

94

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

98

syslogger = None

95

99

96

100

try:

97

101

if_nametoindex = (ctypes.cdll.LoadLibrary

103

107

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

104

108

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

105

109

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

106

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

107

interface))

108

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

109

ifreq[16:20])[0]

110

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

111

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

110

112

return interface_index

111

113

112

114

113

115

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

114

116

"""init logger and add loglevel"""

115

117

118

global syslogger

119

syslogger = (logging.handlers.SysLogHandler

120

(facility =

121

logging.handlers.SysLogHandler.LOG_DAEMON,

122

address = "/dev/log"))

116

123

syslogger.setFormatter(logging.Formatter

117

124

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

118

125

' %(message)s'))

136

143

class PGPEngine(object):

137

144

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

138

145

def __init__(self):

139

self.gnupg = GnuPGInterface.GnuPG()

140

146

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'])

147

self.gnupgargs = ['--batch',

148

'--home', self.tempdir,

149

'--force-mdc',

150

'--quiet',

151

'--no-use-agent']

146

152

147

153

def __enter__(self):

148

154

return self

149

155

150

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

156

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

151

157

self._cleanup()

152

158

return False

153

159

170

176

def password_encode(self, password):

171

177

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

172

178

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

173

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

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

174

186

175

187

def encrypt(self, data, password):

176

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

177

with open(os.devnull) as devnull:

178

try:

179

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

180

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

181

attach_fhs={'stderr': devnull})

182

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

183

f.write(data)

184

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

185

ciphertext = f.read()

186

proc.wait()

187

except IOError as e:

188

raise PGPError(e)

189

self.gnupg.passphrase = None

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)

190

203

return ciphertext

191

204

192

205

def decrypt(self, data, password):

193

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

194

with open(os.devnull) as devnull:

195

try:

196

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

197

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

198

attach_fhs={'stderr': devnull})

199

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

200

f.write(data)

201

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

202

decrypted_plaintext = f.read()

203

proc.wait()

204

except IOError as e:

205

raise PGPError(e)

206

self.gnupg.passphrase = None

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)

207

222

return decrypted_plaintext

208

223

209

224

210

211

225

class AvahiError(Exception):

212

226

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

213

227

self.value = value

214

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

215

def __unicode__(self):

216

return unicode(repr(self.value))

228

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

229

**kwargs)

217

230

218

231

class AvahiServiceError(AvahiError):

219

232

pass

230

243

Used to optionally bind to the specified interface.

231

244

name: string; Example: 'Mandos'

232

245

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

233

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

246

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

234

247

port: integer; what port to announce

235

248

TXT: list of strings; TXT record for the service

236

249

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

242

255

server: D-Bus Server

243

256

bus: dbus.SystemBus()

244

257

"""

258

245

259

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

246

260

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

247

261

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

260

274

self.server = None

261

275

self.bus = bus

262

276

self.entry_group_state_changed_match = None

277

263

278

def rename(self):

264

279

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

265

280

if self.rename_count >= self.max_renames:

267

282

" after %i retries, exiting.",

268

283

self.rename_count)

269

284

raise AvahiServiceError("Too many renames")

270

self.name = unicode(self.server

271

.GetAlternativeServiceName(self.name))

285

self.name = str(self.server

286

.GetAlternativeServiceName(self.name))

272

287

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

273

288

self.name)

274

289

self.remove()

275

290

try:

276

291

self.add()

277

292

except dbus.exceptions.DBusException as error:

278

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

293

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

279

294

self.cleanup()

280

295

os._exit(1)

281

296

self.rename_count += 1

297

282

298

def remove(self):

283

299

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

284

300

if self.entry_group_state_changed_match is not None:

286

302

self.entry_group_state_changed_match = None

287

303

if self.group is not None:

288

304

self.group.Reset()

305

289

306

def add(self):

290

307

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

291

308

self.remove()

308

325

dbus.UInt16(self.port),

309

326

avahi.string_array_to_txt_array(self.TXT))

310

327

self.group.Commit()

328

311

329

def entry_group_state_changed(self, state, error):

312

330

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

313

331

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

319

337

self.rename()

320

338

elif state == avahi.ENTRY_GROUP_FAILURE:

321

339

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

322

unicode(error))

323

raise AvahiGroupError("State changed: %s"

324

% unicode(error))

340

str(error))

341

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

342

.format(error))

343

325

344

def cleanup(self):

326

345

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

327

346

if self.group is not None:

332

351

pass

333

352

self.group = None

334

353

self.remove()

354

335

355

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

336

356

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

337

357

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

356

376

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

357

377

else:

358

378

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

379

359

380

def activate(self):

360

381

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

361

382

if self.server is None:

368

389

self.server_state_changed)

369

390

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

370

391

392

371

393

class AvahiServiceToSyslog(AvahiService):

372

394

def rename(self):

373

395

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

374

396

ret = AvahiService.rename(self)

375

397

syslogger.setFormatter(logging.Formatter

376

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

377

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

378

% self.name))

398

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

399

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

400

.format(self.name)))

379

401

return ret

380

402

381

def timedelta_to_milliseconds(td):

382

"Convert a datetime.timedelta() to milliseconds"

383

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

384

+ (td.seconds * 1000)

385

+ (td.microseconds // 1000))

386

403

387

404

class Client(object):

388

405

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

389

406

414

431

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

415

432

last_checker_status: integer between 0 and 255 reflecting exit

416

433

status of last checker. -1 reflects crashed

417

checker, or None.

434

checker, -2 means no checker completed yet.

418

435

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

419

436

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

420

437

D-Bus identifiers

421

438

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

422

439

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

423

440

until this client is disabled

424

extended_timeout: extra long timeout when password has been sent

441

extended_timeout: extra long timeout when secret has been sent

425

442

runtime_expansions: Allowed attributes for runtime expansion.

426

443

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

427

444

disabled, or None

445

server_settings: The server_settings dict from main()

428

446

"""

429

447

430

448

runtime_expansions = ("approval_delay", "approval_duration",

431

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

432

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

449

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

450

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

451

"last_approval_request", "last_checked_ok",

433

452

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

434

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

435

"extended_timeout": "15m",

436

"interval": "2m",

453

client_defaults = { "timeout": "PT5M",

454

"extended_timeout": "PT15M",

455

"interval": "PT2M",

437

456

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

438

457

"host": "",

439

"approval_delay": "0s",

440

"approval_duration": "1s",

458

"approval_delay": "PT0S",

459

"approval_duration": "PT1S",

441

460

"approved_by_default": "True",

442

461

"enabled": "True",

443

462

}

444

463

445

def timeout_milliseconds(self):

446

"Return the 'timeout' attribute in milliseconds"

447

return timedelta_to_milliseconds(self.timeout)

448

449

def extended_timeout_milliseconds(self):

450

"Return the 'extended_timeout' attribute in milliseconds"

451

return timedelta_to_milliseconds(self.extended_timeout)

452

453

def interval_milliseconds(self):

454

"Return the 'interval' attribute in milliseconds"

455

return timedelta_to_milliseconds(self.interval)

456

457

def approval_delay_milliseconds(self):

458

return timedelta_to_milliseconds(self.approval_delay)

459

460

464

@staticmethod

461

465

def config_parser(config):

462

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

466

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

463

467

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

464

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

468

with exceptions for any special settings as defined above.

469

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

470

value given the same arguments.

471

"""

465

472

settings = {}

466

473

for client_name in config.sections():

467

474

section = dict(config.items(client_name))

471

478

# Reformat values from string types to Python types

472

479

client["approved_by_default"] = config.getboolean(

473

480

client_name, "approved_by_default")

474

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

481

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

482

"enabled")

475

483

476

484

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

477

485

.replace(" ", ""))

483

491

"rb") as secfile:

484

492

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

485

493

else:

486

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

487

% section)

494

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

495

.format(section))

488

496

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

489

497

client["extended_timeout"] = string_to_delta(

490

498

section["extended_timeout"])

496

504

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

497

505

client["last_approval_request"] = None

498

506

client["last_checked_ok"] = None

499

client["last_checker_status"] = None

500

if client["enabled"]:

501

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

502

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

503

+ client["timeout"])

504

else:

505

client["last_enabled"] = None

506

client["expires"] = None

507

client["last_checker_status"] = -2

508

509

return settings

509

510

511

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

512

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

513

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

514

attribute."""

510

511

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

515

512

self.name = name

513

if server_settings is None:

514

server_settings = {}

515

self.server_settings = server_settings

516

# adding all client settings

517

for setting, value in settings.iteritems():

517

for setting, value in settings.items():

518

setattr(self, setting, value)

519

520

if self.enabled:

521

if not hasattr(self, "last_enabled"):

522

self.last_enabled = datetime.datetime.utcnow()

523

if not hasattr(self, "expires"):

524

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

525

+ self.timeout)

526

else:

527

self.last_enabled = None

528

self.expires = None

529

520

530

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

521

531

# Uppercase and remove spaces from fingerprint for later

522

532

# comparison purposes with return value from the fingerprint()

523

533

# function

524

534

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

525

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

526

535

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

536

datetime.datetime.utcnow())

537

527

538

# attributes specific for this server instance

528

539

self.checker = None

529

540

self.checker_initiator_tag = None

557

568

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

558

569

# Already enabled

559

570

return

560

self.send_changedstate()

561

571

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

562

572

self.enabled = True

563

573

self.last_enabled = datetime.datetime.utcnow()

564

574

self.init_checker()

575

self.send_changedstate()

565

576

566

577

def disable(self, quiet=True):

567

578

"""Disable this client."""

568

579

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

569

580

return False

570

581

if not quiet:

571

self.send_changedstate()

572

if not quiet:

573

582

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

574

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

583

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

575

584

gobject.source_remove(self.disable_initiator_tag)

576

585

self.disable_initiator_tag = None

577

586

self.expires = None

578

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

587

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

579

588

gobject.source_remove(self.checker_initiator_tag)

580

589

self.checker_initiator_tag = None

581

590

self.stop_checker()

582

591

self.enabled = False

592

if not quiet:

593

self.send_changedstate()

583

594

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

584

595

return False

585

596

589

600

def init_checker(self):

590

601

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

591

602

# and every interval from then on.

603

if self.checker_initiator_tag is not None:

604

gobject.source_remove(self.checker_initiator_tag)

592

605

self.checker_initiator_tag = (gobject.timeout_add

593

(self.interval_milliseconds(),

606

(int(self.interval

607

.total_seconds() * 1000),

594

608

self.start_checker))

595

609

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

610

if self.disable_initiator_tag is not None:

611

gobject.source_remove(self.disable_initiator_tag)

596

612

self.disable_initiator_tag = (gobject.timeout_add

597

(self.timeout_milliseconds(),

598

self.disable))

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

599

616

# Also start a new checker *right now*.

600

617

self.start_checker()

601

618

617

634

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

618

635

vars(self))

619

636

620

def checked_ok(self, timeout=None):

621

"""Bump up the timeout for this client.

622

623

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

624

alive and well.

625

"""

637

def checked_ok(self):

638

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

639

self.last_checked_ok = datetime.datetime.utcnow()

640

self.last_checker_status = 0

641

self.bump_timeout()

642

643

def bump_timeout(self, timeout=None):

644

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

626

645

if timeout is None:

627

646

timeout = self.timeout

628

self.last_checked_ok = datetime.datetime.utcnow()

629

647

if self.disable_initiator_tag is not None:

630

648

gobject.source_remove(self.disable_initiator_tag)

649

self.disable_initiator_tag = None

631

650

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

632

651

self.disable_initiator_tag = (gobject.timeout_add

633

(timedelta_to_milliseconds

634

(timeout), self.disable))

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

635

654

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

636

655

637

656

def need_approval(self):

643

662

If a checker already exists, leave it running and do

644

663

nothing."""

645

664

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

646

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

647

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

648

# client would inevitably timeout, since no checker would get

649

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

665

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

666

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

667

# would inevitably timeout, since no checker would get a

668

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

650

669

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

651

670

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

652

671

# should be.

654

673

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

655

674

try:

656

675

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

657

except (AttributeError, OSError) as error:

658

if (isinstance(error, OSError)

659

and error.errno != errno.ECHILD):

660

raise error

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

661

681

else:

662

682

if pid:

663

683

logger.warning("Checker was a zombie")

666

686

self.current_checker_command)

667

687

# Start a new checker if needed

668

688

if self.checker is None:

689

# Escape attributes for the shell

690

escaped_attrs = { attr:

691

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

692

for attr in self.runtime_expansions }

669

693

try:

670

# In case checker_command has exactly one % operator

671

command = self.checker_command % self.host

672

except TypeError:

673

# Escape attributes for the shell

674

escaped_attrs = dict(

675

(attr,

676

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

677

errors=

678

'replace')))

679

for attr in

680

self.runtime_expansions)

681

682

try:

683

command = self.checker_command % escaped_attrs

684

except TypeError as error:

685

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

686

' %s', self.checker_command, error)

687

return True # Try again later

694

command = self.checker_command % escaped_attrs

695

except TypeError as error:

696

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

697

self.checker_command, exc_info=error)

698

return True # Try again later

688

699

self.current_checker_command = command

689

700

try:

690

701

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

693

704

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

694

705

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

695

706

# always replaced by /dev/null.)

707

# The exception is when not debugging but nevertheless

708

# running in the foreground; use the previously

709

# created wnull.

710

popen_args = {}

711

if (not self.server_settings["debug"]

712

and self.server_settings["foreground"]):

713

popen_args.update({"stdout": wnull,

714

"stderr": wnull })

696

715

self.checker = subprocess.Popen(command,

697

716

close_fds=True,

698

shell=True, cwd="/")

699

self.checker_callback_tag = (gobject.child_watch_add

700

(self.checker.pid,

701

self.checker_callback,

702

data=command))

703

# The checker may have completed before the gobject

704

# watch was added. Check for this.

717

shell=True, cwd="/",

718

**popen_args)

719

except OSError as error:

720

logger.error("Failed to start subprocess",

721

exc_info=error)

722

return True

723

self.checker_callback_tag = (gobject.child_watch_add

724

(self.checker.pid,

725

self.checker_callback,

726

data=command))

727

# The checker may have completed before the gobject

728

# watch was added. Check for this.

729

try:

705

730

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

706

if pid:

707

gobject.source_remove(self.checker_callback_tag)

708

self.checker_callback(pid, status, command)

709

731

except OSError as error:

710

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

711

error)

732

if error.errno == errno.ECHILD:

733

# This should never happen

734

logger.error("Child process vanished",

735

exc_info=error)

736

return True

737

raise

738

if pid:

739

gobject.source_remove(self.checker_callback_tag)

740

self.checker_callback(pid, status, command)

712

741

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

713

742

return True

714

743

721

750

return

722

751

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

723

752

try:

724

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

753

self.checker.terminate()

725

754

#time.sleep(0.5)

726

755

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

727

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

756

# self.checker.kill()

728

757

except OSError as error:

729

758

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

730

759

raise

747

776

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

748

777

if byte_arrays and signature != "ay":

749

778

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

750

" signature %r" % signature)

779

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

751

780

def decorator(func):

752

781

func._dbus_is_property = True

753

782

func._dbus_interface = dbus_interface

761

790

return decorator

762

791

763

792

793

def dbus_interface_annotations(dbus_interface):

794

"""Decorator for marking functions returning interface annotations

795

796

Usage:

797

798

@dbus_interface_annotations("org.example.Interface")

799

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

800

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

801

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

802

"false"}

803

"""

804

def decorator(func):

805

func._dbus_is_interface = True

806

func._dbus_interface = dbus_interface

807

func._dbus_name = dbus_interface

808

return func

809

return decorator

810

811

812

def dbus_annotations(annotations):

813

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

814

Usage:

815

816

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

817

"org.freedesktop.DBus.Property."

818

"EmitsChangedSignal": "false"})

819

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

820

access="r")

821

def Property_dbus_property(self):

822

return dbus.Boolean(False)

823

"""

824

def decorator(func):

825

func._dbus_annotations = annotations

826

return func

827

return decorator

828

829

764

830

class DBusPropertyException(dbus.exceptions.DBusException):

765

831

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

766

832

"""

767

def __unicode__(self):

768

return unicode(str(self))

769

833

pass

770

834

771

835

class DBusPropertyAccessException(DBusPropertyException):

772

836

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

789

853

"""

790

854

791

855

@staticmethod

792

def _is_dbus_property(obj):

793

return getattr(obj, "_dbus_is_property", False)

856

def _is_dbus_thing(thing):

857

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

858

859

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

860

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

861

"""

862

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

863

False)

794

864

795

def _get_all_dbus_properties(self):

865

def _get_all_dbus_things(self, thing):

796

866

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

797

867

"""

798

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

868

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

869

name),

870

athing.__get__(self))

799

871

for cls in self.__class__.__mro__

800

for name, prop in

801

inspect.getmembers(cls, self._is_dbus_property))

872

for name, athing in

873

inspect.getmembers(cls,

874

self._is_dbus_thing(thing)))

802

875

803

876

def _get_dbus_property(self, interface_name, property_name):

804

877

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

806

879

"""

807

880

for cls in self.__class__.__mro__:

808

881

for name, value in (inspect.getmembers

809

(cls, self._is_dbus_property)):

882

(cls,

883

self._is_dbus_thing("property"))):

810

884

if (value._dbus_name == property_name

811

885

and value._dbus_interface == interface_name):

812

886

return value.__get__(self)

840

914

# The byte_arrays option is not supported yet on

841

915

# signatures other than "ay".

842

916

if prop._dbus_signature != "ay":

843

raise ValueError

844

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

845

for byte in value))

917

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

918

"'ay' signature {!r}"

919

.format(prop._dbus_signature))

920

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

921

for byte in value))

846

922

prop(value)

847

923

848

924

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

854

930

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

855

931

"""

856

932

properties = {}

857

for name, prop in self._get_all_dbus_properties():

933

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

858

934

if (interface_name

859

935

and interface_name != prop._dbus_interface):

860

936

# Interface non-empty but did not match

870

946

value.variant_level+1)

871

947

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

872

948

949

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

950

def PropertiesChanged(self, interface_name, changed_properties,

951

invalidated_properties):

952

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

953

standard.

954

"""

955

pass

956

873

957

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

874

958

out_signature="s",

875

959

path_keyword='object_path',

876

960

connection_keyword='connection')

877

961

def Introspect(self, object_path, connection):

878

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

962

"""Overloading of standard D-Bus method.

963

964

Inserts property tags and interface annotation tags.

879

965

"""

880

966

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

881

967

connection)

888

974

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

889

975

return e

890

976

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

977

# Add property tags

891

978

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

892

979

for name, prop

893

in self._get_all_dbus_properties()

980

in self._get_all_dbus_things("property")

894

981

if prop._dbus_interface

895

982

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

896

983

if_tag.appendChild(tag)

984

# Add annotation tags

985

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

986

for tag in if_tag.getElementsByTagName(typ):

987

annots = dict()

988

for name, prop in (self.

989

_get_all_dbus_things(typ)):

990

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

991

and prop._dbus_interface

992

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

993

annots.update(getattr

994

(prop,

995

"_dbus_annotations",

996

{}))

997

for name, value in annots.items():

998

ann_tag = document.createElement(

999

"annotation")

1000

ann_tag.setAttribute("name", name)

1001

ann_tag.setAttribute("value", value)

1002

tag.appendChild(ann_tag)

1003

# Add interface annotation tags

1004

for annotation, value in dict(

1005

itertools.chain.from_iterable(

1006

annotations().items()

1007

for name, annotations in

1008

self._get_all_dbus_things("interface")

1009

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

1010

)).items():

1011

ann_tag = document.createElement("annotation")

1012

ann_tag.setAttribute("name", annotation)

1013

ann_tag.setAttribute("value", value)

1014

if_tag.appendChild(ann_tag)

897

1015

# Add the names to the return values for the

898

1016

# "org.freedesktop.DBus.Properties" methods

899

1017

if (if_tag.getAttribute("name")

914

1032

except (AttributeError, xml.dom.DOMException,

915

1033

xml.parsers.expat.ExpatError) as error:

916

1034

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

917

error)

1035

exc_info=error)

918

1036

return xmlstring

919

1037

920

1038

921

def datetime_to_dbus (dt, variant_level=0):

1039

def datetime_to_dbus(dt, variant_level=0):

922

1040

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

923

1041

if dt is None:

924

1042

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

926

1044

variant_level=variant_level)

927

1045

928

1046

929

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

930

.__metaclass__):

931

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

932

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

1047

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1048

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

1049

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

1050

interface names according to the "alt_interface_names" mapping.

1051

Usage:

1052

1053

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

1054

"net.example.AlternateInterface"})

1055

class SampleDBusObject(dbus.service.Object):

1056

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

1057

def SampleDBusMethod():

1058

pass

1059

1060

The above "SampleDBusMethod" on "SampleDBusObject" will be

1061

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

1062

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

1063

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

1064

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

1065

1066

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

1067

(from DBusObjectWithProperties) and interfaces (from the

1068

dbus_interface_annotations decorator).

933

1069

"""

934

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

935

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

936

# methods, signals, or properties in them

937

for base in (b for b in bases

938

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

939

# Go though all attributes of the base class

940

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

1070

def wrapper(cls):

1071

for orig_interface_name, alt_interface_name in (

1072

alt_interface_names.items()):

1073

attr = {}

1074

interface_names = set()

1075

# Go though all attributes of the class

1076

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

941

1077

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

942

1078

# with the wrong interface name

943

1079

if (not hasattr(attribute, "_dbus_interface")

944

1080

or not attribute._dbus_interface

945

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

1081

.startswith(orig_interface_name)):

946

1082

continue

947

1083

# Create an alternate D-Bus interface name based on

948

1084

# the current name

949

1085

alt_interface = (attribute._dbus_interface

950

.replace("se.recompile.Mandos",

951

"se.bsnet.fukt.Mandos"))

1086

.replace(orig_interface_name,

1087

alt_interface_name))

1088

interface_names.add(alt_interface)

952

1089

# Is this a D-Bus signal?

953

1090

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

954

# Extract the original non-method function by

955

# black magic

1091

# Extract the original non-method undecorated

1092

# function by black magic

956

1093

nonmethod_func = (dict(

957

1094

zip(attribute.func_code.co_freevars,

958

1095

attribute.__closure__))["func"]

969

1106

nonmethod_func.func_name,

970

1107

nonmethod_func.func_defaults,

971

1108

nonmethod_func.func_closure)))

1109

# Copy annotations, if any

1110

try:

1111

new_function._dbus_annotations = (

1112

dict(attribute._dbus_annotations))

1113

except AttributeError:

1114

pass

972

1115

# Define a creator of a function to call both the

973

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

974

# signals gets sent when the function is called

1116

# original and alternate functions, so both the

1117

# original and alternate signals gets sent when

1118

# the function is called

975

1119

def fixscope(func1, func2):

976

1120

"""This function is a scope container to pass

977

1121

func1 and func2 to the "call_both" function

984

1128

return call_both

985

1129

# Create the "call_both" function and add it to

986

1130

# the class

987

attr[attrname] = fixscope(attribute,

988

new_function)

1131

attr[attrname] = fixscope(attribute, new_function)

989

1132

# Is this a D-Bus method?

990

1133

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

991

1134

# Create a new, but exactly alike, function

1002

1145

attribute.func_name,

1003

1146

attribute.func_defaults,

1004

1147

attribute.func_closure)))

1148

# Copy annotations, if any

1149

try:

1150

attr[attrname]._dbus_annotations = (

1151

dict(attribute._dbus_annotations))

1152

except AttributeError:

1153

pass

1005

1154

# Is this a D-Bus property?

1006

1155

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

1007

1156

# Create a new, but exactly alike, function

1021

1170

attribute.func_name,

1022

1171

attribute.func_defaults,

1023

1172

attribute.func_closure)))

1024

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

1025

1026

1173

# Copy annotations, if any

1174

try:

1175

attr[attrname]._dbus_annotations = (

1176

dict(attribute._dbus_annotations))

1177

except AttributeError:

1178

pass

1179

# Is this a D-Bus interface?

1180

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

1181

# Create a new, but exactly alike, function

1182

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

1183

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

1184

# to the class.

1185

attr[attrname] = (dbus_interface_annotations

1186

(alt_interface)

1187

(types.FunctionType

1188

(attribute.func_code,

1189

attribute.func_globals,

1190

attribute.func_name,

1191

attribute.func_defaults,

1192

attribute.func_closure)))

1193

if deprecate:

1194

# Deprecate all alternate interfaces

1195

iname="_AlternateDBusNames_interface_annotation{}"

1196

for interface_name in interface_names:

1197

@dbus_interface_annotations(interface_name)

1198

def func(self):

1199

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

1200

"true" }

1201

# Find an unused name

1202

for aname in (iname.format(i)

1203

for i in itertools.count()):

1204

if aname not in attr:

1205

attr[aname] = func

1206

break

1207

if interface_names:

1208

# Replace the class with a new subclass of it with

1209

# methods, signals, etc. as created above.

1210

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

1211

(cls,), attr)

1212

return cls

1213

return wrapper

1214

1215

1216

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

1217

"se.bsnet.fukt.Mandos"})

1027

1218

class ClientDBus(Client, DBusObjectWithProperties):

1028

1219

"""A Client class using D-Bus

1029

1220

1035

1226

runtime_expansions = (Client.runtime_expansions

1036

1227

+ ("dbus_object_path",))

1037

1228

1229

_interface = "se.recompile.Mandos.Client"

1230

1038

1231

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

1039

1232

1040

1233

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

1041

1234

self.bus = bus

1042

1235

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

1043

self._approvals_pending = 0

1044

1045

self._approvals_pending = 0

1046

1236

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

1047

1237

# the D-Bus

1048

client_object_name = unicode(self.name).translate(

1238

client_object_name = str(self.name).translate(

1049

1239

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

1050

1240

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

1051

1241

self.dbus_object_path = (dbus.ObjectPath

1052

1242

("/clients/" + client_object_name))

1053

1243

DBusObjectWithProperties.__init__(self, self.bus,

1054

1244

self.dbus_object_path)

1055

1245

1056

1246

def notifychangeproperty(transform_func,

1057

1247

dbus_name, type_func=lambda x: x,

1058

variant_level=1):

1248

variant_level=1, invalidate_only=False,

1249

_interface=_interface):

1059

1250

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

1060

1251

its changes to DBus.

1061

1252

1066

1257

to the D-Bus. Default: no transform

1067

1258

variant_level: D-Bus variant level. Default: 1

1068

1259

"""

1069

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

1260

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

1070

1261

def setter(self, value):

1071

1262

if hasattr(self, "dbus_object_path"):

1072

1263

if (not hasattr(self, attrname) or

1073

1264

type_func(getattr(self, attrname, None))

1074

1265

!= type_func(value)):

1075

dbus_value = transform_func(type_func(value),

1076

variant_level

1077

=variant_level)

1078

self.PropertyChanged(dbus.String(dbus_name),

1079

dbus_value)

1266

if invalidate_only:

1267

self.PropertiesChanged(_interface,

1268

dbus.Dictionary(),

1269

dbus.Array

1270

((dbus_name,)))

1271

else:

1272

dbus_value = transform_func(type_func(value),

1273

variant_level

1274

=variant_level)

1275

self.PropertyChanged(dbus.String(dbus_name),

1276

dbus_value)

1277

self.PropertiesChanged(_interface,

1278

dbus.Dictionary({

1279

dbus.String(dbus_name):

1280

dbus_value }), dbus.Array())

1080

1281

setattr(self, attrname, value)

1081

1282

1082

1283

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

1083

1284

1084

1085

1285

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1086

1286

approvals_pending = notifychangeproperty(dbus.Boolean,

1087

1287

"ApprovalPending",

1094

1294

checker is not None)

1095

1295

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1096

1296

"LastCheckedOK")

1297

last_checker_status = notifychangeproperty(dbus.Int16,

1298

"LastCheckerStatus")

1097

1299

last_approval_request = notifychangeproperty(

1098

1300

datetime_to_dbus, "LastApprovalRequest")

1099

1301

approved_by_default = notifychangeproperty(dbus.Boolean,

1101

1303

approval_delay = notifychangeproperty(dbus.UInt64,

1102

1304

"ApprovalDelay",

1103

1305

type_func =

1104

timedelta_to_milliseconds)

1306

lambda td: td.total_seconds()

1307

* 1000)

1105

1308

approval_duration = notifychangeproperty(

1106

1309

dbus.UInt64, "ApprovalDuration",

1107

type_func = timedelta_to_milliseconds)

1310

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

1108

1311

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

1109

1312

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

1110

type_func =

1111

timedelta_to_milliseconds)

1313

type_func = lambda td:

1314

td.total_seconds() * 1000)

1112

1315

extended_timeout = notifychangeproperty(

1113

1316

dbus.UInt64, "ExtendedTimeout",

1114

type_func = timedelta_to_milliseconds)

1317

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

1115

1318

interval = notifychangeproperty(dbus.UInt64,

1116

1319

"Interval",

1117

1320

type_func =

1118

timedelta_to_milliseconds)

1321

lambda td: td.total_seconds()

1322

* 1000)

1119

1323

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

1324

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

1325

invalidate_only=True)

1120

1326

1121

1327

del notifychangeproperty

1122

1328

1149

1355

*args, **kwargs)

1150

1356

1151

1357

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

1152

old_checker = self.checker

1153

if self.checker is not None:

1154

old_checker_pid = self.checker.pid

1155

else:

1156

old_checker_pid = None

1358

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

1157

1359

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

1158

1360

# Only if new checker process was started

1159

1361

if (self.checker is not None

1167

1369

return False

1168

1370

1169

1371

def approve(self, value=True):

1170

self.send_changedstate()

1171

1372

self.approved = value

1172

gobject.timeout_add(timedelta_to_milliseconds

1173

(self.approval_duration),

1174

self._reset_approved)

1175

1373

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

1374

* 1000), self._reset_approved)

1375

self.send_changedstate()

1176

1376

1177

1377

## D-Bus methods, signals & properties

1178

_interface = "se.recompile.Mandos.Client"

1378

1379

## Interfaces

1179

1380

1180

1381

## Signals

1181

1382

1192

1393

pass

1193

1394

1194

1395

# PropertyChanged - signal

1396

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

1195

1397

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

1196

1398

def PropertyChanged(self, property, value):

1197

1399

"D-Bus signal"

1218

1420

"D-Bus signal"

1219

1421

return self.need_approval()

1220

1422

1221

# NeRwequest - signal

1222

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

1223

def NewRequest(self, ip):

1224

"""D-Bus signal

1225

Is sent after a client request a password.

1226

"""

1227

pass

1228

1229

1423

## Methods

1230

1424

1231

1425

# Approve - method

1281

1475

access="readwrite")

1282

1476

def ApprovalDelay_dbus_property(self, value=None):

1283

1477

if value is None: # get

1284

return dbus.UInt64(self.approval_delay_milliseconds())

1478

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

1479

* 1000)

1285

1480

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

1286

1481

1287

1482

# ApprovalDuration - property

1289

1484

access="readwrite")

1290

1485

def ApprovalDuration_dbus_property(self, value=None):

1291

1486

if value is None: # get

1292

return dbus.UInt64(timedelta_to_milliseconds(

1293

self.approval_duration))

1487

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

1488

* 1000)

1294

1489

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

1295

1490

1296

1491

# Name - property

1309

1504

def Host_dbus_property(self, value=None):

1310

1505

if value is None: # get

1311

1506

return dbus.String(self.host)

1312

self.host = unicode(value)

1507

self.host = str(value)

1313

1508

1314

1509

# Created - property

1315

1510

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

1341

1536

return

1342

1537

return datetime_to_dbus(self.last_checked_ok)

1343

1538

1539

# LastCheckerStatus - property

1540

@dbus_service_property(_interface, signature="n",

1541

access="read")

1542

def LastCheckerStatus_dbus_property(self):

1543

return dbus.Int16(self.last_checker_status)

1544

1344

1545

# Expires - property

1345

1546

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

1346

1547

def Expires_dbus_property(self):

1356

1557

access="readwrite")

1357

1558

def Timeout_dbus_property(self, value=None):

1358

1559

if value is None: # get

1359

return dbus.UInt64(self.timeout_milliseconds())

1560

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

1561

old_timeout = self.timeout

1360

1562

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

1361

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

1362

return

1363

# Reschedule timeout

1364

gobject.source_remove(self.disable_initiator_tag)

1365

self.disable_initiator_tag = None

1366

self.expires = None

1367

time_to_die = timedelta_to_milliseconds((self

1368

.last_checked_ok

1369

+ self.timeout)

1370

- datetime.datetime

1371

.utcnow())

1372

if time_to_die <= 0:

1373

# The timeout has passed

1374

self.disable()

1375

else:

1376

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

1377

+ datetime.timedelta(milliseconds =

1378

time_to_die))

1379

self.disable_initiator_tag = (gobject.timeout_add

1380

(time_to_die, self.disable))

1563

# Reschedule disabling

1564

if self.enabled:

1565

now = datetime.datetime.utcnow()

1566

self.expires += self.timeout - old_timeout

1567

if self.expires <= now:

1568

# The timeout has passed

1569

self.disable()

1570

else:

1571

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

1572

is None):

1573

return

1574

gobject.source_remove(self.disable_initiator_tag)

1575

self.disable_initiator_tag = (

1576

gobject.timeout_add(

1577

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

1578

* 1000), self.disable))

1381

1579

1382

1580

# ExtendedTimeout - property

1383

1581

@dbus_service_property(_interface, signature="t",

1384

1582

access="readwrite")

1385

1583

def ExtendedTimeout_dbus_property(self, value=None):

1386

1584

if value is None: # get

1387

return dbus.UInt64(self.extended_timeout_milliseconds())

1585

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

1586

* 1000)

1388

1587

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

1389

1588

1390

1589

# Interval - property

1392

1591

access="readwrite")

1393

1592

def Interval_dbus_property(self, value=None):

1394

1593

if value is None: # get

1395

return dbus.UInt64(self.interval_milliseconds())

1594

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

1396

1595

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

1397

1596

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

1398

1597

return

1409

1608

def Checker_dbus_property(self, value=None):

1410

1609

if value is None: # get

1411

1610

return dbus.String(self.checker_command)

1412

self.checker_command = unicode(value)

1611

self.checker_command = str(value)

1413

1612

1414

1613

# CheckerRunning - property

1415

1614

@dbus_service_property(_interface, signature="b",

1431

1630

@dbus_service_property(_interface, signature="ay",

1432

1631

access="write", byte_arrays=True)

1433

1632

def Secret_dbus_property(self, value):

1434

self.secret = str(value)

1633

self.secret = bytes(value)

1435

1634

1436

1635

del _interface

1437

1636

1462

1661

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

1463

1662

1464

1663

1465

class ClientDBusTransitional(ClientDBus):

1466

__metaclass__ = AlternateDBusNamesMetaclass

1467

1468

1469

1664

class ClientHandler(socketserver.BaseRequestHandler, object):

1470

1665

"""A class to handle client connections.

1471

1666

1475

1670

def handle(self):

1476

1671

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

1477

1672

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

1478

unicode(self.client_address))

1673

str(self.client_address))

1479

1674

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

1480

1675

self.server.child_pipe.fileno())

1481

1676

1507

1702

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

1508

1703

try:

1509

1704

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

1510

raise RuntimeError

1705

raise RuntimeError(line)

1511

1706

except (ValueError, IndexError, RuntimeError) as error:

1512

1707

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

1513

1708

return

1539

1734

except KeyError:

1540

1735

return

1541

1736

1542

if self.server.use_dbus:

1543

# Emit D-Bus signal

1544

client.NewRequest(str(self.client_address))

1545

1546

1737

if client.approval_delay:

1547

1738

delay = client.approval_delay

1548

1739

client.approvals_pending += 1

1566

1757

if self.server.use_dbus:

1567

1758

# Emit D-Bus signal

1568

1759

client.NeedApproval(

1569

client.approval_delay_milliseconds(),

1570

client.approved_by_default)

1760

client.approval_delay.total_seconds()

1761

* 1000, client.approved_by_default)

1571

1762

else:

1572

1763

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

1573

1764

client.name)

1579

1770

#wait until timeout or approved

1580

1771

time = datetime.datetime.now()

1581

1772

client.changedstate.acquire()

1582

(client.changedstate.wait

1583

(float(client.timedelta_to_milliseconds(delay)

1584

/ 1000)))

1773

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

1585

1774

client.changedstate.release()

1586

1775

time2 = datetime.datetime.now()

1587

1776

if (time2 - time) >= delay:

1603

1792

try:

1604

1793

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

1605

1794

except gnutls.errors.GNUTLSError as error:

1606

logger.warning("gnutls send failed")

1795

logger.warning("gnutls send failed",

1796

exc_info=error)

1607

1797

return

1608

1798

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

1609

1799

sent, len(client.secret)

1612

1802

1613

1803

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

1614

1804

# bump the timeout using extended_timeout

1615

client.checked_ok(client.extended_timeout)

1805

client.bump_timeout(client.extended_timeout)

1616

1806

if self.server.use_dbus:

1617

1807

# Emit D-Bus signal

1618

1808

client.GotSecret()

1623

1813

try:

1624

1814

session.bye()

1625

1815

except gnutls.errors.GNUTLSError as error:

1626

logger.warning("GnuTLS bye failed")

1816

logger.warning("GnuTLS bye failed",

1817

exc_info=error)

1627

1818

1628

1819

@staticmethod

1629

1820

def peer_certificate(session):

1701

1892

def process_request(self, request, address):

1702

1893

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

1703

1894

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

1704

args = (request,

1705

address))

1895

args = (request, address))

1706

1896

proc.start()

1707

1897

return proc

1708

1898

1723

1913

1724

1914

def add_pipe(self, parent_pipe, proc):

1725

1915

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

1726

raise NotImplementedError

1916

raise NotImplementedError()

1727

1917

1728

1918

1729

1919

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1736

1926

use_ipv6: Boolean; to use IPv6 or not

1737

1927

"""

1738

1928

def __init__(self, server_address, RequestHandlerClass,

1739

interface=None, use_ipv6=True):

1929

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

1930

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

1931

creating a new one with socket.socket().

1932

"""

1740

1933

self.interface = interface

1741

1934

if use_ipv6:

1742

1935

self.address_family = socket.AF_INET6

1936

if socketfd is not None:

1937

# Save the file descriptor

1938

self.socketfd = socketfd

1939

# Save the original socket.socket() function

1940

self.socket_socket = socket.socket

1941

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

1942

#

1943

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

1944

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

1945

# patching socket.socket.)

1946

#

1947

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

1948

@functools.wraps(socket.socket)

1949

def socket_wrapper(*args, **kwargs):

1950

# Restore original function so subsequent calls are

1951

# not affected.

1952

socket.socket = self.socket_socket

1953

del self.socket_socket

1954

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

1955

# saved file descriptor.

1956

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

1957

# Replace socket.socket() function with wrapper

1958

socket.socket = socket_wrapper

1959

# The socketserver.TCPServer.__init__ will call

1960

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

1961

# socket_wrapper(), if socketfd was set.

1743

1962

socketserver.TCPServer.__init__(self, server_address,

1744

1963

RequestHandlerClass)

1964

1745

1965

def server_bind(self):

1746

1966

"""This overrides the normal server_bind() function

1747

1967

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

1755

1975

try:

1756

1976

self.socket.setsockopt(socket.SOL_SOCKET,

1757

1977

SO_BINDTODEVICE,

1758

str(self.interface

1759

+ '\0'))

1978

(self.interface + "\0")

1979

.encode("utf-8"))

1760

1980

except socket.error as error:

1761

if error[0] == errno.EPERM:

1762

logger.error("No permission to"

1763

" bind to interface %s",

1764

self.interface)

1765

elif error[0] == errno.ENOPROTOOPT:

1981

if error.errno == errno.EPERM:

1982

logger.error("No permission to bind to"

1983

" interface %s", self.interface)

1984

elif error.errno == errno.ENOPROTOOPT:

1766

1985

logger.error("SO_BINDTODEVICE not available;"

1767

1986

" cannot bind to interface %s",

1768

1987

self.interface)

1988

elif error.errno == errno.ENODEV:

1989

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

1990

" cannot bind", self.interface)

1769

1991

else:

1770

1992

raise

1771

1993

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

1774

1996

if self.address_family == socket.AF_INET6:

1775

1997

any_address = "::" # in6addr_any

1776

1998

else:

1777

any_address = socket.INADDR_ANY

1999

any_address = "0.0.0.0" # INADDR_ANY

1778

2000

self.server_address = (any_address,

1779

2001

self.server_address[1])

1780

2002

elif not self.server_address[1]:

1801

2023

"""

1802

2024

def __init__(self, server_address, RequestHandlerClass,

1803

2025

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

1804

gnutls_priority=None, use_dbus=True):

2026

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

1805

2027

self.enabled = False

1806

2028

self.clients = clients

1807

2029

if self.clients is None:

1811

2033

IPv6_TCPServer.__init__(self, server_address,

1812

2034

RequestHandlerClass,

1813

2035

interface = interface,

1814

use_ipv6 = use_ipv6)

2036

use_ipv6 = use_ipv6,

2037

socketfd = socketfd)

1815

2038

def server_activate(self):

1816

2039

if self.enabled:

1817

2040

return socketserver.TCPServer.server_activate(self)

1830

2053

1831

2054

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

1832

2055

proc = None, client_object=None):

1833

condition_names = {

1834

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

1835

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

1836

# blocking).

1837

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

1838

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

1839

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

1840

# broken, usually for pipes and

1841

# sockets).

1842

}

1843

conditions_string = ' | '.join(name

1844

for cond, name in

1845

condition_names.iteritems()

1846

if cond & condition)

1847

2056

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

1848

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

2057

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

1849

2058

# Wait for other process to exit

1850

2059

proc.join()

1851

2060

return False

1909

2118

return True

1910

2119

1911

2120

2121

def rfc3339_duration_to_delta(duration):

2122

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

2123

2124

>>> rfc3339_duration_to_delta("P7D")

2125

datetime.timedelta(7)

2126

>>> rfc3339_duration_to_delta("PT60S")

2127

datetime.timedelta(0, 60)

2128

>>> rfc3339_duration_to_delta("PT60M")

2129

datetime.timedelta(0, 3600)

2130

>>> rfc3339_duration_to_delta("PT24H")

2131

datetime.timedelta(1)

2132

>>> rfc3339_duration_to_delta("P1W")

2133

datetime.timedelta(7)

2134

>>> rfc3339_duration_to_delta("PT5M30S")

2135

datetime.timedelta(0, 330)

2136

>>> rfc3339_duration_to_delta("P1DT3M20S")

2137

datetime.timedelta(1, 200)

2138

"""

2139

2140

# Parsing an RFC 3339 duration with regular expressions is not

2141

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

2142

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

2143

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

2144

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

2145

# avoid excessive use of external libraries.

2146

2147

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

2148

Token = collections.namedtuple("Token",

2149

("regexp", # To match token; if

2150

# "value" is not None,

2151

# must have a "group"

2152

# containing digits

2153

"value", # datetime.timedelta or

2154

# None

2155

"followers")) # Tokens valid after

2156

# this token

2157

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

2158

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

2159

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

2160

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

2161

datetime.timedelta(seconds=1),

2162

frozenset((token_end,)))

2163

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

2164

datetime.timedelta(minutes=1),

2165

frozenset((token_second, token_end)))

2166

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

2167

datetime.timedelta(hours=1),

2168

frozenset((token_minute, token_end)))

2169

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

2170

None,

2171

frozenset((token_hour, token_minute,

2172

token_second)))

2173

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

2174

datetime.timedelta(days=1),

2175

frozenset((token_time, token_end)))

2176

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

2177

datetime.timedelta(weeks=4),

2178

frozenset((token_day, token_end)))

2179

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

2180

datetime.timedelta(weeks=52),

2181

frozenset((token_month, token_end)))

2182

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

2183

datetime.timedelta(weeks=1),

2184

frozenset((token_end,)))

2185

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

2186

frozenset((token_year, token_month,

2187

token_day, token_time,

2188

token_week)))

2189

# Define starting values

2190

value = datetime.timedelta() # Value so far

2191

found_token = None

2192

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

2193

s = duration # String left to parse

2194

# Loop until end token is found

2195

while found_token is not token_end:

2196

# Search for any currently valid tokens

2197

for token in followers:

2198

match = token.regexp.match(s)

2199

if match is not None:

2200

# Token found

2201

if token.value is not None:

2202

# Value found, parse digits

2203

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

2204

# Add to value so far

2205

value += factor * token.value

2206

# Strip token from string

2207

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

2208

# Go to found token

2209

found_token = token

2210

# Set valid next tokens

2211

followers = found_token.followers

2212

break

2213

else:

2214

# No currently valid tokens were found

2215

raise ValueError("Invalid RFC 3339 duration")

2216

# End token found

2217

return value

2218

2219

1912

2220

def string_to_delta(interval):

1913

2221

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

1914

2222

1925

2233

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

1926

2234

datetime.timedelta(0, 330)

1927

2235

"""

2236

2237

try:

2238

return rfc3339_duration_to_delta(interval)

2239

except ValueError:

2240

pass

2241

1928

2242

timevalue = datetime.timedelta(0)

1929

2243

for s in interval.split():

1930

2244

try:

1931

suffix = unicode(s[-1])

2245

suffix = s[-1]

1932

2246

value = int(s[:-1])

1933

2247

if suffix == "d":

1934

2248

delta = datetime.timedelta(value)

1941

2255

elif suffix == "w":

1942

2256

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

1943

2257

else:

1944

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

1945

except (ValueError, IndexError) as e:

2258

raise ValueError("Unknown suffix {!r}"

2259

.format(suffix))

2260

except IndexError as e:

1946

2261

raise ValueError(*(e.args))

1947

2262

timevalue += delta

1948

2263

return timevalue

1961

2276

sys.exit()

1962

2277

if not noclose:

1963

2278

# Close all standard open file descriptors

1964

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

2279

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

1965

2280

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

1966

raise OSError(errno.ENODEV,

1967

"%s not a character device"

1968

% os.path.devnull)

2281

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

2282

.format(os.devnull))

1969

2283

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

1970

2284

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

1971

2285

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

1980

2294

1981

2295

parser = argparse.ArgumentParser()

1982

2296

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

1983

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

2297

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

1984

2298

help="show version number and exit")

1985

2299

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

1986

2300

help="Bind to interface IF")

1992

2306

help="Run self-test")

1993

2307

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

1994

2308

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

1995

" to terminal")

2309

" to terminal", default=None)

1996

2310

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

1997

2311

help="Debug level for stdout output")

1998

2312

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

2005

2319

" files")

2006

2320

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

2007

2321

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

2008

" system bus interface")

2322

" system bus interface", default=None)

2009

2323

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

2010

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

2324

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

2325

default=None)

2011

2326

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

2012

2327

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

2013

" state")

2328

" state", default=None)

2329

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

2330

help="Specify a file descriptor to a network"

2331

" socket to use instead of creating one")

2014

2332

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

2015

2333

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

2334

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

2335

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

2336

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

2337

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

2338

default=None)

2016

2339

2017

2340

options = parser.parse_args()

2018

2341

2019

2342

if options.check:

2020

2343

import doctest

2021

doctest.testmod()

2022

sys.exit()

2344

fail_count, test_count = doctest.testmod()

2345

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

2023

2346

2024

2347

# Default values for config file for server-global settings

2025

2348

server_defaults = { "interface": "",

2027

2350

"port": "",

2028

2351

"debug": "False",

2029

2352

"priority":

2030

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

2353

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

2031

2354

"servicename": "Mandos",

2032

2355

"use_dbus": "True",

2033

2356

"use_ipv6": "True",

2034

2357

"debuglevel": "",

2035

2358

"restore": "True",

2036

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

2359

"socket": "",

2360

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

2361

"foreground": "False",

2362

"zeroconf": "True",

2037

2363

}

2038

2364

2039

2365

# Parse config file for server-global settings

2044

2370

# Convert the SafeConfigParser object to a dict

2045

2371

server_settings = server_config.defaults()

2046

2372

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

2047

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

2373

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

2048

2374

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

2049

2375

option)

2050

2376

if server_settings["port"]:

2051

2377

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

2052

2378

"port")

2379

if server_settings["socket"]:

2380

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

2381

"socket")

2382

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

2383

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

2384

# happen with a supplied network socket.

2385

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

2386

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

2387

["socket"])

2053

2388

del server_config

2054

2389

2055

2390

# Override the settings from the config file with command line

2057

2392

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

2058

2393

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

2059

2394

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

2060

"statedir"):

2395

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

2061

2396

value = getattr(options, option)

2062

2397

if value is not None:

2063

2398

server_settings[option] = value

2064

2399

del options

2065

2400

# Force all strings to be unicode

2066

2401

for option in server_settings.keys():

2067

if type(server_settings[option]) is str:

2068

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

2402

if isinstance(server_settings[option], bytes):

2403

server_settings[option] = (server_settings[option]

2404

.decode("utf-8"))

2405

# Force all boolean options to be boolean

2406

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

2407

"foreground", "zeroconf"):

2408

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

2409

# Debug implies foreground

2410

if server_settings["debug"]:

2411

server_settings["foreground"] = True

2069

2412

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

2070

2413

2071

2414

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

2072

2415

2416

if (not server_settings["zeroconf"] and

2417

not (server_settings["port"]

2418

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

2419

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

2420

" Zeroconf")

2421

2073

2422

# For convenience

2074

2423

debug = server_settings["debug"]

2075

2424

debuglevel = server_settings["debuglevel"]

2077

2426

use_ipv6 = server_settings["use_ipv6"]

2078

2427

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

2079

2428

stored_state_file)

2429

foreground = server_settings["foreground"]

2430

zeroconf = server_settings["zeroconf"]

2080

2431

2081

2432

if debug:

2082

2433

initlogger(debug, logging.DEBUG)

2089

2440

2090

2441

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

2091

2442

syslogger.setFormatter(logging.Formatter

2092

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

2093

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

2094

% server_settings["servicename"]))

2443

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

2444

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

2445

.format(server_settings

2446

["servicename"])))

2095

2447

2096

2448

# Parse config file with clients

2097

client_config = configparser.SafeConfigParser(Client.client_defaults)

2449

client_config = configparser.SafeConfigParser(Client

2450

.client_defaults)

2098

2451

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

2099

2452

"clients.conf"))

2100

2453

2101

2454

global mandos_dbus_service

2102

2455

mandos_dbus_service = None

2103

2456

2457

socketfd = None

2458

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

2459

socketfd = server_settings["socket"]

2104

2460

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

2105

2461

server_settings["port"]),

2106

2462

ClientHandler,

2109

2465

use_ipv6=use_ipv6,

2110

2466

gnutls_priority=

2111

2467

server_settings["priority"],

2112

use_dbus=use_dbus)

2113

if not debug:

2114

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

2468

use_dbus=use_dbus,

2469

socketfd=socketfd)

2470

if not foreground:

2471

pidfilename = "/run/mandos.pid"

2472

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

2473

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

2474

pidfile = None

2115

2475

try:

2116

2476

pidfile = open(pidfilename, "w")

2117

except IOError:

2118

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

2477

except IOError as e:

2478

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

2479

exc_info=e)

2119

2480

2120

try:

2121

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

2122

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

2123

except KeyError:

2481

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

2124

2482

try:

2125

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

2126

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

2483

uid = pwd.getpwnam(name).pw_uid

2484

gid = pwd.getpwnam(name).pw_gid

2485

break

2127

2486

except KeyError:

2128

try:

2129

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

2130

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

2131

except KeyError:

2132

uid = 65534

2133

gid = 65534

2487

continue

2488

else:

2489

uid = 65534

2490

gid = 65534

2134

2491

try:

2135

2492

os.setgid(gid)

2136

2493

os.setuid(uid)

2137

2494

except OSError as error:

2138

if error[0] != errno.EPERM:

2139

raise error

2495

if error.errno != errno.EPERM:

2496

raise

2140

2497

2141

2498

if debug:

2142

2499

# Enable all possible GnuTLS debugging

2153

2510

.gnutls_global_set_log_function(debug_gnutls))

2154

2511

2155

2512

# Redirect stdin so all checkers get /dev/null

2156

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

2513

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

2157

2514

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

2158

2515

if null > 2:

2159

2516

os.close(null)

2160

2517

2161

2518

# Need to fork before connecting to D-Bus

2162

if not debug:

2519

if not foreground:

2163

2520

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

2164

2521

daemon()

2165

2522

2523

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

2524

# need to inform gobject that threads will be used.

2166

2525

gobject.threads_init()

2167

2526

2168

2527

global main_loop

2169

2528

# From the Avahi example code

2170

DBusGMainLoop(set_as_default=True )

2529

DBusGMainLoop(set_as_default=True)

2171

2530

main_loop = gobject.MainLoop()

2172

2531

bus = dbus.SystemBus()

2173

2532

# End of Avahi example code

2179

2538

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

2180

2539

do_not_queue=True))

2181

2540

except dbus.exceptions.NameExistsException as e:

2182

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

2541

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

2183

2542

use_dbus = False

2184

2543

server_settings["use_dbus"] = False

2185

2544

tcp_server.use_dbus = False

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"])))

2545

if zeroconf:

2546

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2547

service = AvahiServiceToSyslog(name =

2548

server_settings["servicename"],

2549

servicetype = "_mandos._tcp",

2550

protocol = protocol, bus = bus)

2551

if server_settings["interface"]:

2552

service.interface = (if_nametoindex

2553

(server_settings["interface"]

2554

.encode("utf-8")))

2194

2555

2195

2556

global multiprocessing_manager

2196

2557

multiprocessing_manager = multiprocessing.Manager()

2197

2558

2198

2559

client_class = Client

2199

2560

if use_dbus:

2200

client_class = functools.partial(ClientDBusTransitional,

2201

bus = bus)

2561

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

2202

2562

2203

2563

client_settings = Client.config_parser(client_config)

2204

2564

old_client_settings = {}

2205

2565

clients_data = {}

2206

2566

2567

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

2568

global wnull

2569

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

2570

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

2571

# mode

2572

if debug or not foreground:

2573

wnull.close()

2574

2207

2575

# Get client data and settings from last running state.

2208

2576

if server_settings["restore"]:

2209

2577

try:

2212

2580

(stored_state))

2213

2581

os.remove(stored_state_path)

2214

2582

except IOError as e:

2215

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

2216

.format(e))

2217

if e.errno != errno.ENOENT:

2583

if e.errno == errno.ENOENT:

2584

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

2585

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

2586

else:

2587

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

2588

exc_info=e)

2218

2589

raise

2219

2590

except EOFError as e:

2220

2591

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

2221

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

2592

"EOFError:", exc_info=e)

2222

2593

2223

2594

with PGPEngine() as pgp:

2224

for client_name, client in clients_data.iteritems():

2595

for client_name, client in clients_data.items():

2596

# Skip removed clients

2597

if client_name not in client_settings:

2598

continue

2599

2225

2600

# Decide which value to use after restoring saved state.

2226

2601

# We have three different values: Old config file,

2227

2602

# new config file, and saved state.

2241

2616

2242

2617

# Clients who has passed its expire date can still be

2243

2618

# enabled if its last checker was successful. Clients

2244

# whose checker failed before we stored its state is

2245

# assumed to have failed all checkers during downtime.

2619

# whose checker succeeded before we stored its state is

2620

# assumed to have successfully run all checkers during

2621

# downtime.

2246

2622

if client["enabled"]:

2247

2623

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

2248

2624

if not client["last_checked_ok"]:

2249

2625

logger.warning(

2250

"disabling client {0} - Client never "

2251

"performed a successfull checker"

2252

.format(client["name"]))

2626

"disabling client {} - Client never "

2627

"performed a successful checker"

2628

.format(client_name))

2253

2629

client["enabled"] = False

2254

2630

elif client["last_checker_status"] != 0:

2255

2631

logger.warning(

2256

"disabling client {0} - Client "

2257

"last checker failed with error code {1}"

2258

.format(client["name"],

2632

"disabling client {} - Client last"

2633

" checker failed with error code {}"

2634

.format(client_name,

2259

2635

client["last_checker_status"]))

2260

2636

client["enabled"] = False

2261

2637

else:

2262

2638

client["expires"] = (datetime.datetime

2263

2639

.utcnow()

2264

2640

+ client["timeout"])

2265

2641

logger.debug("Last checker succeeded,"

2642

" keeping {} enabled"

2643

.format(client_name))

2266

2644

try:

2267

2645

client["secret"] = (

2268

2646

pgp.decrypt(client["encrypted_secret"],

2270

2648

["secret"]))

2271

2649

except PGPError:

2272

2650

# If decryption fails, we use secret from new settings

2273

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

2651

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

2274

2652

.format(client_name))

2275

2653

client["secret"] = (

2276

2654

client_settings[client_name]["secret"])

2277

2278

2655

2279

2656

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

2280

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

2657

for client_name in (set(old_client_settings)

2658

- set(client_settings)):

2281

2659

del clients_data[client_name]

2282

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

2660

for client_name in (set(client_settings)

2661

- set(old_client_settings)):

2283

2662

clients_data[client_name] = client_settings[client_name]

2284

2285

# Create clients all clients

2286

for client_name, client in clients_data.iteritems():

2663

2664

# Create all client objects

2665

for client_name, client in clients_data.items():

2287

2666

tcp_server.clients[client_name] = client_class(

2288

name = client_name, settings = client)

2667

name = client_name, settings = client,

2668

server_settings = server_settings)

2289

2669

2290

2670

if not tcp_server.clients:

2291

2671

logger.warning("No clients defined")

2292

2293

if not debug:

2294

try:

2295

with pidfile:

2296

pid = os.getpid()

2297

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

2298

del pidfile

2299

except IOError:

2300

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

2301

pidfilename, pid)

2302

except NameError:

2303

# "pidfile" was never created

2304

pass

2672

2673

if not foreground:

2674

if pidfile is not None:

2675

try:

2676

with pidfile:

2677

pid = os.getpid()

2678

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

2679

except IOError:

2680

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

2681

pidfilename, pid)

2682

del pidfile

2305

2683

del pidfilename

2306

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

2307

2684

2308

2685

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

2309

2686

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

2310

2687

2311

2688

if use_dbus:

2312

class MandosDBusService(dbus.service.Object):

2689

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

2690

"se.bsnet.fukt.Mandos"})

2691

class MandosDBusService(DBusObjectWithProperties):

2313

2692

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

2314

2693

def __init__(self):

2315

2694

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

2316

2695

_interface = "se.recompile.Mandos"

2317

2696

2697

@dbus_interface_annotations(_interface)

2698

def _foo(self):

2699

return { "org.freedesktop.DBus.Property"

2700

".EmitsChangedSignal":

2701

"false"}

2702

2318

2703

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

2319

2704

def ClientAdded(self, objpath):

2320

2705

"D-Bus signal"

2342

2727

def GetAllClientsWithProperties(self):

2343

2728

"D-Bus method"

2344

2729

return dbus.Dictionary(

2345

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

2346

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

2730

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

2731

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

2347

2732

signature="oa{sv}")

2348

2733

2349

2734

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

2362

2747

2363

2748

del _interface

2364

2749

2365

class MandosDBusServiceTransitional(MandosDBusService):

2366

__metaclass__ = AlternateDBusNamesMetaclass

2367

mandos_dbus_service = MandosDBusServiceTransitional()

2750

mandos_dbus_service = MandosDBusService()

2368

2751

2369

2752

def cleanup():

2370

2753

"Cleanup function; run on exit"

2371

service.cleanup()

2754

if zeroconf:

2755

service.cleanup()

2372

2756

2373

2757

multiprocessing.active_children()

2758

wnull.close()

2374

2759

if not (tcp_server.clients or client_settings):

2375

2760

return

2376

2761

2387

2772

2388

2773

# A list of attributes that can not be pickled

2389

2774

# + secret.

2390

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

2391

"checker"))

2775

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

2776

"checker", "server_settings" }

2392

2777

for name, typ in (inspect.getmembers

2393

2778

(dbus.service.Object)):

2394

2779

exclude.add(name)

2403

2788

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

2404

2789

2405

2790

try:

2406

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

2407

prefix="clients-",

2408

dir=os.path.dirname

2409

(stored_state_path))

2410

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

2791

with (tempfile.NamedTemporaryFile

2792

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

2793

dir=os.path.dirname(stored_state_path),

2794

delete=False)) as stored_state:

2411

2795

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

2796

tempname=stored_state.name

2412

2797

os.rename(tempname, stored_state_path)

2413

2798

except (IOError, OSError) as e:

2414

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

2415

.format(e))

2416

2799

if not debug:

2417

2800

try:

2418

2801

os.remove(tempname)

2419

2802

except NameError:

2420

2803

pass

2421

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

2422

errno.EEXIST)):

2423

raise e

2804

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

2805

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

2806

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

2807

else:

2808

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

2809

exc_info=e)

2810

raise

2424

2811

2425

2812

# Delete all clients, and settings from config

2426

2813

while tcp_server.clients:

2450

2837

tcp_server.server_activate()

2451

2838

2452

2839

# Find out what port we got

2453

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

2840

if zeroconf:

2841

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

2454

2842

if use_ipv6:

2455

2843

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

2456

" flowinfo %d, scope_id %d"

2457

% tcp_server.socket.getsockname())

2844

" flowinfo %d, scope_id %d",

2845

*tcp_server.socket.getsockname())

2458

2846

else: # IPv4

2459

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

2460

% tcp_server.socket.getsockname())

2847

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

2848

*tcp_server.socket.getsockname())

2461

2849

2462

2850

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

2463

2851

2464

2852

try:

2465

# From the Avahi example code

2466

try:

2467

service.activate()

2468

except dbus.exceptions.DBusException as error:

2469

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

2470

cleanup()

2471

sys.exit(1)

2472

# End of Avahi example code

2853

if zeroconf:

2854

# From the Avahi example code

2855

try:

2856

service.activate()

2857

except dbus.exceptions.DBusException as error:

2858

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

2859

cleanup()

2860

sys.exit(1)

2861

# End of Avahi example code

2473

2862

2474

2863

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

2475

2864

lambda *args, **kwargs:

2479

2868

logger.debug("Starting main loop")

2480

2869

main_loop.run()

2481

2870

except AvahiError as error:

2482

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

2871

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

2483

2872

cleanup()

2484

2873

sys.exit(1)

2485

2874

except KeyboardInterrupt: