/mandos/release : revision 237.7.87

1

#!/usr/bin/python2.7

1

#!/usr/bin/python

2

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

3

#

4

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

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

67

65

import types

68

66

import binascii

69

67

import tempfile

70

import itertools

71

import collections

72

68

73

69

import dbus

74

70

import dbus.service

79

75

import ctypes.util

80

76

import xml.dom.minidom

81

77

import inspect

78

import GnuPGInterface

82

79

83

80

try:

84

81

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

88

85

except ImportError:

89

86

SO_BINDTODEVICE = None

90

87

91

if sys.version_info.major == 2:

92

str = unicode

93

94

version = "1.6.9"

88

version = "1.4.1"

95

89

stored_state_file = "clients.pickle"

96

90

97

91

logger = logging.getLogger()

98

syslogger = None

92

syslogger = (logging.handlers.SysLogHandler

93

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

94

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

99

95

100

96

try:

101

97

if_nametoindex = (ctypes.cdll.LoadLibrary

107

103

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

108

104

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

109

105

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

110

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

111

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

106

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

107

interface))

108

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

109

ifreq[16:20])[0]

112

110

return interface_index

113

111

114

112

115

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

def rename(self, remove=True):

263

def rename(self):

279

264

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

280

265

if self.rename_count >= self.max_renames:

281

266

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

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

287

self.rename_count += 1

270

self.name = unicode(self.server

271

.GetAlternativeServiceName(self.name))

288

272

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

289

273

self.name)

290

if remove:

291

self.remove()

274

self.remove()

292

275

try:

293

276

self.add()

294

277

except dbus.exceptions.DBusException as error:

295

if (error.get_dbus_name()

296

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

297

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

298

return self.rename(remove=False)

299

else:

300

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

301

self.cleanup()

302

os._exit(1)

303

278

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

279

self.cleanup()

280

os._exit(1)

281

self.rename_count += 1

304

282

def remove(self):

305

283

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

306

284

if self.entry_group_state_changed_match is not None:

308

286

self.entry_group_state_changed_match = None

309

287

if self.group is not None:

310

288

self.group.Reset()

311

312

289

def add(self):

313

290

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

314

291

self.remove()

331

308

dbus.UInt16(self.port),

332

309

avahi.string_array_to_txt_array(self.TXT))

333

310

self.group.Commit()

334

335

311

def entry_group_state_changed(self, state, error):

336

312

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

337

313

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

343

319

self.rename()

344

320

elif state == avahi.ENTRY_GROUP_FAILURE:

345

321

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

346

str(error))

347

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

348

.format(error))

349

322

unicode(error))

323

raise AvahiGroupError("State changed: %s"

324

% unicode(error))

350

325

def cleanup(self):

351

326

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

352

327

if self.group is not None:

357

332

pass

358

333

self.group = None

359

334

self.remove()

360

361

335

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

362

336

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

363

337

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

382

356

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

383

357

else:

384

358

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

385

386

359

def activate(self):

387

360

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

388

361

if self.server is None:

395

368

self.server_state_changed)

396

369

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

397

370

398

399

371

class AvahiServiceToSyslog(AvahiService):

400

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

372

def rename(self):

401

373

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

402

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

374

ret = AvahiService.rename(self)

403

375

syslogger.setFormatter(logging.Formatter

404

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

405

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

406

.format(self.name)))

376

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

377

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

378

% self.name))

407

379

return ret

408

380

409

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

410

387

class Client(object):

411

388

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

412

389

437

414

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

438

415

last_checker_status: integer between 0 and 255 reflecting exit

439

416

status of last checker. -1 reflects crashed

440

checker, -2 means no checker completed yet.

417

checker, or None.

441

418

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

442

419

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

443

420

D-Bus identifiers

444

421

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

445

422

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

446

423

until this client is disabled

447

extended_timeout: extra long timeout when secret has been sent

424

extended_timeout: extra long timeout when password has been sent

448

425

runtime_expansions: Allowed attributes for runtime expansion.

449

426

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

450

427

disabled, or None

451

server_settings: The server_settings dict from main()

452

428

"""

453

429

454

430

runtime_expansions = ("approval_delay", "approval_duration",

455

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

456

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

457

"last_approval_request", "last_checked_ok",

431

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

432

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

458

433

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

459

client_defaults = { "timeout": "PT5M",

460

"extended_timeout": "PT15M",

461

"interval": "PT2M",

434

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

435

"extended_timeout": "15m",

436

"interval": "2m",

462

437

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

463

438

"host": "",

464

"approval_delay": "PT0S",

465

"approval_duration": "PT1S",

439

"approval_delay": "0s",

440

"approval_duration": "1s",

466

441

"approved_by_default": "True",

467

442

"enabled": "True",

468

443

}

469

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

470

460

@staticmethod

471

461

def config_parser(config):

472

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

462

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

473

463

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

474

with exceptions for any special settings as defined above.

475

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

476

value given the same arguments.

477

"""

464

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

478

465

settings = {}

479

466

for client_name in config.sections():

480

467

section = dict(config.items(client_name))

484

471

# Reformat values from string types to Python types

485

472

client["approved_by_default"] = config.getboolean(

486

473

client_name, "approved_by_default")

487

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

488

"enabled")

474

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

489

475

490

476

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

491

477

.replace(" ", ""))

497

483

"rb") as secfile:

498

484

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

499

485

else:

500

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

501

.format(section))

486

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

487

% section)

502

488

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

503

489

client["extended_timeout"] = string_to_delta(

504

490

section["extended_timeout"])

510

496

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

511

497

client["last_approval_request"] = None

512

498

client["last_checked_ok"] = None

513

client["last_checker_status"] = -2

514

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

515

508

return settings

516

517

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

518

515

self.name = name

519

if server_settings is None:

520

server_settings = {}

521

self.server_settings = server_settings

522

516

# adding all client settings

523

for setting, value in settings.items():

517

for setting, value in settings.iteritems():

524

518

setattr(self, setting, value)

525

519

526

if self.enabled:

527

if not hasattr(self, "last_enabled"):

528

self.last_enabled = datetime.datetime.utcnow()

529

if not hasattr(self, "expires"):

530

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

531

+ self.timeout)

532

else:

533

self.last_enabled = None

534

self.expires = None

535

536

520

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

537

521

# Uppercase and remove spaces from fingerprint for later

538

522

# comparison purposes with return value from the fingerprint()

539

523

# function

540

524

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

541

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

542

datetime.datetime.utcnow())

543

525

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

526

544

527

# attributes specific for this server instance

545

528

self.checker = None

546

529

self.checker_initiator_tag = None

574

557

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

575

558

# Already enabled

576

559

return

560

self.send_changedstate()

577

561

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

578

562

self.enabled = True

579

563

self.last_enabled = datetime.datetime.utcnow()

580

564

self.init_checker()

581

self.send_changedstate()

582

565

583

566

def disable(self, quiet=True):

584

567

"""Disable this client."""

585

568

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

586

569

return False

587

570

if not quiet:

571

self.send_changedstate()

572

if not quiet:

588

573

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

589

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

574

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

590

575

gobject.source_remove(self.disable_initiator_tag)

591

576

self.disable_initiator_tag = None

592

577

self.expires = None

593

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

578

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

594

579

gobject.source_remove(self.checker_initiator_tag)

595

580

self.checker_initiator_tag = None

596

581

self.stop_checker()

597

582

self.enabled = False

598

if not quiet:

599

self.send_changedstate()

600

583

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

601

584

return False

602

585

606

589

def init_checker(self):

607

590

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

608

591

# and every interval from then on.

609

if self.checker_initiator_tag is not None:

610

gobject.source_remove(self.checker_initiator_tag)

611

592

self.checker_initiator_tag = (gobject.timeout_add

612

(int(self.interval

613

.total_seconds() * 1000),

593

(self.interval_milliseconds(),

614

594

self.start_checker))

615

595

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

616

if self.disable_initiator_tag is not None:

617

gobject.source_remove(self.disable_initiator_tag)

618

596

self.disable_initiator_tag = (gobject.timeout_add

619

(int(self.timeout

620

.total_seconds() * 1000),

621

self.disable))

597

(self.timeout_milliseconds(),

598

self.disable))

622

599

# Also start a new checker *right now*.

623

600

self.start_checker()

624

601

640

617

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

641

618

vars(self))

642

619

643

def checked_ok(self):

644

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

645

self.last_checked_ok = datetime.datetime.utcnow()

646

self.last_checker_status = 0

647

self.bump_timeout()

648

649

def bump_timeout(self, timeout=None):

650

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

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

"""

651

626

if timeout is None:

652

627

timeout = self.timeout

628

self.last_checked_ok = datetime.datetime.utcnow()

653

629

if self.disable_initiator_tag is not None:

654

630

gobject.source_remove(self.disable_initiator_tag)

655

self.disable_initiator_tag = None

656

631

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

657

632

self.disable_initiator_tag = (gobject.timeout_add

658

(int(timeout.total_seconds()

659

* 1000), self.disable))

633

(timedelta_to_milliseconds

634

(timeout), self.disable))

660

635

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

661

636

662

637

def need_approval(self):

668

643

If a checker already exists, leave it running and do

669

644

nothing."""

670

645

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

671

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

672

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

673

# would inevitably timeout, since no checker would get a

674

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

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

675

650

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

676

651

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

677

652

# should be.

679

654

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

680

655

try:

681

656

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

682

except AttributeError:

683

pass

684

except OSError as error:

685

if error.errno != errno.ECHILD:

686

raise

657

except (AttributeError, OSError) as error:

658

if (isinstance(error, OSError)

659

and error.errno != errno.ECHILD):

660

raise error

687

661

else:

688

662

if pid:

689

663

logger.warning("Checker was a zombie")

692

666

self.current_checker_command)

693

667

# Start a new checker if needed

694

668

if self.checker is None:

695

# Escape attributes for the shell

696

escaped_attrs = { attr:

697

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

698

for attr in self.runtime_expansions }

699

669

try:

700

command = self.checker_command % escaped_attrs

701

except TypeError as error:

702

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

703

self.checker_command, exc_info=error)

704

return True # Try again later

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

705

688

self.current_checker_command = command

706

689

try:

707

690

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

710

693

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

711

694

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

712

695

# always replaced by /dev/null.)

713

# The exception is when not debugging but nevertheless

714

# running in the foreground; use the previously

715

# created wnull.

716

popen_args = {}

717

if (not self.server_settings["debug"]

718

and self.server_settings["foreground"]):

719

popen_args.update({"stdout": wnull,

720

"stderr": wnull })

721

696

self.checker = subprocess.Popen(command,

722

697

close_fds=True,

723

shell=True, cwd="/",

724

**popen_args)

725

except OSError as error:

726

logger.error("Failed to start subprocess",

727

exc_info=error)

728

return True

729

self.checker_callback_tag = (gobject.child_watch_add

730

(self.checker.pid,

731

self.checker_callback,

732

data=command))

733

# The checker may have completed before the gobject

734

# watch was added. Check for this.

735

try:

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.

736

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)

737

709

except OSError as error:

738

if error.errno == errno.ECHILD:

739

# This should never happen

740

logger.error("Child process vanished",

741

exc_info=error)

742

return True

743

raise

744

if pid:

745

gobject.source_remove(self.checker_callback_tag)

746

self.checker_callback(pid, status, command)

710

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

711

error)

747

712

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

748

713

return True

749

714

756

721

return

757

722

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

758

723

try:

759

self.checker.terminate()

724

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

760

725

#time.sleep(0.5)

761

726

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

762

# self.checker.kill()

727

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

763

728

except OSError as error:

764

729

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

765

730

raise

782

747

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

783

748

if byte_arrays and signature != "ay":

784

749

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

785

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

750

" signature %r" % signature)

786

751

def decorator(func):

787

752

func._dbus_is_property = True

788

753

func._dbus_interface = dbus_interface

796

761

return decorator

797

762

798

763

799

def dbus_interface_annotations(dbus_interface):

800

"""Decorator for marking functions returning interface annotations

801

802

Usage:

803

804

@dbus_interface_annotations("org.example.Interface")

805

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

806

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

807

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

808

"false"}

809

"""

810

def decorator(func):

811

func._dbus_is_interface = True

812

func._dbus_interface = dbus_interface

813

func._dbus_name = dbus_interface

814

return func

815

return decorator

816

817

818

def dbus_annotations(annotations):

819

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

820

Usage:

821

822

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

823

"org.freedesktop.DBus.Property."

824

"EmitsChangedSignal": "false"})

825

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

826

access="r")

827

def Property_dbus_property(self):

828

return dbus.Boolean(False)

829

"""

830

def decorator(func):

831

func._dbus_annotations = annotations

832

return func

833

return decorator

834

835

836

764

class DBusPropertyException(dbus.exceptions.DBusException):

837

765

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

838

766

"""

839

pass

767

def __unicode__(self):

768

return unicode(str(self))

769

840

770

841

771

class DBusPropertyAccessException(DBusPropertyException):

842

772

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

859

789

"""

860

790

861

791

@staticmethod

862

def _is_dbus_thing(thing):

863

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

864

865

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

866

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

867

"""

868

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

869

False)

792

def _is_dbus_property(obj):

793

return getattr(obj, "_dbus_is_property", False)

870

794

871

def _get_all_dbus_things(self, thing):

795

def _get_all_dbus_properties(self):

872

796

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

873

797

"""

874

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

875

name),

876

athing.__get__(self))

798

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

877

799

for cls in self.__class__.__mro__

878

for name, athing in

879

inspect.getmembers(cls,

880

self._is_dbus_thing(thing)))

800

for name, prop in

801

inspect.getmembers(cls, self._is_dbus_property))

881

802

882

803

def _get_dbus_property(self, interface_name, property_name):

883

804

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

885

806

"""

886

807

for cls in self.__class__.__mro__:

887

808

for name, value in (inspect.getmembers

888

(cls,

889

self._is_dbus_thing("property"))):

809

(cls, self._is_dbus_property)):

890

810

if (value._dbus_name == property_name

891

811

and value._dbus_interface == interface_name):

892

812

return value.__get__(self)

920

840

# The byte_arrays option is not supported yet on

921

841

# signatures other than "ay".

922

842

if prop._dbus_signature != "ay":

923

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

924

"'ay' signature {!r}"

925

.format(prop._dbus_signature))

926

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

927

for byte in value))

843

raise ValueError

844

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

845

for byte in value))

928

846

prop(value)

929

847

930

848

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

936

854

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

937

855

"""

938

856

properties = {}

939

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

857

for name, prop in self._get_all_dbus_properties():

940

858

if (interface_name

941

859

and interface_name != prop._dbus_interface):

942

860

# Interface non-empty but did not match

952

870

value.variant_level+1)

953

871

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

954

872

955

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

956

def PropertiesChanged(self, interface_name, changed_properties,

957

invalidated_properties):

958

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

959

standard.

960

"""

961

pass

962

963

873

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

964

874

out_signature="s",

965

875

path_keyword='object_path',

966

876

connection_keyword='connection')

967

877

def Introspect(self, object_path, connection):

968

"""Overloading of standard D-Bus method.

969

970

Inserts property tags and interface annotation tags.

878

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

971

879

"""

972

880

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

973

881

connection)

980

888

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

981

889

return e

982

890

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

983

# Add property tags

984

891

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

985

892

for name, prop

986

in self._get_all_dbus_things("property")

893

in self._get_all_dbus_properties()

987

894

if prop._dbus_interface

988

895

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

989

896

if_tag.appendChild(tag)

990

# Add annotation tags

991

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

992

for tag in if_tag.getElementsByTagName(typ):

993

annots = dict()

994

for name, prop in (self.

995

_get_all_dbus_things(typ)):

996

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

997

and prop._dbus_interface

998

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

999

annots.update(getattr

1000

(prop,

1001

"_dbus_annotations",

1002

{}))

1003

for name, value in annots.items():

1004

ann_tag = document.createElement(

1005

"annotation")

1006

ann_tag.setAttribute("name", name)

1007

ann_tag.setAttribute("value", value)

1008

tag.appendChild(ann_tag)

1009

# Add interface annotation tags

1010

for annotation, value in dict(

1011

itertools.chain.from_iterable(

1012

annotations().items()

1013

for name, annotations in

1014

self._get_all_dbus_things("interface")

1015

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

1016

)).items():

1017

ann_tag = document.createElement("annotation")

1018

ann_tag.setAttribute("name", annotation)

1019

ann_tag.setAttribute("value", value)

1020

if_tag.appendChild(ann_tag)

1021

897

# Add the names to the return values for the

1022

898

# "org.freedesktop.DBus.Properties" methods

1023

899

if (if_tag.getAttribute("name")

1038

914

except (AttributeError, xml.dom.DOMException,

1039

915

xml.parsers.expat.ExpatError) as error:

1040

916

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

1041

exc_info=error)

917

error)

1042

918

return xmlstring

1043

919

1044

920

1045

def datetime_to_dbus(dt, variant_level=0):

921

def datetime_to_dbus (dt, variant_level=0):

1046

922

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

1047

923

if dt is None:

1048

924

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

1050

926

variant_level=variant_level)

1051

927

1052

928

1053

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1054

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

1055

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

1056

interface names according to the "alt_interface_names" mapping.

1057

Usage:

1058

1059

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

1060

"net.example.AlternateInterface"})

1061

class SampleDBusObject(dbus.service.Object):

1062

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

1063

def SampleDBusMethod():

1064

pass

1065

1066

The above "SampleDBusMethod" on "SampleDBusObject" will be

1067

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

1068

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

1069

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

1070

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

1071

1072

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

1073

(from DBusObjectWithProperties) and interfaces (from the

1074

dbus_interface_annotations decorator).

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.

1075

933

"""

1076

def wrapper(cls):

1077

for orig_interface_name, alt_interface_name in (

1078

alt_interface_names.items()):

1079

attr = {}

1080

interface_names = set()

1081

# Go though all attributes of the class

1082

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

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

1083

941

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

1084

942

# with the wrong interface name

1085

943

if (not hasattr(attribute, "_dbus_interface")

1086

944

or not attribute._dbus_interface

1087

.startswith(orig_interface_name)):

945

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

1088

946

continue

1089

947

# Create an alternate D-Bus interface name based on

1090

948

# the current name

1091

949

alt_interface = (attribute._dbus_interface

1092

.replace(orig_interface_name,

1093

alt_interface_name))

1094

interface_names.add(alt_interface)

950

.replace("se.recompile.Mandos",

951

"se.bsnet.fukt.Mandos"))

1095

952

# Is this a D-Bus signal?

1096

953

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

1097

# Extract the original non-method undecorated

1098

# function by black magic

954

# Extract the original non-method function by

955

# black magic

1099

956

nonmethod_func = (dict(

1100

957

zip(attribute.func_code.co_freevars,

1101

958

attribute.__closure__))["func"]

1112

969

nonmethod_func.func_name,

1113

970

nonmethod_func.func_defaults,

1114

971

nonmethod_func.func_closure)))

1115

# Copy annotations, if any

1116

try:

1117

new_function._dbus_annotations = (

1118

dict(attribute._dbus_annotations))

1119

except AttributeError:

1120

pass

1121

972

# Define a creator of a function to call both the

1122

# original and alternate functions, so both the

1123

# original and alternate signals gets sent when

1124

# the function is called

973

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

974

# signals gets sent when the function is called

1125

975

def fixscope(func1, func2):

1126

976

"""This function is a scope container to pass

1127

977

func1 and func2 to the "call_both" function

1134

984

return call_both

1135

985

# Create the "call_both" function and add it to

1136

986

# the class

1137

attr[attrname] = fixscope(attribute, new_function)

987

attr[attrname] = fixscope(attribute,

988

new_function)

1138

989

# Is this a D-Bus method?

1139

990

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

1140

991

# Create a new, but exactly alike, function

1151

1002

attribute.func_name,

1152

1003

attribute.func_defaults,

1153

1004

attribute.func_closure)))

1154

# Copy annotations, if any

1155

try:

1156

attr[attrname]._dbus_annotations = (

1157

dict(attribute._dbus_annotations))

1158

except AttributeError:

1159

pass

1160

1005

# Is this a D-Bus property?

1161

1006

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

1162

1007

# Create a new, but exactly alike, function

1176

1021

attribute.func_name,

1177

1022

attribute.func_defaults,

1178

1023

attribute.func_closure)))

1179

# Copy annotations, if any

1180

try:

1181

attr[attrname]._dbus_annotations = (

1182

dict(attribute._dbus_annotations))

1183

except AttributeError:

1184

pass

1185

# Is this a D-Bus interface?

1186

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

1187

# Create a new, but exactly alike, function

1188

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

1189

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

1190

# to the class.

1191

attr[attrname] = (dbus_interface_annotations

1192

(alt_interface)

1193

(types.FunctionType

1194

(attribute.func_code,

1195

attribute.func_globals,

1196

attribute.func_name,

1197

attribute.func_defaults,

1198

attribute.func_closure)))

1199

if deprecate:

1200

# Deprecate all alternate interfaces

1201

iname="_AlternateDBusNames_interface_annotation{}"

1202

for interface_name in interface_names:

1203

@dbus_interface_annotations(interface_name)

1204

def func(self):

1205

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

1206

"true" }

1207

# Find an unused name

1208

for aname in (iname.format(i)

1209

for i in itertools.count()):

1210

if aname not in attr:

1211

attr[aname] = func

1212

break

1213

if interface_names:

1214

# Replace the class with a new subclass of it with

1215

# methods, signals, etc. as created above.

1216

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

1217

(cls,), attr)

1218

return cls

1219

return wrapper

1220

1221

1222

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

1223

"se.bsnet.fukt.Mandos"})

1024

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

1025

1026

1224

1027

class ClientDBus(Client, DBusObjectWithProperties):

1225

1028

"""A Client class using D-Bus

1226

1029

1232

1035

runtime_expansions = (Client.runtime_expansions

1233

1036

+ ("dbus_object_path",))

1234

1037

1235

_interface = "se.recompile.Mandos.Client"

1236

1237

1038

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

1238

1039

1239

1040

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

1240

1041

self.bus = bus

1241

1042

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

1043

self._approvals_pending = 0

1044

1045

self._approvals_pending = 0

1242

1046

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

1243

1047

# the D-Bus

1244

client_object_name = str(self.name).translate(

1048

client_object_name = unicode(self.name).translate(

1245

1049

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

1246

1050

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

1247

1051

self.dbus_object_path = (dbus.ObjectPath

1248

1052

("/clients/" + client_object_name))

1249

1053

DBusObjectWithProperties.__init__(self, self.bus,

1250

1054

self.dbus_object_path)

1251

1055

1252

1056

def notifychangeproperty(transform_func,

1253

1057

dbus_name, type_func=lambda x: x,

1254

variant_level=1, invalidate_only=False,

1255

_interface=_interface):

1058

variant_level=1):

1256

1059

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

1257

1060

its changes to DBus.

1258

1061

1263

1066

to the D-Bus. Default: no transform

1264

1067

variant_level: D-Bus variant level. Default: 1

1265

1068

"""

1266

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

1069

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

1267

1070

def setter(self, value):

1268

1071

if hasattr(self, "dbus_object_path"):

1269

1072

if (not hasattr(self, attrname) or

1270

1073

type_func(getattr(self, attrname, None))

1271

1074

!= type_func(value)):

1272

if invalidate_only:

1273

self.PropertiesChanged(_interface,

1274

dbus.Dictionary(),

1275

dbus.Array

1276

((dbus_name,)))

1277

else:

1278

dbus_value = transform_func(type_func(value),

1279

variant_level

1280

=variant_level)

1281

self.PropertyChanged(dbus.String(dbus_name),

1282

dbus_value)

1283

self.PropertiesChanged(_interface,

1284

dbus.Dictionary({

1285

dbus.String(dbus_name):

1286

dbus_value }), dbus.Array())

1075

dbus_value = transform_func(type_func(value),

1076

variant_level

1077

=variant_level)

1078

self.PropertyChanged(dbus.String(dbus_name),

1079

dbus_value)

1287

1080

setattr(self, attrname, value)

1288

1081

1289

1082

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

1290

1083

1084

1291

1085

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1292

1086

approvals_pending = notifychangeproperty(dbus.Boolean,

1293

1087

"ApprovalPending",

1300

1094

checker is not None)

1301

1095

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1302

1096

"LastCheckedOK")

1303

last_checker_status = notifychangeproperty(dbus.Int16,

1304

"LastCheckerStatus")

1305

1097

last_approval_request = notifychangeproperty(

1306

1098

datetime_to_dbus, "LastApprovalRequest")

1307

1099

approved_by_default = notifychangeproperty(dbus.Boolean,

1309

1101

approval_delay = notifychangeproperty(dbus.UInt64,

1310

1102

"ApprovalDelay",

1311

1103

type_func =

1312

lambda td: td.total_seconds()

1313

* 1000)

1104

timedelta_to_milliseconds)

1314

1105

approval_duration = notifychangeproperty(

1315

1106

dbus.UInt64, "ApprovalDuration",

1316

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

1107

type_func = timedelta_to_milliseconds)

1317

1108

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

1318

1109

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

1319

type_func = lambda td:

1320

td.total_seconds() * 1000)

1110

type_func =

1111

timedelta_to_milliseconds)

1321

1112

extended_timeout = notifychangeproperty(

1322

1113

dbus.UInt64, "ExtendedTimeout",

1323

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

1114

type_func = timedelta_to_milliseconds)

1324

1115

interval = notifychangeproperty(dbus.UInt64,

1325

1116

"Interval",

1326

1117

type_func =

1327

lambda td: td.total_seconds()

1328

* 1000)

1118

timedelta_to_milliseconds)

1329

1119

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

1330

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

1331

invalidate_only=True)

1332

1120

1333

1121

del notifychangeproperty

1334

1122

1361

1149

*args, **kwargs)

1362

1150

1363

1151

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

1364

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

1365

1157

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

1366

1158

# Only if new checker process was started

1367

1159

if (self.checker is not None

1375

1167

return False

1376

1168

1377

1169

def approve(self, value=True):

1170

self.send_changedstate()

1378

1171

self.approved = value

1379

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

1380

* 1000), self._reset_approved)

1381

self.send_changedstate()

1172

gobject.timeout_add(timedelta_to_milliseconds

1173

(self.approval_duration),

1174

self._reset_approved)

1175

1382

1176

1383

1177

## D-Bus methods, signals & properties

1384

1385

## Interfaces

1178

_interface = "se.recompile.Mandos.Client"

1386

1179

1387

1180

## Signals

1388

1181

1399

1192

pass

1400

1193

1401

1194

# PropertyChanged - signal

1402

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

1403

1195

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

1404

1196

def PropertyChanged(self, property, value):

1405

1197

"D-Bus signal"

1426

1218

"D-Bus signal"

1427

1219

return self.need_approval()

1428

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

1429

1229

## Methods

1430

1230

1431

1231

# Approve - method

1481

1281

access="readwrite")

1482

1282

def ApprovalDelay_dbus_property(self, value=None):

1483

1283

if value is None: # get

1484

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

1485

* 1000)

1284

return dbus.UInt64(self.approval_delay_milliseconds())

1486

1285

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

1487

1286

1488

1287

# ApprovalDuration - property

1490

1289

access="readwrite")

1491

1290

def ApprovalDuration_dbus_property(self, value=None):

1492

1291

if value is None: # get

1493

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

1494

* 1000)

1292

return dbus.UInt64(timedelta_to_milliseconds(

1293

self.approval_duration))

1495

1294

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

1496

1295

1497

1296

# Name - property

1510

1309

def Host_dbus_property(self, value=None):

1511

1310

if value is None: # get

1512

1311

return dbus.String(self.host)

1513

self.host = str(value)

1312

self.host = unicode(value)

1514

1313

1515

1314

# Created - property

1516

1315

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

1542

1341

return

1543

1342

return datetime_to_dbus(self.last_checked_ok)

1544

1343

1545

# LastCheckerStatus - property

1546

@dbus_service_property(_interface, signature="n",

1547

access="read")

1548

def LastCheckerStatus_dbus_property(self):

1549

return dbus.Int16(self.last_checker_status)

1550

1551

1344

# Expires - property

1552

1345

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

1553

1346

def Expires_dbus_property(self):

1563

1356

access="readwrite")

1564

1357

def Timeout_dbus_property(self, value=None):

1565

1358

if value is None: # get

1566

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

1567

old_timeout = self.timeout

1359

return dbus.UInt64(self.timeout_milliseconds())

1568

1360

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

1569

# Reschedule disabling

1570

if self.enabled:

1571

now = datetime.datetime.utcnow()

1572

self.expires += self.timeout - old_timeout

1573

if self.expires <= now:

1574

# The timeout has passed

1575

self.disable()

1576

else:

1577

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

1578

is None):

1579

return

1580

gobject.source_remove(self.disable_initiator_tag)

1581

self.disable_initiator_tag = (

1582

gobject.timeout_add(

1583

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

1584

* 1000), self.disable))

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

1585

1381

1586

1382

# ExtendedTimeout - property

1587

1383

@dbus_service_property(_interface, signature="t",

1588

1384

access="readwrite")

1589

1385

def ExtendedTimeout_dbus_property(self, value=None):

1590

1386

if value is None: # get

1591

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

1592

* 1000)

1387

return dbus.UInt64(self.extended_timeout_milliseconds())

1593

1388

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

1594

1389

1595

1390

# Interval - property

1597

1392

access="readwrite")

1598

1393

def Interval_dbus_property(self, value=None):

1599

1394

if value is None: # get

1600

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

1395

return dbus.UInt64(self.interval_milliseconds())

1601

1396

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

1602

1397

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

1603

1398

return

1614

1409

def Checker_dbus_property(self, value=None):

1615

1410

if value is None: # get

1616

1411

return dbus.String(self.checker_command)

1617

self.checker_command = str(value)

1412

self.checker_command = unicode(value)

1618

1413

1619

1414

# CheckerRunning - property

1620

1415

@dbus_service_property(_interface, signature="b",

1636

1431

@dbus_service_property(_interface, signature="ay",

1637

1432

access="write", byte_arrays=True)

1638

1433

def Secret_dbus_property(self, value):

1639

self.secret = bytes(value)

1434

self.secret = str(value)

1640

1435

1641

1436

del _interface

1642

1437

1667

1462

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

1668

1463

1669

1464

1465

class ClientDBusTransitional(ClientDBus):

1466

__metaclass__ = AlternateDBusNamesMetaclass

1467

1468

1670

1469

class ClientHandler(socketserver.BaseRequestHandler, object):

1671

1470

"""A class to handle client connections.

1672

1471

1676

1475

def handle(self):

1677

1476

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

1678

1477

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

1679

str(self.client_address))

1478

unicode(self.client_address))

1680

1479

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

1681

1480

self.server.child_pipe.fileno())

1682

1481

1708

1507

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

1709

1508

try:

1710

1509

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

1711

raise RuntimeError(line)

1510

raise RuntimeError

1712

1511

except (ValueError, IndexError, RuntimeError) as error:

1713

1512

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

1714

1513

return

1740

1539

except KeyError:

1741

1540

return

1742

1541

1542

if self.server.use_dbus:

1543

# Emit D-Bus signal

1544

client.NewRequest(str(self.client_address))

1545

1743

1546

if client.approval_delay:

1744

1547

delay = client.approval_delay

1745

1548

client.approvals_pending += 1

1763

1566

if self.server.use_dbus:

1764

1567

# Emit D-Bus signal

1765

1568

client.NeedApproval(

1766

client.approval_delay.total_seconds()

1767

* 1000, client.approved_by_default)

1569

client.approval_delay_milliseconds(),

1570

client.approved_by_default)

1768

1571

else:

1769

1572

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

1770

1573

client.name)

1776

1579

#wait until timeout or approved

1777

1580

time = datetime.datetime.now()

1778

1581

client.changedstate.acquire()

1779

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

1582

(client.changedstate.wait

1583

(float(client.timedelta_to_milliseconds(delay)

1584

/ 1000)))

1780

1585

client.changedstate.release()

1781

1586

time2 = datetime.datetime.now()

1782

1587

if (time2 - time) >= delay:

1798

1603

try:

1799

1604

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

1800

1605

except gnutls.errors.GNUTLSError as error:

1801

logger.warning("gnutls send failed",

1802

exc_info=error)

1606

logger.warning("gnutls send failed")

1803

1607

return

1804

1608

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

1805

1609

sent, len(client.secret)

1808

1612

1809

1613

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

1810

1614

# bump the timeout using extended_timeout

1811

client.bump_timeout(client.extended_timeout)

1615

client.checked_ok(client.extended_timeout)

1812

1616

if self.server.use_dbus:

1813

1617

# Emit D-Bus signal

1814

1618

client.GotSecret()

1819

1623

try:

1820

1624

session.bye()

1821

1625

except gnutls.errors.GNUTLSError as error:

1822

logger.warning("GnuTLS bye failed",

1823

exc_info=error)

1626

logger.warning("GnuTLS bye failed")

1824

1627

1825

1628

@staticmethod

1826

1629

def peer_certificate(session):

1898

1701

def process_request(self, request, address):

1899

1702

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

1900

1703

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

1901

args = (request, address))

1704

args = (request,

1705

address))

1902

1706

proc.start()

1903

1707

return proc

1904

1708

1919

1723

1920

1724

def add_pipe(self, parent_pipe, proc):

1921

1725

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

1922

raise NotImplementedError()

1726

raise NotImplementedError

1923

1727

1924

1728

1925

1729

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1932

1736

use_ipv6: Boolean; to use IPv6 or not

1933

1737

"""

1934

1738

def __init__(self, server_address, RequestHandlerClass,

1935

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

1936

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

1937

creating a new one with socket.socket().

1938

"""

1739

interface=None, use_ipv6=True):

1939

1740

self.interface = interface

1940

1741

if use_ipv6:

1941

1742

self.address_family = socket.AF_INET6

1942

if socketfd is not None:

1943

# Save the file descriptor

1944

self.socketfd = socketfd

1945

# Save the original socket.socket() function

1946

self.socket_socket = socket.socket

1947

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

1948

#

1949

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

1950

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

1951

# patching socket.socket.)

1952

#

1953

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

1954

@functools.wraps(socket.socket)

1955

def socket_wrapper(*args, **kwargs):

1956

# Restore original function so subsequent calls are

1957

# not affected.

1958

socket.socket = self.socket_socket

1959

del self.socket_socket

1960

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

1961

# saved file descriptor.

1962

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

1963

# Replace socket.socket() function with wrapper

1964

socket.socket = socket_wrapper

1965

# The socketserver.TCPServer.__init__ will call

1966

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

1967

# socket_wrapper(), if socketfd was set.

1968

1743

socketserver.TCPServer.__init__(self, server_address,

1969

1744

RequestHandlerClass)

1970

1971

1745

def server_bind(self):

1972

1746

"""This overrides the normal server_bind() function

1973

1747

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

1981

1755

try:

1982

1756

self.socket.setsockopt(socket.SOL_SOCKET,

1983

1757

SO_BINDTODEVICE,

1984

(self.interface + "\0")

1985

.encode("utf-8"))

1758

str(self.interface

1759

+ '\0'))

1986

1760

except socket.error as error:

1987

if error.errno == errno.EPERM:

1988

logger.error("No permission to bind to"

1989

" interface %s", self.interface)

1990

elif error.errno == errno.ENOPROTOOPT:

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:

1991

1766

logger.error("SO_BINDTODEVICE not available;"

1992

1767

" cannot bind to interface %s",

1993

1768

self.interface)

1994

elif error.errno == errno.ENODEV:

1995

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

1996

" cannot bind", self.interface)

1997

1769

else:

1998

1770

raise

1999

1771

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

2002

1774

if self.address_family == socket.AF_INET6:

2003

1775

any_address = "::" # in6addr_any

2004

1776

else:

2005

any_address = "0.0.0.0" # INADDR_ANY

1777

any_address = socket.INADDR_ANY

2006

1778

self.server_address = (any_address,

2007

1779

self.server_address[1])

2008

1780

elif not self.server_address[1]:

2029

1801

"""

2030

1802

def __init__(self, server_address, RequestHandlerClass,

2031

1803

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

2032

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

1804

gnutls_priority=None, use_dbus=True):

2033

1805

self.enabled = False

2034

1806

self.clients = clients

2035

1807

if self.clients is None:

2039

1811

IPv6_TCPServer.__init__(self, server_address,

2040

1812

RequestHandlerClass,

2041

1813

interface = interface,

2042

use_ipv6 = use_ipv6,

2043

socketfd = socketfd)

1814

use_ipv6 = use_ipv6)

2044

1815

def server_activate(self):

2045

1816

if self.enabled:

2046

1817

return socketserver.TCPServer.server_activate(self)

2059

1830

2060

1831

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

2061

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)

2062

1847

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

2063

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

1848

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

2064

1849

# Wait for other process to exit

2065

1850

proc.join()

2066

1851

return False

2124

1909

return True

2125

1910

2126

1911

2127

def rfc3339_duration_to_delta(duration):

2128

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

2129

2130

>>> rfc3339_duration_to_delta("P7D")

2131

datetime.timedelta(7)

2132

>>> rfc3339_duration_to_delta("PT60S")

2133

datetime.timedelta(0, 60)

2134

>>> rfc3339_duration_to_delta("PT60M")

2135

datetime.timedelta(0, 3600)

2136

>>> rfc3339_duration_to_delta("PT24H")

2137

datetime.timedelta(1)

2138

>>> rfc3339_duration_to_delta("P1W")

2139

datetime.timedelta(7)

2140

>>> rfc3339_duration_to_delta("PT5M30S")

2141

datetime.timedelta(0, 330)

2142

>>> rfc3339_duration_to_delta("P1DT3M20S")

2143

datetime.timedelta(1, 200)

2144

"""

2145

2146

# Parsing an RFC 3339 duration with regular expressions is not

2147

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

2148

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

2149

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

2150

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

2151

# avoid excessive use of external libraries.

2152

2153

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

2154

Token = collections.namedtuple("Token",

2155

("regexp", # To match token; if

2156

# "value" is not None,

2157

# must have a "group"

2158

# containing digits

2159

"value", # datetime.timedelta or

2160

# None

2161

"followers")) # Tokens valid after

2162

# this token

2163

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

2164

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

2165

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

2166

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

2167

datetime.timedelta(seconds=1),

2168

frozenset((token_end,)))

2169

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

2170

datetime.timedelta(minutes=1),

2171

frozenset((token_second, token_end)))

2172

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

2173

datetime.timedelta(hours=1),

2174

frozenset((token_minute, token_end)))

2175

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

2176

None,

2177

frozenset((token_hour, token_minute,

2178

token_second)))

2179

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

2180

datetime.timedelta(days=1),

2181

frozenset((token_time, token_end)))

2182

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

2183

datetime.timedelta(weeks=4),

2184

frozenset((token_day, token_end)))

2185

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

2186

datetime.timedelta(weeks=52),

2187

frozenset((token_month, token_end)))

2188

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

2189

datetime.timedelta(weeks=1),

2190

frozenset((token_end,)))

2191

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

2192

frozenset((token_year, token_month,

2193

token_day, token_time,

2194

token_week)))

2195

# Define starting values

2196

value = datetime.timedelta() # Value so far

2197

found_token = None

2198

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

2199

s = duration # String left to parse

2200

# Loop until end token is found

2201

while found_token is not token_end:

2202

# Search for any currently valid tokens

2203

for token in followers:

2204

match = token.regexp.match(s)

2205

if match is not None:

2206

# Token found

2207

if token.value is not None:

2208

# Value found, parse digits

2209

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

2210

# Add to value so far

2211

value += factor * token.value

2212

# Strip token from string

2213

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

2214

# Go to found token

2215

found_token = token

2216

# Set valid next tokens

2217

followers = found_token.followers

2218

break

2219

else:

2220

# No currently valid tokens were found

2221

raise ValueError("Invalid RFC 3339 duration")

2222

# End token found

2223

return value

2224

2225

2226

1912

def string_to_delta(interval):

2227

1913

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

2228

1914

2239

1925

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

2240

1926

datetime.timedelta(0, 330)

2241

1927

"""

2242

2243

try:

2244

return rfc3339_duration_to_delta(interval)

2245

except ValueError:

2246

pass

2247

2248

1928

timevalue = datetime.timedelta(0)

2249

1929

for s in interval.split():

2250

1930

try:

2251

suffix = s[-1]

1931

suffix = unicode(s[-1])

2252

1932

value = int(s[:-1])

2253

1933

if suffix == "d":

2254

1934

delta = datetime.timedelta(value)

2261

1941

elif suffix == "w":

2262

1942

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

2263

1943

else:

2264

raise ValueError("Unknown suffix {!r}"

2265

.format(suffix))

2266

except IndexError as e:

1944

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

1945

except (ValueError, IndexError) as e:

2267

1946

raise ValueError(*(e.args))

2268

1947

timevalue += delta

2269

1948

return timevalue

2282

1961

sys.exit()

2283

1962

if not noclose:

2284

1963

# Close all standard open file descriptors

2285

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

1964

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

2286

1965

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

2287

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

2288

.format(os.devnull))

1966

raise OSError(errno.ENODEV,

1967

"%s not a character device"

1968

% os.path.devnull)

2289

1969

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

2290

1970

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

2291

1971

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

2300

1980

2301

1981

parser = argparse.ArgumentParser()

2302

1982

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

2303

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

1983

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

2304

1984

help="show version number and exit")

2305

1985

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

2306

1986

help="Bind to interface IF")

2312

1992

help="Run self-test")

2313

1993

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

2314

1994

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

2315

" to terminal", default=None)

1995

" to terminal")

2316

1996

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

2317

1997

help="Debug level for stdout output")

2318

1998

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

2325

2005

" files")

2326

2006

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

2327

2007

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

2328

" system bus interface", default=None)

2008

" system bus interface")

2329

2009

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

2330

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

2331

default=None)

2010

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

2332

2011

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

2333

2012

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

2334

" state", default=None)

2335

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

2336

help="Specify a file descriptor to a network"

2337

" socket to use instead of creating one")

2013

" state")

2338

2014

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

2339

2015

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

2340

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

2341

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

2342

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

2343

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

2344

default=None)

2345

2016

2346

2017

options = parser.parse_args()

2347

2018

2348

2019

if options.check:

2349

2020

import doctest

2350

fail_count, test_count = doctest.testmod()

2351

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

2021

doctest.testmod()

2022

sys.exit()

2352

2023

2353

2024

# Default values for config file for server-global settings

2354

2025

server_defaults = { "interface": "",

2356

2027

"port": "",

2357

2028

"debug": "False",

2358

2029

"priority":

2359

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

2030

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

2360

2031

"servicename": "Mandos",

2361

2032

"use_dbus": "True",

2362

2033

"use_ipv6": "True",

2363

2034

"debuglevel": "",

2364

2035

"restore": "True",

2365

"socket": "",

2366

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

2367

"foreground": "False",

2368

"zeroconf": "True",

2036

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

2369

2037

}

2370

2038

2371

2039

# Parse config file for server-global settings

2376

2044

# Convert the SafeConfigParser object to a dict

2377

2045

server_settings = server_config.defaults()

2378

2046

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

2379

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

2047

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

2380

2048

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

2381

2049

option)

2382

2050

if server_settings["port"]:

2383

2051

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

2384

2052

"port")

2385

if server_settings["socket"]:

2386

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

2387

"socket")

2388

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

2389

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

2390

# happen with a supplied network socket.

2391

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

2392

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

2393

["socket"])

2394

2053

del server_config

2395

2054

2396

2055

# Override the settings from the config file with command line

2398

2057

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

2399

2058

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

2400

2059

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

2401

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

2060

"statedir"):

2402

2061

value = getattr(options, option)

2403

2062

if value is not None:

2404

2063

server_settings[option] = value

2405

2064

del options

2406

2065

# Force all strings to be unicode

2407

2066

for option in server_settings.keys():

2408

if isinstance(server_settings[option], bytes):

2409

server_settings[option] = (server_settings[option]

2410

.decode("utf-8"))

2411

# Force all boolean options to be boolean

2412

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

2413

"foreground", "zeroconf"):

2414

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

2415

# Debug implies foreground

2416

if server_settings["debug"]:

2417

server_settings["foreground"] = True

2067

if type(server_settings[option]) is str:

2068

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

2418

2069

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

2419

2070

2420

2071

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

2421

2072

2422

if (not server_settings["zeroconf"] and

2423

not (server_settings["port"]

2424

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

2425

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

2426

" Zeroconf")

2427

2428

2073

# For convenience

2429

2074

debug = server_settings["debug"]

2430

2075

debuglevel = server_settings["debuglevel"]

2432

2077

use_ipv6 = server_settings["use_ipv6"]

2433

2078

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

2434

2079

stored_state_file)

2435

foreground = server_settings["foreground"]

2436

zeroconf = server_settings["zeroconf"]

2437

2080

2438

2081

if debug:

2439

2082

initlogger(debug, logging.DEBUG)

2446

2089

2447

2090

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

2448

2091

syslogger.setFormatter(logging.Formatter

2449

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

2450

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

2451

.format(server_settings

2452

["servicename"])))

2092

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

2093

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

2094

% server_settings["servicename"]))

2453

2095

2454

2096

# Parse config file with clients

2455

client_config = configparser.SafeConfigParser(Client

2456

.client_defaults)

2097

client_config = configparser.SafeConfigParser(Client.client_defaults)

2457

2098

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

2458

2099

"clients.conf"))

2459

2100

2460

2101

global mandos_dbus_service

2461

2102

mandos_dbus_service = None

2462

2103

2463

socketfd = None

2464

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

2465

socketfd = server_settings["socket"]

2466

2104

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

2467

2105

server_settings["port"]),

2468

2106

ClientHandler,

2471

2109

use_ipv6=use_ipv6,

2472

2110

gnutls_priority=

2473

2111

server_settings["priority"],

2474

use_dbus=use_dbus,

2475

socketfd=socketfd)

2476

if not foreground:

2477

pidfilename = "/run/mandos.pid"

2478

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

2479

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

2480

pidfile = None

2112

use_dbus=use_dbus)

2113

if not debug:

2114

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

2481

2115

try:

2482

2116

pidfile = open(pidfilename, "w")

2483

except IOError as e:

2484

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

2485

exc_info=e)

2117

except IOError:

2118

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

2486

2119

2487

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:

2488

2124

try:

2489

uid = pwd.getpwnam(name).pw_uid

2490

gid = pwd.getpwnam(name).pw_gid

2491

break

2125

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

2126

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

2492

2127

except KeyError:

2493

continue

2494

else:

2495

uid = 65534

2496

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

2497

2134

try:

2498

2135

os.setgid(gid)

2499

2136

os.setuid(uid)

2500

2137

except OSError as error:

2501

if error.errno != errno.EPERM:

2502

raise

2138

if error[0] != errno.EPERM:

2139

raise error

2503

2140

2504

2141

if debug:

2505

2142

# Enable all possible GnuTLS debugging

2516

2153

.gnutls_global_set_log_function(debug_gnutls))

2517

2154

2518

2155

# Redirect stdin so all checkers get /dev/null

2519

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

2156

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

2520

2157

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

2521

2158

if null > 2:

2522

2159

os.close(null)

2523

2160

2524

2161

# Need to fork before connecting to D-Bus

2525

if not foreground:

2162

if not debug:

2526

2163

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

2527

2164

daemon()

2528

2165

2529

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

2530

# need to inform gobject that threads will be used.

2531

2166

gobject.threads_init()

2532

2167

2533

2168

global main_loop

2534

2169

# From the Avahi example code

2535

DBusGMainLoop(set_as_default=True)

2170

DBusGMainLoop(set_as_default=True )

2536

2171

main_loop = gobject.MainLoop()

2537

2172

bus = dbus.SystemBus()

2538

2173

# End of Avahi example code

2544

2179

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

2545

2180

do_not_queue=True))

2546

2181

except dbus.exceptions.NameExistsException as e:

2547

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

2182

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

2548

2183

use_dbus = False

2549

2184

server_settings["use_dbus"] = False

2550

2185

tcp_server.use_dbus = False

2551

if zeroconf:

2552

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2553

service = AvahiServiceToSyslog(name =

2554

server_settings["servicename"],

2555

servicetype = "_mandos._tcp",

2556

protocol = protocol, bus = bus)

2557

if server_settings["interface"]:

2558

service.interface = (if_nametoindex

2559

(server_settings["interface"]

2560

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

2561

2194

2562

2195

global multiprocessing_manager

2563

2196

multiprocessing_manager = multiprocessing.Manager()

2564

2197

2565

2198

client_class = Client

2566

2199

if use_dbus:

2567

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

2200

client_class = functools.partial(ClientDBusTransitional,

2201

bus = bus)

2568

2202

2569

2203

client_settings = Client.config_parser(client_config)

2570

2204

old_client_settings = {}

2571

2205

clients_data = {}

2572

2206

2573

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

2574

global wnull

2575

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

2576

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

2577

# mode

2578

if debug or not foreground:

2579

wnull.close()

2580

2581

2207

# Get client data and settings from last running state.

2582

2208

if server_settings["restore"]:

2583

2209

try:

2586

2212

(stored_state))

2587

2213

os.remove(stored_state_path)

2588

2214

except IOError as e:

2589

if e.errno == errno.ENOENT:

2590

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

2591

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

2592

else:

2593

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

2594

exc_info=e)

2215

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

2216

.format(e))

2217

if e.errno != errno.ENOENT:

2595

2218

raise

2596

2219

except EOFError as e:

2597

2220

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

2598

"EOFError:", exc_info=e)

2221

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

2599

2222

2600

2223

with PGPEngine() as pgp:

2601

for client_name, client in clients_data.items():

2602

# Skip removed clients

2603

if client_name not in client_settings:

2604

continue

2605

2224

for client_name, client in clients_data.iteritems():

2606

2225

# Decide which value to use after restoring saved state.

2607

2226

# We have three different values: Old config file,

2608

2227

# new config file, and saved state.

2622

2241

2623

2242

# Clients who has passed its expire date can still be

2624

2243

# enabled if its last checker was successful. Clients

2625

# whose checker succeeded before we stored its state is

2626

# assumed to have successfully run all checkers during

2627

# downtime.

2244

# whose checker failed before we stored its state is

2245

# assumed to have failed all checkers during downtime.

2628

2246

if client["enabled"]:

2629

2247

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

2630

2248

if not client["last_checked_ok"]:

2631

2249

logger.warning(

2632

"disabling client {} - Client never "

2633

"performed a successful checker"

2634

.format(client_name))

2250

"disabling client {0} - Client never "

2251

"performed a successfull checker"

2252

.format(client["name"]))

2635

2253

client["enabled"] = False

2636

2254

elif client["last_checker_status"] != 0:

2637

2255

logger.warning(

2638

"disabling client {} - Client last"

2639

" checker failed with error code {}"

2640

.format(client_name,

2256

"disabling client {0} - Client "

2257

"last checker failed with error code {1}"

2258

.format(client["name"],

2641

2259

client["last_checker_status"]))

2642

2260

client["enabled"] = False

2643

2261

else:

2644

2262

client["expires"] = (datetime.datetime

2645

2263

.utcnow()

2646

2264

+ client["timeout"])

2647

logger.debug("Last checker succeeded,"

2648

" keeping {} enabled"

2649

.format(client_name))

2265

2650

2266

try:

2651

2267

client["secret"] = (

2652

2268

pgp.decrypt(client["encrypted_secret"],

2654

2270

["secret"]))

2655

2271

except PGPError:

2656

2272

# If decryption fails, we use secret from new settings

2657

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

2273

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

2658

2274

.format(client_name))

2659

2275

client["secret"] = (

2660

2276

client_settings[client_name]["secret"])

2277

2661

2278

2662

2279

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

2663

for client_name in (set(old_client_settings)

2664

- set(client_settings)):

2280

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

2665

2281

del clients_data[client_name]

2666

for client_name in (set(client_settings)

2667

- set(old_client_settings)):

2282

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

2668

2283

clients_data[client_name] = client_settings[client_name]

2669

2670

# Create all client objects

2671

for client_name, client in clients_data.items():

2284

2285

# Create clients all clients

2286

for client_name, client in clients_data.iteritems():

2672

2287

tcp_server.clients[client_name] = client_class(

2673

name = client_name, settings = client,

2674

server_settings = server_settings)

2288

name = client_name, settings = client)

2675

2289

2676

2290

if not tcp_server.clients:

2677

2291

logger.warning("No clients defined")

2678

2679

if not foreground:

2680

if pidfile is not None:

2681

try:

2682

with pidfile:

2683

pid = os.getpid()

2684

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

2685

except IOError:

2686

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

2687

pidfilename, pid)

2688

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

2689

2305

del pidfilename

2306

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

2690

2307

2691

2308

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

2692

2309

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

2693

2310

2694

2311

if use_dbus:

2695

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

2696

"se.bsnet.fukt.Mandos"})

2697

class MandosDBusService(DBusObjectWithProperties):

2312

class MandosDBusService(dbus.service.Object):

2698

2313

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

2699

2314

def __init__(self):

2700

2315

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

2701

2316

_interface = "se.recompile.Mandos"

2702

2317

2703

@dbus_interface_annotations(_interface)

2704

def _foo(self):

2705

return { "org.freedesktop.DBus.Property"

2706

".EmitsChangedSignal":

2707

"false"}

2708

2709

2318

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

2710

2319

def ClientAdded(self, objpath):

2711

2320

"D-Bus signal"

2733

2342

def GetAllClientsWithProperties(self):

2734

2343

"D-Bus method"

2735

2344

return dbus.Dictionary(

2736

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

2737

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

2345

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

2346

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

2738

2347

signature="oa{sv}")

2739

2348

2740

2349

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

2753

2362

2754

2363

del _interface

2755

2364

2756

mandos_dbus_service = MandosDBusService()

2365

class MandosDBusServiceTransitional(MandosDBusService):

2366

__metaclass__ = AlternateDBusNamesMetaclass

2367

mandos_dbus_service = MandosDBusServiceTransitional()

2757

2368

2758

2369

def cleanup():

2759

2370

"Cleanup function; run on exit"

2760

if zeroconf:

2761

service.cleanup()

2371

service.cleanup()

2762

2372

2763

2373

multiprocessing.active_children()

2764

wnull.close()

2765

2374

if not (tcp_server.clients or client_settings):

2766

2375

return

2767

2376

2778

2387

2779

2388

# A list of attributes that can not be pickled

2780

2389

# + secret.

2781

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

2782

"checker", "server_settings" }

2390

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

2391

"checker"))

2783

2392

for name, typ in (inspect.getmembers

2784

2393

(dbus.service.Object)):

2785

2394

exclude.add(name)

2794

2403

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

2795

2404

2796

2405

try:

2797

with (tempfile.NamedTemporaryFile

2798

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

2799

dir=os.path.dirname(stored_state_path),

2800

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:

2801

2411

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

2802

tempname=stored_state.name

2803

2412

os.rename(tempname, stored_state_path)

2804

2413

except (IOError, OSError) as e:

2414

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

2415

.format(e))

2805

2416

if not debug:

2806

2417

try:

2807

2418

os.remove(tempname)

2808

2419

except NameError:

2809

2420

pass

2810

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

2811

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

2812

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

2813

else:

2814

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

2815

exc_info=e)

2816

raise

2421

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

2422

errno.EEXIST)):

2423

raise e

2817

2424

2818

2425

# Delete all clients, and settings from config

2819

2426

while tcp_server.clients:

2843

2450

tcp_server.server_activate()

2844

2451

2845

2452

# Find out what port we got

2846

if zeroconf:

2847

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

2453

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

2848

2454

if use_ipv6:

2849

2455

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

2850

" flowinfo %d, scope_id %d",

2851

*tcp_server.socket.getsockname())

2456

" flowinfo %d, scope_id %d"

2457

% tcp_server.socket.getsockname())

2852

2458

else: # IPv4

2853

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

2854

*tcp_server.socket.getsockname())

2459

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

2460

% tcp_server.socket.getsockname())

2855

2461

2856

2462

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

2857

2463

2858

2464

try:

2859

if zeroconf:

2860

# From the Avahi example code

2861

try:

2862

service.activate()

2863

except dbus.exceptions.DBusException as error:

2864

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

2865

cleanup()

2866

sys.exit(1)

2867

# 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

2868

2473

2869

2474

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

2870

2475

lambda *args, **kwargs:

2874

2479

logger.debug("Starting main loop")

2875

2480

main_loop.run()

2876

2481

except AvahiError as error:

2877

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

2482

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

2878

2483

cleanup()

2879

2484

sys.exit(1)

2880

2485

except KeyboardInterrupt: