/mandos/trunk : revision 539

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.8"

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

113

def initlogger(debug, 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'))

143

136

class PGPEngine(object):

144

137

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

145

138

def __init__(self):

139

self.gnupg = GnuPGInterface.GnuPG()

146

140

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

147

self.gnupgargs = ['--batch',

148

'--home', self.tempdir,

149

'--force-mdc',

150

'--quiet',

151

'--no-use-agent']

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

152

146

153

147

def __enter__(self):

154

148

return self

155

149

156

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

150

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

157

151

self._cleanup()

158

152

return False

159

153

176

170

def password_encode(self, password):

177

171

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

178

172

# 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

173

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

186

174

187

175

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)

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

203

190

return ciphertext

204

191

205

192

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)

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

222

207

return decrypted_plaintext

223

208

224

209

210

225

211

class AvahiError(Exception):

226

212

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

227

213

self.value = value

228

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

229

**kwargs)

214

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

215

def __unicode__(self):

216

return unicode(repr(self.value))

230

217

231

218

class AvahiServiceError(AvahiError):

232

219

pass

243

230

Used to optionally bind to the specified interface.

244

231

name: string; Example: 'Mandos'

245

232

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

246

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

233

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

247

234

port: integer; what port to announce

248

235

TXT: list of strings; TXT record for the service

249

236

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

255

242

server: D-Bus Server

256

243

bus: dbus.SystemBus()

257

244

"""

258

259

245

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

260

246

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

261

247

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

274

260

self.server = None

275

261

self.bus = bus

276

262

self.entry_group_state_changed_match = None

277

278

263

def rename(self):

279

264

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

280

265

if self.rename_count >= self.max_renames:

282

267

" after %i retries, exiting.",

283

268

self.rename_count)

284

269

raise AvahiServiceError("Too many renames")

285

self.name = str(self.server

286

.GetAlternativeServiceName(self.name))

270

self.name = unicode(self.server

271

.GetAlternativeServiceName(self.name))

287

272

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

288

273

self.name)

289

274

self.remove()

290

275

try:

291

276

self.add()

292

277

except dbus.exceptions.DBusException as error:

293

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

278

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

294

279

self.cleanup()

295

280

os._exit(1)

296

281

self.rename_count += 1

297

298

282

def remove(self):

299

283

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

300

284

if self.entry_group_state_changed_match is not None:

302

286

self.entry_group_state_changed_match = None

303

287

if self.group is not None:

304

288

self.group.Reset()

305

306

289

def add(self):

307

290

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

308

291

self.remove()

325

308

dbus.UInt16(self.port),

326

309

avahi.string_array_to_txt_array(self.TXT))

327

310

self.group.Commit()

328

329

311

def entry_group_state_changed(self, state, error):

330

312

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

331

313

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

337

319

self.rename()

338

320

elif state == avahi.ENTRY_GROUP_FAILURE:

339

321

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

340

str(error))

341

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

342

.format(error))

343

322

unicode(error))

323

raise AvahiGroupError("State changed: %s"

324

% unicode(error))

344

325

def cleanup(self):

345

326

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

346

327

if self.group is not None:

351

332

pass

352

333

self.group = None

353

334

self.remove()

354

355

335

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

356

336

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

357

337

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

376

356

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

377

357

else:

378

358

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

379

380

359

def activate(self):

381

360

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

382

361

if self.server is None:

389

368

self.server_state_changed)

390

369

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

391

370

392

393

371

class AvahiServiceToSyslog(AvahiService):

394

372

def rename(self):

395

373

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

396

374

ret = AvahiService.rename(self)

397

375

syslogger.setFormatter(logging.Formatter

398

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

399

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

400

.format(self.name)))

376

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

377

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

378

% self.name))

401

379

return ret

402

380

403

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

404

387

class Client(object):

405

388

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

406

389

431

414

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

432

415

last_checker_status: integer between 0 and 255 reflecting exit

433

416

status of last checker. -1 reflects crashed

434

checker, -2 means no checker completed yet.

417

checker, or None.

435

418

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

436

419

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

437

420

D-Bus identifiers

438

421

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

439

422

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

440

423

until this client is disabled

441

extended_timeout: extra long timeout when secret has been sent

424

extended_timeout: extra long timeout when password has been sent

442

425

runtime_expansions: Allowed attributes for runtime expansion.

443

426

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

444

427

disabled, or None

445

server_settings: The server_settings dict from main()

446

428

"""

447

429

448

430

runtime_expansions = ("approval_delay", "approval_duration",

449

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

450

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

451

"last_approval_request", "last_checked_ok",

431

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

432

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

452

433

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

453

client_defaults = { "timeout": "PT5M",

454

"extended_timeout": "PT15M",

455

"interval": "PT2M",

434

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

435

"extended_timeout": "15m",

436

"interval": "2m",

456

437

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

457

438

"host": "",

458

"approval_delay": "PT0S",

459

"approval_duration": "PT1S",

439

"approval_delay": "0s",

440

"approval_duration": "1s",

460

441

"approved_by_default": "True",

461

442

"enabled": "True",

462

443

}

463

444

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

464

460

@staticmethod

465

461

def config_parser(config):

466

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

462

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

467

463

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

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

"""

464

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

472

465

settings = {}

473

466

for client_name in config.sections():

474

467

section = dict(config.items(client_name))

478

471

# Reformat values from string types to Python types

479

472

client["approved_by_default"] = config.getboolean(

480

473

client_name, "approved_by_default")

481

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

482

"enabled")

474

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

483

475

484

476

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

485

477

.replace(" ", ""))

491

483

"rb") as secfile:

492

484

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

493

485

else:

494

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

495

.format(section))

486

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

487

% section)

496

488

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

497

489

client["extended_timeout"] = string_to_delta(

498

490

section["extended_timeout"])

504

496

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

505

497

client["last_approval_request"] = None

506

498

client["last_checked_ok"] = None

507

client["last_checker_status"] = -2

508

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

509

508

return settings

510

511

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

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."""

512

515

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.items():

517

for setting, value in settings.iteritems():

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

530

520

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

531

521

# Uppercase and remove spaces from fingerprint for later

532

522

# comparison purposes with return value from the fingerprint()

533

523

# function

534

524

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

535

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

536

datetime.datetime.utcnow())

537

525

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

526

538

527

# attributes specific for this server instance

539

528

self.checker = None

540

529

self.checker_initiator_tag = None

568

557

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

569

558

# Already enabled

570

559

return

560

self.send_changedstate()

571

561

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

572

562

self.enabled = True

573

563

self.last_enabled = datetime.datetime.utcnow()

574

564

self.init_checker()

575

self.send_changedstate()

576

565

577

566

def disable(self, quiet=True):

578

567

"""Disable this client."""

579

568

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

580

569

return False

581

570

if not quiet:

571

self.send_changedstate()

572

if not quiet:

582

573

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

583

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

574

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

584

575

gobject.source_remove(self.disable_initiator_tag)

585

576

self.disable_initiator_tag = None

586

577

self.expires = None

587

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

578

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

588

579

gobject.source_remove(self.checker_initiator_tag)

589

580

self.checker_initiator_tag = None

590

581

self.stop_checker()

591

582

self.enabled = False

592

if not quiet:

593

self.send_changedstate()

594

583

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

595

584

return False

596

585

600

589

def init_checker(self):

601

590

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

602

591

# and every interval from then on.

603

if self.checker_initiator_tag is not None:

604

gobject.source_remove(self.checker_initiator_tag)

605

592

self.checker_initiator_tag = (gobject.timeout_add

606

(int(self.interval

607

.total_seconds() * 1000),

593

(self.interval_milliseconds(),

608

594

self.start_checker))

609

595

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

610

if self.disable_initiator_tag is not None:

611

gobject.source_remove(self.disable_initiator_tag)

612

596

self.disable_initiator_tag = (gobject.timeout_add

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

597

(self.timeout_milliseconds(),

598

self.disable))

616

599

# Also start a new checker *right now*.

617

600

self.start_checker()

618

601

634

617

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

635

618

vars(self))

636

619

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."""

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

"""

645

626

if timeout is None:

646

627

timeout = self.timeout

628

self.last_checked_ok = datetime.datetime.utcnow()

647

629

if self.disable_initiator_tag is not None:

648

630

gobject.source_remove(self.disable_initiator_tag)

649

self.disable_initiator_tag = None

650

631

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

651

632

self.disable_initiator_tag = (gobject.timeout_add

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

633

(timedelta_to_milliseconds

634

(timeout), self.disable))

654

635

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

655

636

656

637

def need_approval(self):

662

643

If a checker already exists, leave it running and do

663

644

nothing."""

664

645

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

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

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

669

650

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

670

651

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

671

652

# should be.

673

654

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

674

655

try:

675

656

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

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

657

except (AttributeError, OSError) as error:

658

if (isinstance(error, OSError)

659

and error.errno != errno.ECHILD):

660

raise error

681

661

else:

682

662

if pid:

683

663

logger.warning("Checker was a zombie")

686

666

self.current_checker_command)

687

667

# Start a new checker if needed

688

668

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 }

693

669

try:

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

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

699

688

self.current_checker_command = command

700

689

try:

701

690

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

704

693

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

705

694

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

706

695

# 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 })

715

696

self.checker = subprocess.Popen(command,

716

697

close_fds=True,

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:

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.

730

705

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)

731

709

except OSError as 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)

710

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

711

error)

741

712

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

742

713

return True

743

714

750

721

return

751

722

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

752

723

try:

753

self.checker.terminate()

724

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

754

725

#time.sleep(0.5)

755

726

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

756

# self.checker.kill()

727

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

757

728

except OSError as error:

758

729

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

759

730

raise

776

747

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

777

748

if byte_arrays and signature != "ay":

778

749

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

779

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

750

" signature %r" % signature)

780

751

def decorator(func):

781

752

func._dbus_is_property = True

782

753

func._dbus_interface = dbus_interface

790

761

return decorator

791

762

792

763

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

830

764

class DBusPropertyException(dbus.exceptions.DBusException):

831

765

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

832

766

"""

833

pass

767

def __unicode__(self):

768

return unicode(str(self))

769

834

770

835

771

class DBusPropertyAccessException(DBusPropertyException):

836

772

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

853

789

"""

854

790

855

791

@staticmethod

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)

792

def _is_dbus_property(obj):

793

return getattr(obj, "_dbus_is_property", False)

864

794

865

def _get_all_dbus_things(self, thing):

795

def _get_all_dbus_properties(self):

866

796

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

867

797

"""

868

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

869

name),

870

athing.__get__(self))

798

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

871

799

for cls in self.__class__.__mro__

872

for name, athing in

873

inspect.getmembers(cls,

874

self._is_dbus_thing(thing)))

800

for name, prop in

801

inspect.getmembers(cls, self._is_dbus_property))

875

802

876

803

def _get_dbus_property(self, interface_name, property_name):

877

804

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

879

806

"""

880

807

for cls in self.__class__.__mro__:

881

808

for name, value in (inspect.getmembers

882

(cls,

883

self._is_dbus_thing("property"))):

809

(cls, self._is_dbus_property)):

884

810

if (value._dbus_name == property_name

885

811

and value._dbus_interface == interface_name):

886

812

return value.__get__(self)

914

840

# The byte_arrays option is not supported yet on

915

841

# signatures other than "ay".

916

842

if prop._dbus_signature != "ay":

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

843

raise ValueError

844

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

845

for byte in value))

922

846

prop(value)

923

847

924

848

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

930

854

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

931

855

"""

932

856

properties = {}

933

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

857

for name, prop in self._get_all_dbus_properties():

934

858

if (interface_name

935

859

and interface_name != prop._dbus_interface):

936

860

# Interface non-empty but did not match

946

870

value.variant_level+1)

947

871

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

948

872

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

957

873

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

958

874

out_signature="s",

959

875

path_keyword='object_path',

960

876

connection_keyword='connection')

961

877

def Introspect(self, object_path, connection):

962

"""Overloading of standard D-Bus method.

963

964

Inserts property tags and interface annotation tags.

878

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

965

879

"""

966

880

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

967

881

connection)

974

888

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

975

889

return e

976

890

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

977

# Add property tags

978

891

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

979

892

for name, prop

980

in self._get_all_dbus_things("property")

893

in self._get_all_dbus_properties()

981

894

if prop._dbus_interface

982

895

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

983

896

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)

1015

897

# Add the names to the return values for the

1016

898

# "org.freedesktop.DBus.Properties" methods

1017

899

if (if_tag.getAttribute("name")

1032

914

except (AttributeError, xml.dom.DOMException,

1033

915

xml.parsers.expat.ExpatError) as error:

1034

916

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

1035

exc_info=error)

917

error)

1036

918

return xmlstring

1037

919

1038

920

1039

def datetime_to_dbus(dt, variant_level=0):

921

def datetime_to_dbus (dt, variant_level=0):

1040

922

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

1041

923

if dt is None:

1042

924

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

1044

926

variant_level=variant_level)

1045

927

1046

928

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).

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.

1069

933

"""

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):

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):

1077

941

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

1078

942

# with the wrong interface name

1079

943

if (not hasattr(attribute, "_dbus_interface")

1080

944

or not attribute._dbus_interface

1081

.startswith(orig_interface_name)):

945

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

1082

946

continue

1083

947

# Create an alternate D-Bus interface name based on

1084

948

# the current name

1085

949

alt_interface = (attribute._dbus_interface

1086

.replace(orig_interface_name,

1087

alt_interface_name))

1088

interface_names.add(alt_interface)

950

.replace("se.recompile.Mandos",

951

"se.bsnet.fukt.Mandos"))

1089

952

# Is this a D-Bus signal?

1090

953

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

1091

# Extract the original non-method undecorated

1092

# function by black magic

954

# Extract the original non-method function by

955

# black magic

1093

956

nonmethod_func = (dict(

1094

957

zip(attribute.func_code.co_freevars,

1095

958

attribute.__closure__))["func"]

1106

969

nonmethod_func.func_name,

1107

970

nonmethod_func.func_defaults,

1108

971

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

1115

972

# Define a creator of a function to call both the

1116

# original and alternate functions, so both the

1117

# original and alternate signals gets sent when

1118

# the function is called

973

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

974

# signals gets sent when the function is called

1119

975

def fixscope(func1, func2):

1120

976

"""This function is a scope container to pass

1121

977

func1 and func2 to the "call_both" function

1128

984

return call_both

1129

985

# Create the "call_both" function and add it to

1130

986

# the class

1131

attr[attrname] = fixscope(attribute, new_function)

987

attr[attrname] = fixscope(attribute,

988

new_function)

1132

989

# Is this a D-Bus method?

1133

990

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

1134

991

# Create a new, but exactly alike, function

1145

1002

attribute.func_name,

1146

1003

attribute.func_defaults,

1147

1004

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

1154

1005

# Is this a D-Bus property?

1155

1006

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

1156

1007

# Create a new, but exactly alike, function

1170

1021

attribute.func_name,

1171

1022

attribute.func_defaults,

1172

1023

attribute.func_closure)))

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

1024

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

1025

1026

1218

1027

class ClientDBus(Client, DBusObjectWithProperties):

1219

1028

"""A Client class using D-Bus

1220

1029

1226

1035

runtime_expansions = (Client.runtime_expansions

1227

1036

+ ("dbus_object_path",))

1228

1037

1229

_interface = "se.recompile.Mandos.Client"

1230

1231

1038

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

1232

1039

1233

1040

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

1234

1041

self.bus = bus

1235

1042

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

1043

self._approvals_pending = 0

1044

1045

self._approvals_pending = 0

1236

1046

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

1237

1047

# the D-Bus

1238

client_object_name = str(self.name).translate(

1048

client_object_name = unicode(self.name).translate(

1239

1049

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

1240

1050

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

1241

1051

self.dbus_object_path = (dbus.ObjectPath

1242

1052

("/clients/" + client_object_name))

1243

1053

DBusObjectWithProperties.__init__(self, self.bus,

1244

1054

self.dbus_object_path)

1245

1055

1246

1056

def notifychangeproperty(transform_func,

1247

1057

dbus_name, type_func=lambda x: x,

1248

variant_level=1, invalidate_only=False,

1249

_interface=_interface):

1058

variant_level=1):

1250

1059

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

1251

1060

its changes to DBus.

1252

1061

1257

1066

to the D-Bus. Default: no transform

1258

1067

variant_level: D-Bus variant level. Default: 1

1259

1068

"""

1260

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

1069

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

1261

1070

def setter(self, value):

1262

1071

if hasattr(self, "dbus_object_path"):

1263

1072

if (not hasattr(self, attrname) or

1264

1073

type_func(getattr(self, attrname, None))

1265

1074

!= type_func(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())

1075

dbus_value = transform_func(type_func(value),

1076

variant_level

1077

=variant_level)

1078

self.PropertyChanged(dbus.String(dbus_name),

1079

dbus_value)

1281

1080

setattr(self, attrname, value)

1282

1081

1283

1082

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

1284

1083

1084

1285

1085

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1286

1086

approvals_pending = notifychangeproperty(dbus.Boolean,

1287

1087

"ApprovalPending",

1294

1094

checker is not None)

1295

1095

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1296

1096

"LastCheckedOK")

1297

last_checker_status = notifychangeproperty(dbus.Int16,

1298

"LastCheckerStatus")

1299

1097

last_approval_request = notifychangeproperty(

1300

1098

datetime_to_dbus, "LastApprovalRequest")

1301

1099

approved_by_default = notifychangeproperty(dbus.Boolean,

1303

1101

approval_delay = notifychangeproperty(dbus.UInt64,

1304

1102

"ApprovalDelay",

1305

1103

type_func =

1306

lambda td: td.total_seconds()

1307

* 1000)

1104

timedelta_to_milliseconds)

1308

1105

approval_duration = notifychangeproperty(

1309

1106

dbus.UInt64, "ApprovalDuration",

1310

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

1107

type_func = timedelta_to_milliseconds)

1311

1108

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

1312

1109

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

1313

type_func = lambda td:

1314

td.total_seconds() * 1000)

1110

type_func =

1111

timedelta_to_milliseconds)

1315

1112

extended_timeout = notifychangeproperty(

1316

1113

dbus.UInt64, "ExtendedTimeout",

1317

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

1114

type_func = timedelta_to_milliseconds)

1318

1115

interval = notifychangeproperty(dbus.UInt64,

1319

1116

"Interval",

1320

1117

type_func =

1321

lambda td: td.total_seconds()

1322

* 1000)

1118

timedelta_to_milliseconds)

1323

1119

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

1324

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

1325

invalidate_only=True)

1326

1120

1327

1121

del notifychangeproperty

1328

1122

1355

1149

*args, **kwargs)

1356

1150

1357

1151

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

1358

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

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

1359

1157

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

1360

1158

# Only if new checker process was started

1361

1159

if (self.checker is not None

1369

1167

return False

1370

1168

1371

1169

def approve(self, value=True):

1170

self.send_changedstate()

1372

1171

self.approved = value

1373

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

1374

* 1000), self._reset_approved)

1375

self.send_changedstate()

1172

gobject.timeout_add(timedelta_to_milliseconds

1173

(self.approval_duration),

1174

self._reset_approved)

1175

1376

1176

1377

1177

## D-Bus methods, signals & properties

1378

1379

## Interfaces

1178

_interface = "se.recompile.Mandos.Client"

1380

1179

1381

1180

## Signals

1382

1181

1393

1192

pass

1394

1193

1395

1194

# PropertyChanged - signal

1396

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

1397

1195

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

1398

1196

def PropertyChanged(self, property, value):

1399

1197

"D-Bus signal"

1420

1218

"D-Bus signal"

1421

1219

return self.need_approval()

1422

1220

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

1423

1229

## Methods

1424

1230

1425

1231

# Approve - method

1475

1281

access="readwrite")

1476

1282

def ApprovalDelay_dbus_property(self, value=None):

1477

1283

if value is None: # get

1478

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

1479

* 1000)

1284

return dbus.UInt64(self.approval_delay_milliseconds())

1480

1285

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

1481

1286

1482

1287

# ApprovalDuration - property

1484

1289

access="readwrite")

1485

1290

def ApprovalDuration_dbus_property(self, value=None):

1486

1291

if value is None: # get

1487

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

1488

* 1000)

1292

return dbus.UInt64(timedelta_to_milliseconds(

1293

self.approval_duration))

1489

1294

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

1490

1295

1491

1296

# Name - property

1504

1309

def Host_dbus_property(self, value=None):

1505

1310

if value is None: # get

1506

1311

return dbus.String(self.host)

1507

self.host = str(value)

1312

self.host = unicode(value)

1508

1313

1509

1314

# Created - property

1510

1315

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

1536

1341

return

1537

1342

return datetime_to_dbus(self.last_checked_ok)

1538

1343

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

1545

1344

# Expires - property

1546

1345

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

1547

1346

def Expires_dbus_property(self):

1557

1356

access="readwrite")

1558

1357

def Timeout_dbus_property(self, value=None):

1559

1358

if value is None: # get

1560

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

1561

old_timeout = self.timeout

1359

return dbus.UInt64(self.timeout_milliseconds())

1562

1360

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

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

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

1579

1381

1580

1382

# ExtendedTimeout - property

1581

1383

@dbus_service_property(_interface, signature="t",

1582

1384

access="readwrite")

1583

1385

def ExtendedTimeout_dbus_property(self, value=None):

1584

1386

if value is None: # get

1585

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

1586

* 1000)

1387

return dbus.UInt64(self.extended_timeout_milliseconds())

1587

1388

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

1588

1389

1589

1390

# Interval - property

1591

1392

access="readwrite")

1592

1393

def Interval_dbus_property(self, value=None):

1593

1394

if value is None: # get

1594

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

1395

return dbus.UInt64(self.interval_milliseconds())

1595

1396

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

1596

1397

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

1597

1398

return

1608

1409

def Checker_dbus_property(self, value=None):

1609

1410

if value is None: # get

1610

1411

return dbus.String(self.checker_command)

1611

self.checker_command = str(value)

1412

self.checker_command = unicode(value)

1612

1413

1613

1414

# CheckerRunning - property

1614

1415

@dbus_service_property(_interface, signature="b",

1630

1431

@dbus_service_property(_interface, signature="ay",

1631

1432

access="write", byte_arrays=True)

1632

1433

def Secret_dbus_property(self, value):

1633

self.secret = bytes(value)

1434

self.secret = str(value)

1634

1435

1635

1436

del _interface

1636

1437

1661

1462

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

1662

1463

1663

1464

1465

class ClientDBusTransitional(ClientDBus):

1466

__metaclass__ = AlternateDBusNamesMetaclass

1467

1468

1664

1469

class ClientHandler(socketserver.BaseRequestHandler, object):

1665

1470

"""A class to handle client connections.

1666

1471

1670

1475

def handle(self):

1671

1476

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

1672

1477

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

1673

str(self.client_address))

1478

unicode(self.client_address))

1674

1479

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

1675

1480

self.server.child_pipe.fileno())

1676

1481

1702

1507

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

1703

1508

try:

1704

1509

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

1705

raise RuntimeError(line)

1510

raise RuntimeError

1706

1511

except (ValueError, IndexError, RuntimeError) as error:

1707

1512

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

1708

1513

return

1734

1539

except KeyError:

1735

1540

return

1736

1541

1542

if self.server.use_dbus:

1543

# Emit D-Bus signal

1544

client.NewRequest(str(self.client_address))

1545

1737

1546

if client.approval_delay:

1738

1547

delay = client.approval_delay

1739

1548

client.approvals_pending += 1

1757

1566

if self.server.use_dbus:

1758

1567

# Emit D-Bus signal

1759

1568

client.NeedApproval(

1760

client.approval_delay.total_seconds()

1761

* 1000, client.approved_by_default)

1569

client.approval_delay_milliseconds(),

1570

client.approved_by_default)

1762

1571

else:

1763

1572

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

1764

1573

client.name)

1770

1579

#wait until timeout or approved

1771

1580

time = datetime.datetime.now()

1772

1581

client.changedstate.acquire()

1773

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

1582

(client.changedstate.wait

1583

(float(client.timedelta_to_milliseconds(delay)

1584

/ 1000)))

1774

1585

client.changedstate.release()

1775

1586

time2 = datetime.datetime.now()

1776

1587

if (time2 - time) >= delay:

1792

1603

try:

1793

1604

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

1794

1605

except gnutls.errors.GNUTLSError as error:

1795

logger.warning("gnutls send failed",

1796

exc_info=error)

1606

logger.warning("gnutls send failed")

1797

1607

return

1798

1608

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

1799

1609

sent, len(client.secret)

1802

1612

1803

1613

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

1804

1614

# bump the timeout using extended_timeout

1805

client.bump_timeout(client.extended_timeout)

1615

client.checked_ok(client.extended_timeout)

1806

1616

if self.server.use_dbus:

1807

1617

# Emit D-Bus signal

1808

1618

client.GotSecret()

1813

1623

try:

1814

1624

session.bye()

1815

1625

except gnutls.errors.GNUTLSError as error:

1816

logger.warning("GnuTLS bye failed",

1817

exc_info=error)

1626

logger.warning("GnuTLS bye failed")

1818

1627

1819

1628

@staticmethod

1820

1629

def peer_certificate(session):

1892

1701

def process_request(self, request, address):

1893

1702

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

1894

1703

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

1895

args = (request, address))

1704

args = (request,

1705

address))

1896

1706

proc.start()

1897

1707

return proc

1898

1708

1913

1723

1914

1724

def add_pipe(self, parent_pipe, proc):

1915

1725

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

1916

raise NotImplementedError()

1726

raise NotImplementedError

1917

1727

1918

1728

1919

1729

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1926

1736

use_ipv6: Boolean; to use IPv6 or not

1927

1737

"""

1928

1738

def __init__(self, server_address, RequestHandlerClass,

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

"""

1739

interface=None, use_ipv6=True):

1933

1740

self.interface = interface

1934

1741

if use_ipv6:

1935

1742

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.

1962

1743

socketserver.TCPServer.__init__(self, server_address,

1963

1744

RequestHandlerClass)

1964

1965

1745

def server_bind(self):

1966

1746

"""This overrides the normal server_bind() function

1967

1747

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

1975

1755

try:

1976

1756

self.socket.setsockopt(socket.SOL_SOCKET,

1977

1757

SO_BINDTODEVICE,

1978

(self.interface + "\0")

1979

.encode("utf-8"))

1758

str(self.interface

1759

+ '\0'))

1980

1760

except socket.error as error:

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:

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:

1985

1766

logger.error("SO_BINDTODEVICE not available;"

1986

1767

" cannot bind to interface %s",

1987

1768

self.interface)

1988

elif error.errno == errno.ENODEV:

1989

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

1990

" cannot bind", self.interface)

1991

1769

else:

1992

1770

raise

1993

1771

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

1996

1774

if self.address_family == socket.AF_INET6:

1997

1775

any_address = "::" # in6addr_any

1998

1776

else:

1999

any_address = "0.0.0.0" # INADDR_ANY

1777

any_address = socket.INADDR_ANY

2000

1778

self.server_address = (any_address,

2001

1779

self.server_address[1])

2002

1780

elif not self.server_address[1]:

2023

1801

"""

2024

1802

def __init__(self, server_address, RequestHandlerClass,

2025

1803

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

2026

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

1804

gnutls_priority=None, use_dbus=True):

2027

1805

self.enabled = False

2028

1806

self.clients = clients

2029

1807

if self.clients is None:

2033

1811

IPv6_TCPServer.__init__(self, server_address,

2034

1812

RequestHandlerClass,

2035

1813

interface = interface,

2036

use_ipv6 = use_ipv6,

2037

socketfd = socketfd)

1814

use_ipv6 = use_ipv6)

2038

1815

def server_activate(self):

2039

1816

if self.enabled:

2040

1817

return socketserver.TCPServer.server_activate(self)

2053

1830

2054

1831

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

2055

1832

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)

2056

1847

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

2057

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

1848

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

2058

1849

# Wait for other process to exit

2059

1850

proc.join()

2060

1851

return False

2118

1909

return True

2119

1910

2120

1911

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

2220

1912

def string_to_delta(interval):

2221

1913

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

2222

1914

2233

1925

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

2234

1926

datetime.timedelta(0, 330)

2235

1927

"""

2236

2237

try:

2238

return rfc3339_duration_to_delta(interval)

2239

except ValueError:

2240

pass

2241

2242

1928

timevalue = datetime.timedelta(0)

2243

1929

for s in interval.split():

2244

1930

try:

2245

suffix = s[-1]

1931

suffix = unicode(s[-1])

2246

1932

value = int(s[:-1])

2247

1933

if suffix == "d":

2248

1934

delta = datetime.timedelta(value)

2255

1941

elif suffix == "w":

2256

1942

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

2257

1943

else:

2258

raise ValueError("Unknown suffix {!r}"

2259

.format(suffix))

2260

except IndexError as e:

1944

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

1945

except (ValueError, IndexError) as e:

2261

1946

raise ValueError(*(e.args))

2262

1947

timevalue += delta

2263

1948

return timevalue

2276

1961

sys.exit()

2277

1962

if not noclose:

2278

1963

# Close all standard open file descriptors

2279

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

1964

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

2280

1965

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

2281

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

2282

.format(os.devnull))

1966

raise OSError(errno.ENODEV,

1967

"%s not a character device"

1968

% os.path.devnull)

2283

1969

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

2284

1970

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

2285

1971

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

2294

1980

2295

1981

parser = argparse.ArgumentParser()

2296

1982

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

2297

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

1983

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

2298

1984

help="show version number and exit")

2299

1985

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

2300

1986

help="Bind to interface IF")

2306

1992

help="Run self-test")

2307

1993

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

2308

1994

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

2309

" to terminal", default=None)

1995

" to terminal")

2310

1996

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

2311

1997

help="Debug level for stdout output")

2312

1998

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

2319

2005

" files")

2320

2006

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

2321

2007

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

2322

" system bus interface", default=None)

2008

" system bus interface")

2323

2009

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

2324

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

2325

default=None)

2010

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

2326

2011

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

2327

2012

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

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

2013

" state")

2332

2014

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

2333

2015

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)

2339

2016

2340

2017

options = parser.parse_args()

2341

2018

2342

2019

if options.check:

2343

2020

import doctest

2344

fail_count, test_count = doctest.testmod()

2345

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

2021

doctest.testmod()

2022

sys.exit()

2346

2023

2347

2024

# Default values for config file for server-global settings

2348

2025

server_defaults = { "interface": "",

2350

2027

"port": "",

2351

2028

"debug": "False",

2352

2029

"priority":

2353

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

2030

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

2354

2031

"servicename": "Mandos",

2355

2032

"use_dbus": "True",

2356

2033

"use_ipv6": "True",

2357

2034

"debuglevel": "",

2358

2035

"restore": "True",

2359

"socket": "",

2360

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

2361

"foreground": "False",

2362

"zeroconf": "True",

2036

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

2363

2037

}

2364

2038

2365

2039

# Parse config file for server-global settings

2370

2044

# Convert the SafeConfigParser object to a dict

2371

2045

server_settings = server_config.defaults()

2372

2046

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

2373

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

2047

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

2374

2048

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

2375

2049

option)

2376

2050

if server_settings["port"]:

2377

2051

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

2378

2052

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

2388

2053

del server_config

2389

2054

2390

2055

# Override the settings from the config file with command line

2392

2057

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

2393

2058

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

2394

2059

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

2395

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

2060

"statedir"):

2396

2061

value = getattr(options, option)

2397

2062

if value is not None:

2398

2063

server_settings[option] = value

2399

2064

del options

2400

2065

# Force all strings to be unicode

2401

2066

for option in server_settings.keys():

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

2067

if type(server_settings[option]) is str:

2068

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

2412

2069

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

2413

2070

2414

2071

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

2415

2072

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

2422

2073

# For convenience

2423

2074

debug = server_settings["debug"]

2424

2075

debuglevel = server_settings["debuglevel"]

2426

2077

use_ipv6 = server_settings["use_ipv6"]

2427

2078

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

2428

2079

stored_state_file)

2429

foreground = server_settings["foreground"]

2430

zeroconf = server_settings["zeroconf"]

2431

2080

2432

2081

if debug:

2433

2082

initlogger(debug, logging.DEBUG)

2440

2089

2441

2090

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

2442

2091

syslogger.setFormatter(logging.Formatter

2443

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

2444

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

2445

.format(server_settings

2446

["servicename"])))

2092

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

2093

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

2094

% server_settings["servicename"]))

2447

2095

2448

2096

# Parse config file with clients

2449

client_config = configparser.SafeConfigParser(Client

2450

.client_defaults)

2097

client_config = configparser.SafeConfigParser(Client.client_defaults)

2451

2098

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

2452

2099

"clients.conf"))

2453

2100

2454

2101

global mandos_dbus_service

2455

2102

mandos_dbus_service = None

2456

2103

2457

socketfd = None

2458

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

2459

socketfd = server_settings["socket"]

2460

2104

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

2461

2105

server_settings["port"]),

2462

2106

ClientHandler,

2465

2109

use_ipv6=use_ipv6,

2466

2110

gnutls_priority=

2467

2111

server_settings["priority"],

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

2112

use_dbus=use_dbus)

2113

if not debug:

2114

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

2475

2115

try:

2476

2116

pidfile = open(pidfilename, "w")

2477

except IOError as e:

2478

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

2479

exc_info=e)

2117

except IOError:

2118

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

2480

2119

2481

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

2120

try:

2121

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

2122

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

2123

except KeyError:

2482

2124

try:

2483

uid = pwd.getpwnam(name).pw_uid

2484

gid = pwd.getpwnam(name).pw_gid

2485

break

2125

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

2126

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

2486

2127

except KeyError:

2487

continue

2488

else:

2489

uid = 65534

2490

gid = 65534

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

2491

2134

try:

2492

2135

os.setgid(gid)

2493

2136

os.setuid(uid)

2494

2137

except OSError as error:

2495

if error.errno != errno.EPERM:

2496

raise

2138

if error[0] != errno.EPERM:

2139

raise error

2497

2140

2498

2141

if debug:

2499

2142

# Enable all possible GnuTLS debugging

2510

2153

.gnutls_global_set_log_function(debug_gnutls))

2511

2154

2512

2155

# Redirect stdin so all checkers get /dev/null

2513

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

2156

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

2514

2157

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

2515

2158

if null > 2:

2516

2159

os.close(null)

2517

2160

2518

2161

# Need to fork before connecting to D-Bus

2519

if not foreground:

2162

if not debug:

2520

2163

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

2521

2164

daemon()

2522

2165

2523

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

2524

# need to inform gobject that threads will be used.

2525

2166

gobject.threads_init()

2526

2167

2527

2168

global main_loop

2528

2169

# From the Avahi example code

2529

DBusGMainLoop(set_as_default=True)

2170

DBusGMainLoop(set_as_default=True )

2530

2171

main_loop = gobject.MainLoop()

2531

2172

bus = dbus.SystemBus()

2532

2173

# End of Avahi example code

2538

2179

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

2539

2180

do_not_queue=True))

2540

2181

except dbus.exceptions.NameExistsException as e:

2541

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

2182

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

2542

2183

use_dbus = False

2543

2184

server_settings["use_dbus"] = False

2544

2185

tcp_server.use_dbus = False

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

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

2555

2194

2556

2195

global multiprocessing_manager

2557

2196

multiprocessing_manager = multiprocessing.Manager()

2558

2197

2559

2198

client_class = Client

2560

2199

if use_dbus:

2561

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

2200

client_class = functools.partial(ClientDBusTransitional,

2201

bus = bus)

2562

2202

2563

2203

client_settings = Client.config_parser(client_config)

2564

2204

old_client_settings = {}

2565

2205

clients_data = {}

2566

2206

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

2575

2207

# Get client data and settings from last running state.

2576

2208

if server_settings["restore"]:

2577

2209

try:

2580

2212

(stored_state))

2581

2213

os.remove(stored_state_path)

2582

2214

except IOError as e:

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)

2215

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

2216

.format(e))

2217

if e.errno != errno.ENOENT:

2589

2218

raise

2590

2219

except EOFError as e:

2591

2220

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

2592

"EOFError:", exc_info=e)

2221

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

2593

2222

2594

2223

with PGPEngine() as pgp:

2595

for client_name, client in clients_data.items():

2596

# Skip removed clients

2597

if client_name not in client_settings:

2598

continue

2599

2224

for client_name, client in clients_data.iteritems():

2600

2225

# Decide which value to use after restoring saved state.

2601

2226

# We have three different values: Old config file,

2602

2227

# new config file, and saved state.

2616

2241

2617

2242

# Clients who has passed its expire date can still be

2618

2243

# enabled if its last checker was successful. Clients

2619

# whose checker succeeded before we stored its state is

2620

# assumed to have successfully run all checkers during

2621

# downtime.

2244

# whose checker failed before we stored its state is

2245

# assumed to have failed all checkers during downtime.

2622

2246

if client["enabled"]:

2623

2247

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

2624

2248

if not client["last_checked_ok"]:

2625

2249

logger.warning(

2626

"disabling client {} - Client never "

2627

"performed a successful checker"

2628

.format(client_name))

2250

"disabling client {0} - Client never "

2251

"performed a successfull checker"

2252

.format(client["name"]))

2629

2253

client["enabled"] = False

2630

2254

elif client["last_checker_status"] != 0:

2631

2255

logger.warning(

2632

"disabling client {} - Client last"

2633

" checker failed with error code {}"

2634

.format(client_name,

2256

"disabling client {0} - Client "

2257

"last checker failed with error code {1}"

2258

.format(client["name"],

2635

2259

client["last_checker_status"]))

2636

2260

client["enabled"] = False

2637

2261

else:

2638

2262

client["expires"] = (datetime.datetime

2639

2263

.utcnow()

2640

2264

+ client["timeout"])

2641

logger.debug("Last checker succeeded,"

2642

" keeping {} enabled"

2643

.format(client_name))

2265

2644

2266

try:

2645

2267

client["secret"] = (

2646

2268

pgp.decrypt(client["encrypted_secret"],

2648

2270

["secret"]))

2649

2271

except PGPError:

2650

2272

# If decryption fails, we use secret from new settings

2651

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

2273

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

2652

2274

.format(client_name))

2653

2275

client["secret"] = (

2654

2276

client_settings[client_name]["secret"])

2277

2655

2278

2656

2279

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

2657

for client_name in (set(old_client_settings)

2658

- set(client_settings)):

2280

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

2659

2281

del clients_data[client_name]

2660

for client_name in (set(client_settings)

2661

- set(old_client_settings)):

2282

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

2662

2283

clients_data[client_name] = client_settings[client_name]

2663

2664

# Create all client objects

2665

for client_name, client in clients_data.items():

2284

2285

# Create clients all clients

2286

for client_name, client in clients_data.iteritems():

2666

2287

tcp_server.clients[client_name] = client_class(

2667

name = client_name, settings = client,

2668

server_settings = server_settings)

2288

name = client_name, settings = client)

2669

2289

2670

2290

if not tcp_server.clients:

2671

2291

logger.warning("No clients defined")

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

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

2683

2305

del pidfilename

2306

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

2684

2307

2685

2308

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

2686

2309

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

2687

2310

2688

2311

if use_dbus:

2689

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

2690

"se.bsnet.fukt.Mandos"})

2691

class MandosDBusService(DBusObjectWithProperties):

2312

class MandosDBusService(dbus.service.Object):

2692

2313

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

2693

2314

def __init__(self):

2694

2315

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

2695

2316

_interface = "se.recompile.Mandos"

2696

2317

2697

@dbus_interface_annotations(_interface)

2698

def _foo(self):

2699

return { "org.freedesktop.DBus.Property"

2700

".EmitsChangedSignal":

2701

"false"}

2702

2703

2318

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

2704

2319

def ClientAdded(self, objpath):

2705

2320

"D-Bus signal"

2727

2342

def GetAllClientsWithProperties(self):

2728

2343

"D-Bus method"

2729

2344

return dbus.Dictionary(

2730

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

2731

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

2345

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

2346

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

2732

2347

signature="oa{sv}")

2733

2348

2734

2349

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

2747

2362

2748

2363

del _interface

2749

2364

2750

mandos_dbus_service = MandosDBusService()

2365

class MandosDBusServiceTransitional(MandosDBusService):

2366

__metaclass__ = AlternateDBusNamesMetaclass

2367

mandos_dbus_service = MandosDBusServiceTransitional()

2751

2368

2752

2369

def cleanup():

2753

2370

"Cleanup function; run on exit"

2754

if zeroconf:

2755

service.cleanup()

2371

service.cleanup()

2756

2372

2757

2373

multiprocessing.active_children()

2758

wnull.close()

2759

2374

if not (tcp_server.clients or client_settings):

2760

2375

return

2761

2376

2772

2387

2773

2388

# A list of attributes that can not be pickled

2774

2389

# + secret.

2775

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

2776

"checker", "server_settings" }

2390

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

2391

"checker"))

2777

2392

for name, typ in (inspect.getmembers

2778

2393

(dbus.service.Object)):

2779

2394

exclude.add(name)

2788

2403

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

2789

2404

2790

2405

try:

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:

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:

2795

2411

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

2796

tempname=stored_state.name

2797

2412

os.rename(tempname, stored_state_path)

2798

2413

except (IOError, OSError) as e:

2414

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

2415

.format(e))

2799

2416

if not debug:

2800

2417

try:

2801

2418

os.remove(tempname)

2802

2419

except NameError:

2803

2420

pass

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

2421

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

2422

errno.EEXIST)):

2423

raise e

2811

2424

2812

2425

# Delete all clients, and settings from config

2813

2426

while tcp_server.clients:

2837

2450

tcp_server.server_activate()

2838

2451

2839

2452

# Find out what port we got

2840

if zeroconf:

2841

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

2453

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

2842

2454

if use_ipv6:

2843

2455

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

2844

" flowinfo %d, scope_id %d",

2845

*tcp_server.socket.getsockname())

2456

" flowinfo %d, scope_id %d"

2457

% tcp_server.socket.getsockname())

2846

2458

else: # IPv4

2847

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

2848

*tcp_server.socket.getsockname())

2459

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

2460

% tcp_server.socket.getsockname())

2849

2461

2850

2462

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

2851

2463

2852

2464

try:

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

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

2862

2473

2863

2474

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

2864

2475

lambda *args, **kwargs:

2868

2479

logger.debug("Starting main loop")

2869

2480

main_loop.run()

2870

2481

except AvahiError as error:

2871

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

2482

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

2872

2483

cleanup()

2873

2484

sys.exit(1)

2874

2485

except KeyboardInterrupt: