/mandos/trunk : revision 636

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

37

39

import SocketServer as socketserver

38

40

import socket

39

41

import argparse

63

65

import cPickle as pickle

64

66

import multiprocessing

65

67

import types

66

import hashlib

68

import binascii

69

import tempfile

70

import itertools

71

import collections

67

72

68

73

import dbus

69

74

import dbus.service

74

79

import ctypes.util

75

80

import xml.dom.minidom

76

81

import inspect

77

import Crypto.Cipher.AES

78

82

79

83

try:

80

84

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

84

88

except ImportError:

85

89

SO_BINDTODEVICE = None

86

90

87

88

version = "1.4.1"

91

version = "1.6.2"

92

stored_state_file = "clients.pickle"

89

93

90

94

logger = logging.getLogger()

91

stored_state_path = "/var/lib/mandos/clients.pickle"

92

93

95

syslogger = (logging.handlers.SysLogHandler

94

96

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

95

97

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

96

syslogger.setFormatter(logging.Formatter

97

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

98

' %(message)s'))

99

logger.addHandler(syslogger)

100

101

console = logging.StreamHandler()

102

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

103

' [%(process)d]:'

104

' %(levelname)s:'

105

' %(message)s'))

106

logger.addHandler(console)

98

99

try:

100

if_nametoindex = (ctypes.cdll.LoadLibrary

101

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

102

.if_nametoindex)

103

except (OSError, AttributeError):

104

def if_nametoindex(interface):

105

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

106

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

107

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

108

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

109

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

110

interface))

111

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

112

ifreq[16:20])[0]

113

return interface_index

114

115

116

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

117

"""init logger and add loglevel"""

118

119

syslogger.setFormatter(logging.Formatter

120

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

121

' %(message)s'))

122

logger.addHandler(syslogger)

123

124

if debug:

125

console = logging.StreamHandler()

126

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

127

' [%(process)d]:'

128

' %(levelname)s:'

129

' %(message)s'))

130

logger.addHandler(console)

131

logger.setLevel(level)

132

133

134

class PGPError(Exception):

135

"""Exception if encryption/decryption fails"""

136

pass

137

138

139

class PGPEngine(object):

140

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

141

def __init__(self):

142

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

143

self.gnupgargs = ['--batch',

144

'--home', self.tempdir,

145

'--force-mdc',

146

'--quiet',

147

'--no-use-agent']

148

149

def __enter__(self):

150

return self

151

152

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

153

self._cleanup()

154

return False

155

156

def __del__(self):

157

self._cleanup()

158

159

def _cleanup(self):

160

if self.tempdir is not None:

161

# Delete contents of tempdir

162

for root, dirs, files in os.walk(self.tempdir,

163

topdown = False):

164

for filename in files:

165

os.remove(os.path.join(root, filename))

166

for dirname in dirs:

167

os.rmdir(os.path.join(root, dirname))

168

# Remove tempdir

169

os.rmdir(self.tempdir)

170

self.tempdir = None

171

172

def password_encode(self, password):

173

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

174

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

175

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

176

if len(encoded) > 2048:

177

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

178

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

179

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

180

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

181

return encoded

182

183

def encrypt(self, data, password):

184

passphrase = self.password_encode(password)

185

with tempfile.NamedTemporaryFile(dir=self.tempdir

186

) as passfile:

187

passfile.write(passphrase)

188

passfile.flush()

189

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

190

'--passphrase-file',

191

passfile.name]

192

+ self.gnupgargs,

193

stdin = subprocess.PIPE,

194

stdout = subprocess.PIPE,

195

stderr = subprocess.PIPE)

196

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

197

if proc.returncode != 0:

198

raise PGPError(err)

199

return ciphertext

200

201

def decrypt(self, data, password):

202

passphrase = self.password_encode(password)

203

with tempfile.NamedTemporaryFile(dir = self.tempdir

204

) as passfile:

205

passfile.write(passphrase)

206

passfile.flush()

207

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

208

'--passphrase-file',

209

passfile.name]

210

+ self.gnupgargs,

211

stdin = subprocess.PIPE,

212

stdout = subprocess.PIPE,

213

stderr = subprocess.PIPE)

214

decrypted_plaintext, err = proc.communicate(input

215

= data)

216

if proc.returncode != 0:

217

raise PGPError(err)

218

return decrypted_plaintext

107

219

108

220

109

221

class AvahiError(Exception):

128

240

Used to optionally bind to the specified interface.

129

241

name: string; Example: 'Mandos'

130

242

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

131

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

243

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

132

244

port: integer; what port to announce

133

245

TXT: list of strings; TXT record for the service

134

246

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

140

252

server: D-Bus Server

141

253

bus: dbus.SystemBus()

142

254

"""

255

143

256

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

144

257

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

145

258

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

158

271

self.server = None

159

272

self.bus = bus

160

273

self.entry_group_state_changed_match = None

274

161

275

def rename(self):

162

276

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

163

277

if self.rename_count >= self.max_renames:

173

287

try:

174

288

self.add()

175

289

except dbus.exceptions.DBusException as error:

176

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

290

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

177

291

self.cleanup()

178

292

os._exit(1)

179

293

self.rename_count += 1

294

180

295

def remove(self):

181

296

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

182

297

if self.entry_group_state_changed_match is not None:

184

299

self.entry_group_state_changed_match = None

185

300

if self.group is not None:

186

301

self.group.Reset()

302

187

303

def add(self):

188

304

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

189

305

self.remove()

206

322

dbus.UInt16(self.port),

207

323

avahi.string_array_to_txt_array(self.TXT))

208

324

self.group.Commit()

325

209

326

def entry_group_state_changed(self, state, error):

210

327

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

211

328

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

218

335

elif state == avahi.ENTRY_GROUP_FAILURE:

219

336

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

220

337

unicode(error))

221

raise AvahiGroupError("State changed: %s"

222

% unicode(error))

338

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

339

.format(error))

340

223

341

def cleanup(self):

224

342

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

225

343

if self.group is not None:

226

344

try:

227

345

self.group.Free()

228

346

except (dbus.exceptions.UnknownMethodException,

229

dbus.exceptions.DBusException) as e:

347

dbus.exceptions.DBusException):

230

348

pass

231

349

self.group = None

232

350

self.remove()

351

233

352

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

234

353

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

235

354

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

254

373

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

255

374

else:

256

375

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

376

257

377

def activate(self):

258

378

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

259

379

if self.server is None:

266

386

self.server_state_changed)

267

387

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

268

388

389

269

390

class AvahiServiceToSyslog(AvahiService):

270

391

def rename(self):

271

392

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

272

393

ret = AvahiService.rename(self)

273

394

syslogger.setFormatter(logging.Formatter

274

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

275

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

276

% self.name))

395

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

396

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

397

.format(self.name)))

277

398

return ret

278

399

279

def _timedelta_to_milliseconds(td):

400

401

def timedelta_to_milliseconds(td):

280

402

"Convert a datetime.timedelta() to milliseconds"

281

403

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

282

404

+ (td.seconds * 1000)

283

405

+ (td.microseconds // 1000))

284

406

407

285

408

class Client(object):

286

409

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

287

410

288

411

Attributes:

289

_approved: bool(); 'None' if not yet approved/disapproved

412

approved: bool(); 'None' if not yet approved/disapproved

290

413

approval_delay: datetime.timedelta(); Time to wait for approval

291

414

approval_duration: datetime.timedelta(); Duration of one approval

292

415

checker: subprocess.Popen(); a running checker process used

311

434

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

312

435

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

313

436

last_checker_status: integer between 0 and 255 reflecting exit

314

status of last checker. -1 reflect crashed

315

checker, or None.

316

last_enabled: datetime.datetime(); (UTC)

437

status of last checker. -1 reflects crashed

438

checker, -2 means no checker completed yet.

439

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

317

440

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

318

441

D-Bus identifiers

319

442

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

320

443

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

321

444

until this client is disabled

322

extended_timeout: extra long timeout when password has been sent

445

extended_timeout: extra long timeout when secret has been sent

323

446

runtime_expansions: Allowed attributes for runtime expansion.

324

447

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

325

448

disabled, or None

449

server_settings: The server_settings dict from main()

326

450

"""

327

451

328

452

runtime_expansions = ("approval_delay", "approval_duration",

329

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

330

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

453

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

454

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

455

"last_approval_request", "last_checked_ok",

331

456

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

457

client_defaults = { "timeout": "PT5M",

458

"extended_timeout": "PT15M",

459

"interval": "PT2M",

460

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

461

"host": "",

462

"approval_delay": "PT0S",

463

"approval_duration": "PT1S",

464

"approved_by_default": "True",

465

"enabled": "True",

466

}

332

467

333

468

def timeout_milliseconds(self):

334

469

"Return the 'timeout' attribute in milliseconds"

335

return _timedelta_to_milliseconds(self.timeout)

470

return timedelta_to_milliseconds(self.timeout)

336

471

337

472

def extended_timeout_milliseconds(self):

338

473

"Return the 'extended_timeout' attribute in milliseconds"

339

return _timedelta_to_milliseconds(self.extended_timeout)

474

return timedelta_to_milliseconds(self.extended_timeout)

340

475

341

476

def interval_milliseconds(self):

342

477

"Return the 'interval' attribute in milliseconds"

343

return _timedelta_to_milliseconds(self.interval)

478

return timedelta_to_milliseconds(self.interval)

344

479

345

480

def approval_delay_milliseconds(self):

346

return _timedelta_to_milliseconds(self.approval_delay)

347

348

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

349

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

350

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

351

attribute."""

481

return timedelta_to_milliseconds(self.approval_delay)

482

483

@staticmethod

484

def config_parser(config):

485

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

486

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

487

with exceptions for any special settings as defined above.

488

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

489

value given the same arguments.

490

"""

491

settings = {}

492

for client_name in config.sections():

493

section = dict(config.items(client_name))

494

client = settings[client_name] = {}

495

496

client["host"] = section["host"]

497

# Reformat values from string types to Python types

498

client["approved_by_default"] = config.getboolean(

499

client_name, "approved_by_default")

500

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

501

"enabled")

502

503

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

504

.replace(" ", ""))

505

if "secret" in section:

506

client["secret"] = section["secret"].decode("base64")

507

elif "secfile" in section:

508

with open(os.path.expanduser(os.path.expandvars

509

(section["secfile"])),

510

"rb") as secfile:

511

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

512

else:

513

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

514

.format(section))

515

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

516

client["extended_timeout"] = string_to_delta(

517

section["extended_timeout"])

518

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

519

client["approval_delay"] = string_to_delta(

520

section["approval_delay"])

521

client["approval_duration"] = string_to_delta(

522

section["approval_duration"])

523

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

524

client["last_approval_request"] = None

525

client["last_checked_ok"] = None

526

client["last_checker_status"] = -2

527

528

return settings

529

530

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

352

531

self.name = name

353

if config is None:

354

config = {}

532

if server_settings is None:

533

server_settings = {}

534

self.server_settings = server_settings

535

# adding all client settings

536

for setting, value in settings.iteritems():

537

setattr(self, setting, value)

538

539

if self.enabled:

540

if not hasattr(self, "last_enabled"):

541

self.last_enabled = datetime.datetime.utcnow()

542

if not hasattr(self, "expires"):

543

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

544

+ self.timeout)

545

else:

546

self.last_enabled = None

547

self.expires = None

548

355

549

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

356

550

# Uppercase and remove spaces from fingerprint for later

357

551

# comparison purposes with return value from the fingerprint()

358

552

# function

359

self.fingerprint = (config["fingerprint"].upper()

360

.replace(" ", ""))

361

553

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

362

if "secret" in config:

363

self.secret = config["secret"].decode("base64")

364

elif "secfile" in config:

365

with open(os.path.expanduser(os.path.expandvars

366

(config["secfile"])),

367

"rb") as secfile:

368

self.secret = secfile.read()

369

else:

370

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

371

% self.name)

372

self.host = config.get("host", "")

373

self.created = datetime.datetime.utcnow()

374

self.enabled = True

375

self.last_approval_request = None

376

self.last_enabled = datetime.datetime.utcnow()

377

self.last_checked_ok = None

378

self.last_checker_status = None

379

self.timeout = string_to_delta(config["timeout"])

380

self.extended_timeout = string_to_delta(config

381

["extended_timeout"])

382

self.interval = string_to_delta(config["interval"])

554

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

555

datetime.datetime.utcnow())

556

557

# attributes specific for this server instance

383

558

self.checker = None

384

559

self.checker_initiator_tag = None

385

560

self.disable_initiator_tag = None

386

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

387

561

self.checker_callback_tag = None

388

self.checker_command = config["checker"]

389

562

self.current_checker_command = None

390

self._approved = None

391

self.approved_by_default = config.get("approved_by_default",

392

True)

563

self.approved = None

393

564

self.approvals_pending = 0

394

self.approval_delay = string_to_delta(

395

config["approval_delay"])

396

self.approval_duration = string_to_delta(

397

config["approval_duration"])

398

565

self.changedstate = (multiprocessing_manager

399

566

.Condition(multiprocessing_manager

400

567

.Lock()))

401

self.client_structure = [attr for attr

402

in self.__dict__.iterkeys()

568

self.client_structure = [attr for attr in

569

self.__dict__.iterkeys()

403

570

if not attr.startswith("_")]

404

571

self.client_structure.append("client_structure")

405

406

572

407

573

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

408

574

lambda obj:

409

575

isinstance(obj,

421

587

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

422

588

# Already enabled

423

589

return

424

self.send_changedstate()

425

590

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

426

591

self.enabled = True

427

592

self.last_enabled = datetime.datetime.utcnow()

428

593

self.init_checker()

594

self.send_changedstate()

429

595

430

596

def disable(self, quiet=True):

431

597

"""Disable this client."""

432

598

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

433

599

return False

434

600

if not quiet:

435

self.send_changedstate()

436

if not quiet:

437

601

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

438

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

602

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

439

603

gobject.source_remove(self.disable_initiator_tag)

440

604

self.disable_initiator_tag = None

441

605

self.expires = None

442

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

606

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

443

607

gobject.source_remove(self.checker_initiator_tag)

444

608

self.checker_initiator_tag = None

445

609

self.stop_checker()

446

610

self.enabled = False

611

if not quiet:

612

self.send_changedstate()

447

613

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

448

614

return False

449

615

450

616

def __del__(self):

451

617

self.disable()

452

618

453

619

def init_checker(self):

454

620

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

455

621

# and every interval from then on.

622

if self.checker_initiator_tag is not None:

623

gobject.source_remove(self.checker_initiator_tag)

456

624

self.checker_initiator_tag = (gobject.timeout_add

457

625

(self.interval_milliseconds(),

458

626

self.start_checker))

459

627

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

628

if self.disable_initiator_tag is not None:

629

gobject.source_remove(self.disable_initiator_tag)

460

630

self.disable_initiator_tag = (gobject.timeout_add

461

631

(self.timeout_milliseconds(),

462

632

self.disable))

463

633

# Also start a new checker *right now*.

464

634

self.start_checker()

465

466

635

467

636

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

468

637

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

469

638

self.checker_callback_tag = None

470

639

self.checker = None

471

640

if os.WIFEXITED(condition):

472

self.last_checker_status = os.WEXITSTATUS(condition)

641

self.last_checker_status = os.WEXITSTATUS(condition)

473

642

if self.last_checker_status == 0:

474

643

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

475

644

vars(self))

482

651

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

483

652

vars(self))

484

653

485

def checked_ok(self, timeout=None):

486

"""Bump up the timeout for this client.

487

488

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

489

alive and well.

490

"""

654

def checked_ok(self):

655

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

656

self.last_checked_ok = datetime.datetime.utcnow()

657

self.last_checker_status = 0

658

self.bump_timeout()

659

660

def bump_timeout(self, timeout=None):

661

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

491

662

if timeout is None:

492

663

timeout = self.timeout

493

self.last_checked_ok = datetime.datetime.utcnow()

494

664

if self.disable_initiator_tag is not None:

495

665

gobject.source_remove(self.disable_initiator_tag)

666

self.disable_initiator_tag = None

496

667

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

497

668

self.disable_initiator_tag = (gobject.timeout_add

498

(_timedelta_to_milliseconds

669

(timedelta_to_milliseconds

499

670

(timeout), self.disable))

500

671

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

501

672

508

679

If a checker already exists, leave it running and do

509

680

nothing."""

510

681

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

511

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

512

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

513

# client would inevitably timeout, since no checker would get

514

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

682

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

683

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

684

# would inevitably timeout, since no checker would get a

685

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

515

686

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

516

687

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

517

688

# should be.

531

702

self.current_checker_command)

532

703

# Start a new checker if needed

533

704

if self.checker is None:

705

# Escape attributes for the shell

706

escaped_attrs = dict(

707

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

708

for attr in

709

self.runtime_expansions)

534

710

try:

535

# In case checker_command has exactly one % operator

536

command = self.checker_command % self.host

537

except TypeError:

538

# Escape attributes for the shell

539

escaped_attrs = dict(

540

(attr,

541

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

542

errors=

543

'replace')))

544

for attr in

545

self.runtime_expansions)

546

547

try:

548

command = self.checker_command % escaped_attrs

549

except TypeError as error:

550

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

551

' %s', self.checker_command, error)

552

return True # Try again later

711

command = self.checker_command % escaped_attrs

712

except TypeError as error:

713

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

714

self.checker_command, exc_info=error)

715

return True # Try again later

553

716

self.current_checker_command = command

554

717

try:

555

718

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

558

721

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

559

722

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

560

723

# always replaced by /dev/null.)

724

# The exception is when not debugging but nevertheless

725

# running in the foreground; use the previously

726

# created wnull.

727

popen_args = {}

728

if (not self.server_settings["debug"]

729

and self.server_settings["foreground"]):

730

popen_args.update({"stdout": wnull,

731

"stderr": wnull })

561

732

self.checker = subprocess.Popen(command,

562

733

close_fds=True,

563

shell=True, cwd="/")

564

self.checker_callback_tag = (gobject.child_watch_add

565

(self.checker.pid,

566

self.checker_callback,

567

data=command))

568

# The checker may have completed before the gobject

569

# watch was added. Check for this.

734

shell=True, cwd="/",

735

**popen_args)

736

except OSError as error:

737

logger.error("Failed to start subprocess",

738

exc_info=error)

739

return True

740

self.checker_callback_tag = (gobject.child_watch_add

741

(self.checker.pid,

742

self.checker_callback,

743

data=command))

744

# The checker may have completed before the gobject

745

# watch was added. Check for this.

746

try:

570

747

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

571

if pid:

572

gobject.source_remove(self.checker_callback_tag)

573

self.checker_callback(pid, status, command)

574

748

except OSError as error:

575

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

576

error)

749

if error.errno == errno.ECHILD:

750

# This should never happen

751

logger.error("Child process vanished",

752

exc_info=error)

753

return True

754

raise

755

if pid:

756

gobject.source_remove(self.checker_callback_tag)

757

self.checker_callback(pid, status, command)

577

758

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

578

759

return True

579

760

586

767

return

587

768

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

588

769

try:

589

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

770

self.checker.terminate()

590

771

#time.sleep(0.5)

591

772

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

592

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

773

# self.checker.kill()

593

774

except OSError as error:

594

775

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

595

776

raise

596

777

self.checker = None

597

778

598

# Encrypts a client secret and stores it in a varible

599

# encrypted_secret

600

def encrypt_secret(self, key):

601

# Encryption-key need to be of a specific size, so we hash

602

# supplied key

603

hasheng = hashlib.sha256()

604

hasheng.update(key)

605

encryptionkey = hasheng.digest()

606

607

# Create validation hash so we know at decryption if it was

608

# sucessful

609

hasheng = hashlib.sha256()

610

hasheng.update(self.secret)

611

validationhash = hasheng.digest()

612

613

# Encrypt secret

614

iv = os.urandom(Crypto.Cipher.AES.block_size)

615

ciphereng = Crypto.Cipher.AES.new(encryptionkey,

616

Crypto.Cipher.AES.MODE_CFB, iv)

617

ciphertext = ciphereng.encrypt(validationhash+self.secret)

618

self.encrypted_secret = (ciphertext, iv)

619

620

# Decrypt a encrypted client secret

621

def decrypt_secret(self, key):

622

# Decryption-key need to be of a specific size, so we hash

623

# supplied key

624

hasheng = hashlib.sha256()

625

hasheng.update(key)

626

encryptionkey = hasheng.digest()

627

628

# Decrypt encrypted secret

629

ciphertext, iv = self.encrypted_secret

630

ciphereng = Crypto.Cipher.AES.new(encryptionkey,

631

Crypto.Cipher.AES.MODE_CFB, iv)

632

plain = ciphereng.decrypt(ciphertext)

633

634

# Validate decrypted secret to know if it was succesful

635

hasheng = hashlib.sha256()

636

validationhash = plain[:hasheng.digest_size]

637

secret = plain[hasheng.digest_size:]

638

hasheng.update(secret)

639

640

# If validation fails, we use key as new secret. Otherwise, we

641

# use the decrypted secret

642

if hasheng.digest() == validationhash:

643

self.secret = secret

644

else:

645

self.secret = key

646

del self.encrypted_secret

647

648

779

649

780

def dbus_service_property(dbus_interface, signature="v",

650

781

access="readwrite", byte_arrays=False):

662

793

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

663

794

if byte_arrays and signature != "ay":

664

795

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

665

" signature %r" % signature)

796

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

666

797

def decorator(func):

667

798

func._dbus_is_property = True

668

799

func._dbus_interface = dbus_interface

676

807

return decorator

677

808

678

809

810

def dbus_interface_annotations(dbus_interface):

811

"""Decorator for marking functions returning interface annotations

812

813

Usage:

814

815

@dbus_interface_annotations("org.example.Interface")

816

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

817

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

818

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

819

"false"}

820

"""

821

def decorator(func):

822

func._dbus_is_interface = True

823

func._dbus_interface = dbus_interface

824

func._dbus_name = dbus_interface

825

return func

826

return decorator

827

828

829

def dbus_annotations(annotations):

830

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

831

Usage:

832

833

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

834

access="r")

835

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

836

"org.freedesktop.DBus.Property."

837

"EmitsChangedSignal": "false"})

838

def Property_dbus_property(self):

839

return dbus.Boolean(False)

840

"""

841

def decorator(func):

842

func._dbus_annotations = annotations

843

return func

844

return decorator

845

846

679

847

class DBusPropertyException(dbus.exceptions.DBusException):

680

848

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

681

849

"""

704

872

"""

705

873

706

874

@staticmethod

707

def _is_dbus_property(obj):

708

return getattr(obj, "_dbus_is_property", False)

875

def _is_dbus_thing(thing):

876

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

877

878

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

879

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

880

"""

881

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

882

False)

709

883

710

def _get_all_dbus_properties(self):

884

def _get_all_dbus_things(self, thing):

711

885

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

712

886

"""

713

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

887

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

888

name),

889

athing.__get__(self))

714

890

for cls in self.__class__.__mro__

715

for name, prop in

716

inspect.getmembers(cls, self._is_dbus_property))

891

for name, athing in

892

inspect.getmembers(cls,

893

self._is_dbus_thing(thing)))

717

894

718

895

def _get_dbus_property(self, interface_name, property_name):

719

896

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

721

898

"""

722

899

for cls in self.__class__.__mro__:

723

900

for name, value in (inspect.getmembers

724

(cls, self._is_dbus_property)):

901

(cls,

902

self._is_dbus_thing("property"))):

725

903

if (value._dbus_name == property_name

726

904

and value._dbus_interface == interface_name):

727

905

return value.__get__(self)

756

934

# signatures other than "ay".

757

935

if prop._dbus_signature != "ay":

758

936

raise ValueError

759

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

760

for byte in value))

937

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

938

for byte in value))

761

939

prop(value)

762

940

763

941

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

768

946

769

947

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

770

948

"""

771

all = {}

772

for name, prop in self._get_all_dbus_properties():

949

properties = {}

950

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

773

951

if (interface_name

774

952

and interface_name != prop._dbus_interface):

775

953

# Interface non-empty but did not match

779

957

continue

780

958

value = prop()

781

959

if not hasattr(value, "variant_level"):

782

all[name] = value

960

properties[name] = value

783

961

continue

784

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

785

value.variant_level+1)

786

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

962

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

963

value.variant_level+1)

964

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

787

965

788

966

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

789

967

out_signature="s",

790

968

path_keyword='object_path',

791

969

connection_keyword='connection')

792

970

def Introspect(self, object_path, connection):

793

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

971

"""Overloading of standard D-Bus method.

972

973

Inserts property tags and interface annotation tags.

794

974

"""

795

975

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

796

976

connection)

803

983

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

804

984

return e

805

985

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

986

# Add property tags

806

987

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

807

988

for name, prop

808

in self._get_all_dbus_properties()

989

in self._get_all_dbus_things("property")

809

990

if prop._dbus_interface

810

991

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

811

992

if_tag.appendChild(tag)

993

# Add annotation tags

994

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

995

for tag in if_tag.getElementsByTagName(typ):

996

annots = dict()

997

for name, prop in (self.

998

_get_all_dbus_things(typ)):

999

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

1000

and prop._dbus_interface

1001

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

1002

annots.update(getattr

1003

(prop,

1004

"_dbus_annotations",

1005

{}))

1006

for name, value in annots.iteritems():

1007

ann_tag = document.createElement(

1008

"annotation")

1009

ann_tag.setAttribute("name", name)

1010

ann_tag.setAttribute("value", value)

1011

tag.appendChild(ann_tag)

1012

# Add interface annotation tags

1013

for annotation, value in dict(

1014

itertools.chain.from_iterable(

1015

annotations().iteritems()

1016

for name, annotations in

1017

self._get_all_dbus_things("interface")

1018

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

1019

)).iteritems():

1020

ann_tag = document.createElement("annotation")

1021

ann_tag.setAttribute("name", annotation)

1022

ann_tag.setAttribute("value", value)

1023

if_tag.appendChild(ann_tag)

812

1024

# Add the names to the return values for the

813

1025

# "org.freedesktop.DBus.Properties" methods

814

1026

if (if_tag.getAttribute("name")

829

1041

except (AttributeError, xml.dom.DOMException,

830

1042

xml.parsers.expat.ExpatError) as error:

831

1043

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

832

error)

1044

exc_info=error)

833

1045

return xmlstring

834

1046

835

1047

836

def datetime_to_dbus (dt, variant_level=0):

1048

def datetime_to_dbus(dt, variant_level=0):

837

1049

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

838

1050

if dt is None:

839

1051

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

840

1052

return dbus.String(dt.isoformat(),

841

1053

variant_level=variant_level)

842

1054

843

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

844

.__metaclass__):

845

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

846

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

1055

1056

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1057

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

1058

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

1059

interface names according to the "alt_interface_names" mapping.

1060

Usage:

1061

1062

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

1063

"net.example.AlternateInterface"})

1064

class SampleDBusObject(dbus.service.Object):

1065

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

1066

def SampleDBusMethod():

1067

pass

1068

1069

The above "SampleDBusMethod" on "SampleDBusObject" will be

1070

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

1071

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

1072

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

1073

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

1074

1075

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

1076

(from DBusObjectWithProperties) and interfaces (from the

1077

dbus_interface_annotations decorator).

847

1078

"""

848

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

849

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

850

# methods, signals, or properties in them

851

for base in (b for b in bases

852

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

853

# Go though all attributes of the base class

854

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

1079

def wrapper(cls):

1080

for orig_interface_name, alt_interface_name in (

1081

alt_interface_names.iteritems()):

1082

attr = {}

1083

interface_names = set()

1084

# Go though all attributes of the class

1085

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

855

1086

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

856

1087

# with the wrong interface name

857

1088

if (not hasattr(attribute, "_dbus_interface")

858

1089

or not attribute._dbus_interface

859

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

1090

.startswith(orig_interface_name)):

860

1091

continue

861

1092

# Create an alternate D-Bus interface name based on

862

1093

# the current name

863

1094

alt_interface = (attribute._dbus_interface

864

.replace("se.recompile.Mandos",

865

"se.bsnet.fukt.Mandos"))

1095

.replace(orig_interface_name,

1096

alt_interface_name))

1097

interface_names.add(alt_interface)

866

1098

# Is this a D-Bus signal?

867

1099

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

868

# Extract the original non-method function by

869

# black magic

1100

# Extract the original non-method undecorated

1101

# function by black magic

870

1102

nonmethod_func = (dict(

871

1103

zip(attribute.func_code.co_freevars,

872

1104

attribute.__closure__))["func"]

883

1115

nonmethod_func.func_name,

884

1116

nonmethod_func.func_defaults,

885

1117

nonmethod_func.func_closure)))

1118

# Copy annotations, if any

1119

try:

1120

new_function._dbus_annotations = (

1121

dict(attribute._dbus_annotations))

1122

except AttributeError:

1123

pass

886

1124

# Define a creator of a function to call both the

887

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

888

# signals gets sent when the function is called

1125

# original and alternate functions, so both the

1126

# original and alternate signals gets sent when

1127

# the function is called

889

1128

def fixscope(func1, func2):

890

1129

"""This function is a scope container to pass

891

1130

func1 and func2 to the "call_both" function

898

1137

return call_both

899

1138

# Create the "call_both" function and add it to

900

1139

# the class

901

attr[attrname] = fixscope(attribute,

902

new_function)

1140

attr[attrname] = fixscope(attribute, new_function)

903

1141

# Is this a D-Bus method?

904

1142

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

905

1143

# Create a new, but exactly alike, function

916

1154

attribute.func_name,

917

1155

attribute.func_defaults,

918

1156

attribute.func_closure)))

1157

# Copy annotations, if any

1158

try:

1159

attr[attrname]._dbus_annotations = (

1160

dict(attribute._dbus_annotations))

1161

except AttributeError:

1162

pass

919

1163

# Is this a D-Bus property?

920

1164

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

921

1165

# Create a new, but exactly alike, function

935

1179

attribute.func_name,

936

1180

attribute.func_defaults,

937

1181

attribute.func_closure)))

938

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

939

1182

# Copy annotations, if any

1183

try:

1184

attr[attrname]._dbus_annotations = (

1185

dict(attribute._dbus_annotations))

1186

except AttributeError:

1187

pass

1188

# Is this a D-Bus interface?

1189

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

1190

# Create a new, but exactly alike, function

1191

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

1192

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

1193

# to the class.

1194

attr[attrname] = (dbus_interface_annotations

1195

(alt_interface)

1196

(types.FunctionType

1197

(attribute.func_code,

1198

attribute.func_globals,

1199

attribute.func_name,

1200

attribute.func_defaults,

1201

attribute.func_closure)))

1202

if deprecate:

1203

# Deprecate all alternate interfaces

1204

iname="_AlternateDBusNames_interface_annotation{0}"

1205

for interface_name in interface_names:

1206

@dbus_interface_annotations(interface_name)

1207

def func(self):

1208

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

1209

"true" }

1210

# Find an unused name

1211

for aname in (iname.format(i)

1212

for i in itertools.count()):

1213

if aname not in attr:

1214

attr[aname] = func

1215

break

1216

if interface_names:

1217

# Replace the class with a new subclass of it with

1218

# methods, signals, etc. as created above.

1219

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

1220

(cls,), attr)

1221

return cls

1222

return wrapper

1223

1224

1225

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

1226

"se.bsnet.fukt.Mandos"})

940

1227

class ClientDBus(Client, DBusObjectWithProperties):

941

1228

"""A Client class using D-Bus

942

1229

952

1239

953

1240

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

954

1241

self.bus = bus

955

self._approvals_pending = 0

956

1242

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

957

self.add_to_dbus()

958

959

def add_to_dbus(self):

960

1243

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

961

1244

# the D-Bus

962

1245

client_object_name = unicode(self.name).translate(

966

1249

("/clients/" + client_object_name))

967

1250

DBusObjectWithProperties.__init__(self, self.bus,

968

1251

self.dbus_object_path)

969

1252

970

1253

def notifychangeproperty(transform_func,

971

1254

dbus_name, type_func=lambda x: x,

972

1255

variant_level=1):

973

1256

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

974

1257

its changes to DBus.

975

1258

976

1259

transform_fun: Function that takes a value and a variant_level

977

1260

and transforms it to a D-Bus type.

978

1261

dbus_name: D-Bus name of the variable

995

1278

996

1279

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

997

1280

998

999

1281

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1000

1282

approvals_pending = notifychangeproperty(dbus.Boolean,

1001

1283

"ApprovalPending",

1008

1290

checker is not None)

1009

1291

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1010

1292

"LastCheckedOK")

1293

last_checker_status = notifychangeproperty(dbus.Int16,

1294

"LastCheckerStatus")

1011

1295

last_approval_request = notifychangeproperty(

1012

1296

datetime_to_dbus, "LastApprovalRequest")

1013

1297

approved_by_default = notifychangeproperty(dbus.Boolean,

1014

1298

"ApprovedByDefault")

1015

approval_delay = notifychangeproperty(dbus.UInt16,

1299

approval_delay = notifychangeproperty(dbus.UInt64,

1016

1300

"ApprovalDelay",

1017

1301

type_func =

1018

_timedelta_to_milliseconds)

1302

timedelta_to_milliseconds)

1019

1303

approval_duration = notifychangeproperty(

1020

dbus.UInt16, "ApprovalDuration",

1021

type_func = _timedelta_to_milliseconds)

1304

dbus.UInt64, "ApprovalDuration",

1305

type_func = timedelta_to_milliseconds)

1022

1306

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

1023

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

1307

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

1024

1308

type_func =

1025

_timedelta_to_milliseconds)

1309

timedelta_to_milliseconds)

1026

1310

extended_timeout = notifychangeproperty(

1027

dbus.UInt16, "ExtendedTimeout",

1028

type_func = _timedelta_to_milliseconds)

1029

interval = notifychangeproperty(dbus.UInt16,

1311

dbus.UInt64, "ExtendedTimeout",

1312

type_func = timedelta_to_milliseconds)

1313

interval = notifychangeproperty(dbus.UInt64,

1030

1314

"Interval",

1031

1315

type_func =

1032

_timedelta_to_milliseconds)

1316

timedelta_to_milliseconds)

1033

1317

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

1034

1318

1035

1319

del notifychangeproperty

1077

1361

return r

1078

1362

1079

1363

def _reset_approved(self):

1080

self._approved = None

1364

self.approved = None

1081

1365

return False

1082

1366

1083

1367

def approve(self, value=True):

1084

self.send_changedstate()

1085

self._approved = value

1086

gobject.timeout_add(_timedelta_to_milliseconds

1368

self.approved = value

1369

gobject.timeout_add(timedelta_to_milliseconds

1087

1370

(self.approval_duration),

1088

1371

self._reset_approved)

1089

1372

self.send_changedstate()

1090

1373

1091

1374

## D-Bus methods, signals & properties

1092

1375

_interface = "se.recompile.Mandos.Client"

1093

1376

1377

## Interfaces

1378

1379

@dbus_interface_annotations(_interface)

1380

def _foo(self):

1381

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

1382

"false"}

1383

1094

1384

## Signals

1095

1385

1096

1386

# CheckerCompleted - signal

1195

1485

access="readwrite")

1196

1486

def ApprovalDuration_dbus_property(self, value=None):

1197

1487

if value is None: # get

1198

return dbus.UInt64(_timedelta_to_milliseconds(

1488

return dbus.UInt64(timedelta_to_milliseconds(

1199

1489

self.approval_duration))

1200

1490

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

1201

1491

1215

1505

def Host_dbus_property(self, value=None):

1216

1506

if value is None: # get

1217

1507

return dbus.String(self.host)

1218

self.host = value

1508

self.host = unicode(value)

1219

1509

1220

1510

# Created - property

1221

1511

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

1222

1512

def Created_dbus_property(self):

1223

return dbus.String(datetime_to_dbus(self.created))

1513

return datetime_to_dbus(self.created)

1224

1514

1225

1515

# LastEnabled - property

1226

1516

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

1247

1537

return

1248

1538

return datetime_to_dbus(self.last_checked_ok)

1249

1539

1540

# LastCheckerStatus - property

1541

@dbus_service_property(_interface, signature="n",

1542

access="read")

1543

def LastCheckerStatus_dbus_property(self):

1544

return dbus.Int16(self.last_checker_status)

1545

1250

1546

# Expires - property

1251

1547

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

1252

1548

def Expires_dbus_property(self):

1263

1559

def Timeout_dbus_property(self, value=None):

1264

1560

if value is None: # get

1265

1561

return dbus.UInt64(self.timeout_milliseconds())

1562

old_timeout = self.timeout

1266

1563

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

1267

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

1268

return

1269

# Reschedule timeout

1270

gobject.source_remove(self.disable_initiator_tag)

1271

self.disable_initiator_tag = None

1272

self.expires = None

1273

time_to_die = _timedelta_to_milliseconds((self

1274

.last_checked_ok

1275

+ self.timeout)

1276

- datetime.datetime

1277

.utcnow())

1278

if time_to_die <= 0:

1279

# The timeout has passed

1280

self.disable()

1281

else:

1282

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

1283

+ datetime.timedelta(milliseconds =

1284

time_to_die))

1285

self.disable_initiator_tag = (gobject.timeout_add

1286

(time_to_die, self.disable))

1564

# Reschedule disabling

1565

if self.enabled:

1566

now = datetime.datetime.utcnow()

1567

self.expires += self.timeout - old_timeout

1568

if self.expires <= now:

1569

# The timeout has passed

1570

self.disable()

1571

else:

1572

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

1573

is None):

1574

return

1575

gobject.source_remove(self.disable_initiator_tag)

1576

self.disable_initiator_tag = (

1577

gobject.timeout_add(

1578

timedelta_to_milliseconds(self.expires - now),

1579

self.disable))

1287

1580

1288

1581

# ExtendedTimeout - property

1289

1582

@dbus_service_property(_interface, signature="t",

1302

1595

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

1303

1596

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

1304

1597

return

1305

# Reschedule checker run

1306

gobject.source_remove(self.checker_initiator_tag)

1307

self.checker_initiator_tag = (gobject.timeout_add

1308

(value, self.start_checker))

1309

self.start_checker() # Start one now, too

1598

if self.enabled:

1599

# Reschedule checker run

1600

gobject.source_remove(self.checker_initiator_tag)

1601

self.checker_initiator_tag = (gobject.timeout_add

1602

(value, self.start_checker))

1603

self.start_checker() # Start one now, too

1310

1604

1311

1605

# Checker - property

1312

1606

@dbus_service_property(_interface, signature="s",

1314

1608

def Checker_dbus_property(self, value=None):

1315

1609

if value is None: # get

1316

1610

return dbus.String(self.checker_command)

1317

self.checker_command = value

1611

self.checker_command = unicode(value)

1318

1612

1319

1613

# CheckerRunning - property

1320

1614

@dbus_service_property(_interface, signature="b",

1349

1643

raise KeyError()

1350

1644

1351

1645

def __getattribute__(self, name):

1352

if(name == '_pipe'):

1646

if name == '_pipe':

1353

1647

return super(ProxyClient, self).__getattribute__(name)

1354

1648

self._pipe.send(('getattr', name))

1355

1649

data = self._pipe.recv()

1362

1656

return func

1363

1657

1364

1658

def __setattr__(self, name, value):

1365

if(name == '_pipe'):

1659

if name == '_pipe':

1366

1660

return super(ProxyClient, self).__setattr__(name, value)

1367

1661

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

1368

1662

1369

class ClientDBusTransitional(ClientDBus):

1370

__metaclass__ = AlternateDBusNamesMetaclass

1371

1663

1372

1664

class ClientHandler(socketserver.BaseRequestHandler, object):

1373

1665

"""A class to handle client connections.

1456

1748

client.Rejected("Disabled")

1457

1749

return

1458

1750

1459

if client._approved or not client.approval_delay:

1751

if client.approved or not client.approval_delay:

1460

1752

#We are approved or approval is disabled

1461

1753

break

1462

elif client._approved is None:

1754

elif client.approved is None:

1463

1755

logger.info("Client %s needs approval",

1464

1756

client.name)

1465

1757

if self.server.use_dbus:

1478

1770

#wait until timeout or approved

1479

1771

time = datetime.datetime.now()

1480

1772

client.changedstate.acquire()

1481

(client.changedstate.wait

1482

(float(client._timedelta_to_milliseconds(delay)

1483

/ 1000)))

1773

client.changedstate.wait(

1774

float(timedelta_to_milliseconds(delay)

1775

/ 1000))

1484

1776

client.changedstate.release()

1485

1777

time2 = datetime.datetime.now()

1486

1778

if (time2 - time) >= delay:

1502

1794

try:

1503

1795

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

1504

1796

except gnutls.errors.GNUTLSError as error:

1505

logger.warning("gnutls send failed")

1797

logger.warning("gnutls send failed",

1798

exc_info=error)

1506

1799

return

1507

1800

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

1508

1801

sent, len(client.secret)

1511

1804

1512

1805

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

1513

1806

# bump the timeout using extended_timeout

1514

client.checked_ok(client.extended_timeout)

1807

client.bump_timeout(client.extended_timeout)

1515

1808

if self.server.use_dbus:

1516

1809

# Emit D-Bus signal

1517

1810

client.GotSecret()

1522

1815

try:

1523

1816

session.bye()

1524

1817

except gnutls.errors.GNUTLSError as error:

1525

logger.warning("GnuTLS bye failed")

1818

logger.warning("GnuTLS bye failed",

1819

exc_info=error)

1526

1820

1527

1821

@staticmethod

1528

1822

def peer_certificate(session):

1584

1878

# Convert the buffer to a Python bytestring

1585

1879

fpr = ctypes.string_at(buf, buf_len.value)

1586

1880

# Convert the bytestring to hexadecimal notation

1587

hex_fpr = ''.join("%02X" % ord(char) for char in fpr)

1881

hex_fpr = binascii.hexlify(fpr).upper()

1588

1882

return hex_fpr

1589

1883

1590

1884

1593

1887

def sub_process_main(self, request, address):

1594

1888

try:

1595

1889

self.finish_request(request, address)

1596

except:

1890

except Exception:

1597

1891

self.handle_error(request, address)

1598

1892

self.close_request(request)

1599

1893

1600

1894

def process_request(self, request, address):

1601

1895

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

1602

1896

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

1603

args = (request,

1604

address))

1897

args = (request, address))

1605

1898

proc.start()

1606

1899

return proc

1607

1900

1635

1928

use_ipv6: Boolean; to use IPv6 or not

1636

1929

"""

1637

1930

def __init__(self, server_address, RequestHandlerClass,

1638

interface=None, use_ipv6=True):

1931

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

1932

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

1933

creating a new one with socket.socket().

1934

"""

1639

1935

self.interface = interface

1640

1936

if use_ipv6:

1641

1937

self.address_family = socket.AF_INET6

1938

if socketfd is not None:

1939

# Save the file descriptor

1940

self.socketfd = socketfd

1941

# Save the original socket.socket() function

1942

self.socket_socket = socket.socket

1943

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

1944

#

1945

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

1946

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

1947

# patching socket.socket.)

1948

#

1949

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

1950

@functools.wraps(socket.socket)

1951

def socket_wrapper(*args, **kwargs):

1952

# Restore original function so subsequent calls are

1953

# not affected.

1954

socket.socket = self.socket_socket

1955

del self.socket_socket

1956

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

1957

# saved file descriptor.

1958

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

1959

# Replace socket.socket() function with wrapper

1960

socket.socket = socket_wrapper

1961

# The socketserver.TCPServer.__init__ will call

1962

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

1963

# socket_wrapper(), if socketfd was set.

1642

1964

socketserver.TCPServer.__init__(self, server_address,

1643

1965

RequestHandlerClass)

1966

1644

1967

def server_bind(self):

1645

1968

"""This overrides the normal server_bind() function

1646

1969

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

1654

1977

try:

1655

1978

self.socket.setsockopt(socket.SOL_SOCKET,

1656

1979

SO_BINDTODEVICE,

1657

str(self.interface

1658

+ '\0'))

1980

str(self.interface + '\0'))

1659

1981

except socket.error as error:

1660

if error[0] == errno.EPERM:

1661

logger.error("No permission to"

1662

" bind to interface %s",

1663

self.interface)

1664

elif error[0] == errno.ENOPROTOOPT:

1982

if error.errno == errno.EPERM:

1983

logger.error("No permission to bind to"

1984

" interface %s", self.interface)

1985

elif error.errno == errno.ENOPROTOOPT:

1665

1986

logger.error("SO_BINDTODEVICE not available;"

1666

1987

" cannot bind to interface %s",

1667

1988

self.interface)

1989

elif error.errno == errno.ENODEV:

1990

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

1991

" cannot bind", self.interface)

1668

1992

else:

1669

1993

raise

1670

1994

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

1673

1997

if self.address_family == socket.AF_INET6:

1674

1998

any_address = "::" # in6addr_any

1675

1999

else:

1676

any_address = socket.INADDR_ANY

2000

any_address = "0.0.0.0" # INADDR_ANY

1677

2001

self.server_address = (any_address,

1678

2002

self.server_address[1])

1679

2003

elif not self.server_address[1]:

1700

2024

"""

1701

2025

def __init__(self, server_address, RequestHandlerClass,

1702

2026

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

1703

gnutls_priority=None, use_dbus=True):

2027

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

1704

2028

self.enabled = False

1705

2029

self.clients = clients

1706

2030

if self.clients is None:

1710

2034

IPv6_TCPServer.__init__(self, server_address,

1711

2035

RequestHandlerClass,

1712

2036

interface = interface,

1713

use_ipv6 = use_ipv6)

2037

use_ipv6 = use_ipv6,

2038

socketfd = socketfd)

1714

2039

def server_activate(self):

1715

2040

if self.enabled:

1716

2041

return socketserver.TCPServer.server_activate(self)

1729

2054

1730

2055

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

1731

2056

proc = None, client_object=None):

1732

condition_names = {

1733

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

1734

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

1735

# blocking).

1736

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

1737

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

1738

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

1739

# broken, usually for pipes and

1740

# sockets).

1741

}

1742

conditions_string = ' | '.join(name

1743

for cond, name in

1744

condition_names.iteritems()

1745

if cond & condition)

1746

2057

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

1747

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

2058

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

1748

2059

# Wait for other process to exit

1749

2060

proc.join()

1750

2061

return False

1808

2119

return True

1809

2120

1810

2121

2122

def rfc3339_duration_to_delta(duration):

2123

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

2124

2125

>>> rfc3339_duration_to_delta("P7D")

2126

datetime.timedelta(7)

2127

>>> rfc3339_duration_to_delta("PT60S")

2128

datetime.timedelta(0, 60)

2129

>>> rfc3339_duration_to_delta("PT60M")

2130

datetime.timedelta(0, 3600)

2131

>>> rfc3339_duration_to_delta("PT24H")

2132

datetime.timedelta(1)

2133

>>> rfc3339_duration_to_delta("P1W")

2134

datetime.timedelta(7)

2135

>>> rfc3339_duration_to_delta("PT5M30S")

2136

datetime.timedelta(0, 330)

2137

>>> rfc3339_duration_to_delta("P1DT3M20S")

2138

datetime.timedelta(1, 200)

2139

"""

2140

2141

# Parsing an RFC 3339 duration with regular expressions is not

2142

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

2143

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

2144

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

2145

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

2146

# avoid excessive use of external libraries.

2147

2148

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

2149

Token = collections.namedtuple("Token",

2150

("regexp", # To match token; if

2151

# "value" is not None,

2152

# must have a "group"

2153

# containing digits

2154

"value", # datetime.timedelta or

2155

# None

2156

"followers")) # Tokens valid after

2157

# this token

2158

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

2159

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

2160

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

2161

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

2162

datetime.timedelta(seconds=1),

2163

frozenset((token_end,)))

2164

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

2165

datetime.timedelta(minutes=1),

2166

frozenset((token_second, token_end)))

2167

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

2168

datetime.timedelta(hours=1),

2169

frozenset((token_minute, token_end)))

2170

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

2171

None,

2172

frozenset((token_hour, token_minute,

2173

token_second)))

2174

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

2175

datetime.timedelta(days=1),

2176

frozenset((token_time, token_end)))

2177

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

2178

datetime.timedelta(weeks=4),

2179

frozenset((token_day, token_end)))

2180

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

2181

datetime.timedelta(weeks=52),

2182

frozenset((token_month, token_end)))

2183

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

2184

datetime.timedelta(weeks=1),

2185

frozenset((token_end,)))

2186

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

2187

frozenset((token_year, token_month,

2188

token_day, token_time,

2189

token_week))),

2190

# Define starting values

2191

value = datetime.timedelta() # Value so far

2192

found_token = None

2193

followers = frozenset(token_duration,) # Following valid tokens

2194

s = duration # String left to parse

2195

# Loop until end token is found

2196

while found_token is not token_end:

2197

# Search for any currently valid tokens

2198

for token in followers:

2199

match = token.regexp.match(s)

2200

if match is not None:

2201

# Token found

2202

if token.value is not None:

2203

# Value found, parse digits

2204

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

2205

# Add to value so far

2206

value += factor * token.value

2207

# Strip token from string

2208

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

2209

# Go to found token

2210

found_token = token

2211

# Set valid next tokens

2212

followers = found_token.followers

2213

break

2214

else:

2215

# No currently valid tokens were found

2216

raise ValueError("Invalid RFC 3339 duration")

2217

# End token found

2218

return value

2219

2220

1811

2221

def string_to_delta(interval):

1812

2222

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

1813

2223

1824

2234

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

1825

2235

datetime.timedelta(0, 330)

1826

2236

"""

2237

2238

try:

2239

return rfc3339_duration_to_delta(interval)

2240

except ValueError:

2241

pass

2242

1827

2243

timevalue = datetime.timedelta(0)

1828

2244

for s in interval.split():

1829

2245

try:

1840

2256

elif suffix == "w":

1841

2257

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

1842

2258

else:

1843

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

2259

raise ValueError("Unknown suffix {0!r}"

2260

.format(suffix))

1844

2261

except (ValueError, IndexError) as e:

1845

2262

raise ValueError(*(e.args))

1846

2263

timevalue += delta

1847

2264

return timevalue

1848

2265

1849

2266

1850

def if_nametoindex(interface):

1851

"""Call the C function if_nametoindex(), or equivalent

1852

1853

Note: This function cannot accept a unicode string."""

1854

global if_nametoindex

1855

try:

1856

if_nametoindex = (ctypes.cdll.LoadLibrary

1857

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

1858

.if_nametoindex)

1859

except (OSError, AttributeError):

1860

logger.warning("Doing if_nametoindex the hard way")

1861

def if_nametoindex(interface):

1862

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

1863

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

1864

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

1865

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1866

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

1867

interface))

1868

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

1869

ifreq[16:20])[0]

1870

return interface_index

1871

return if_nametoindex(interface)

1872

1873

1874

2267

def daemon(nochdir = False, noclose = False):

1875

2268

"""See daemon(3). Standard BSD Unix function.

1876

2269

1884

2277

sys.exit()

1885

2278

if not noclose:

1886

2279

# Close all standard open file descriptors

1887

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

2280

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

1888

2281

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

1889

2282

raise OSError(errno.ENODEV,

1890

"%s not a character device"

1891

% os.path.devnull)

2283

"{0} not a character device"

2284

.format(os.devnull))

1892

2285

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

1893

2286

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

1894

2287

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

1903

2296

1904

2297

parser = argparse.ArgumentParser()

1905

2298

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

1906

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

2299

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

1907

2300

help="show version number and exit")

1908

2301

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

1909

2302

help="Bind to interface IF")

1915

2308

help="Run self-test")

1916

2309

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

1917

2310

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

1918

" to terminal")

2311

" to terminal", default=None)

1919

2312

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

1920

2313

help="Debug level for stdout output")

1921

2314

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

1928

2321

" files")

1929

2322

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

1930

2323

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

1931

" system bus interface")

2324

" system bus interface", default=None)

1932

2325

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

1933

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

2326

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

2327

default=None)

1934

2328

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

1935

dest="restore",

1936

help="Do not restore stored state",

1937

default=True)

1938

2329

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

2330

" state", default=None)

2331

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

2332

help="Specify a file descriptor to a network"

2333

" socket to use instead of creating one")

2334

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

2335

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

2336

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

2337

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

2338

1939

2339

options = parser.parse_args()

1940

2340

1941

2341

if options.check:

1949

2349

"port": "",

1950

2350

"debug": "False",

1951

2351

"priority":

1952

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

2352

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

1953

2353

"servicename": "Mandos",

1954

2354

"use_dbus": "True",

1955

2355

"use_ipv6": "True",

1956

2356

"debuglevel": "",

2357

"restore": "True",

2358

"socket": "",

2359

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

2360

"foreground": "False",

1957

2361

}

1958

2362

1959

2363

# Parse config file for server-global settings

1964

2368

# Convert the SafeConfigParser object to a dict

1965

2369

server_settings = server_config.defaults()

1966

2370

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

1967

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

2371

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

1968

2372

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

1969

2373

option)

1970

2374

if server_settings["port"]:

1971

2375

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

1972

2376

"port")

2377

if server_settings["socket"]:

2378

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

2379

"socket")

2380

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

2381

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

2382

# happen with a supplied network socket.

2383

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

2384

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

2385

["socket"])

1973

2386

del server_config

1974

2387

1975

2388

# Override the settings from the config file with command line

1976

2389

# options, if set.

1977

2390

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

1978

2391

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

1979

"use_dbus", "use_ipv6", "debuglevel", "restore"):

2392

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

2393

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

1980

2394

value = getattr(options, option)

1981

2395

if value is not None:

1982

2396

server_settings[option] = value

1985

2399

for option in server_settings.keys():

1986

2400

if type(server_settings[option]) is str:

1987

2401

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

2402

# Force all boolean options to be boolean

2403

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

2404

"foreground"):

2405

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

2406

# Debug implies foreground

2407

if server_settings["debug"]:

2408

server_settings["foreground"] = True

1988

2409

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

1989

2410

1990

2411

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

1994

2415

debuglevel = server_settings["debuglevel"]

1995

2416

use_dbus = server_settings["use_dbus"]

1996

2417

use_ipv6 = server_settings["use_ipv6"]

2418

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

2419

stored_state_file)

2420

foreground = server_settings["foreground"]

2421

2422

if debug:

2423

initlogger(debug, logging.DEBUG)

2424

else:

2425

if not debuglevel:

2426

initlogger(debug)

2427

else:

2428

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

2429

initlogger(debug, level)

1997

2430

1998

2431

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

1999

2432

syslogger.setFormatter(logging.Formatter

2000

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

2001

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

2002

% server_settings["servicename"]))

2433

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

2434

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

2435

.format(server_settings

2436

["servicename"])))

2003

2437

2004

2438

# Parse config file with clients

2005

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

2006

"extended_timeout": "15m",

2007

"interval": "2m",

2008

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

2009

"host": "",

2010

"approval_delay": "0s",

2011

"approval_duration": "1s",

2012

}

2013

client_config = configparser.SafeConfigParser(client_defaults)

2439

client_config = configparser.SafeConfigParser(Client

2440

.client_defaults)

2014

2441

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

2015

2442

"clients.conf"))

2016

2443

2025

2452

use_ipv6=use_ipv6,

2026

2453

gnutls_priority=

2027

2454

server_settings["priority"],

2028

use_dbus=use_dbus)

2029

if not debug:

2030

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

2455

use_dbus=use_dbus,

2456

socketfd=(server_settings["socket"]

2457

or None))

2458

if not foreground:

2459

pidfilename = "/run/mandos.pid"

2460

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

2461

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

2462

pidfile = None

2031

2463

try:

2032

2464

pidfile = open(pidfilename, "w")

2033

except IOError:

2034

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

2465

except IOError as e:

2466

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

2467

exc_info=e)

2035

2468

2036

try:

2037

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

2038

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

2039

except KeyError:

2469

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

2040

2470

try:

2041

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

2042

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

2471

uid = pwd.getpwnam(name).pw_uid

2472

gid = pwd.getpwnam(name).pw_gid

2473

break

2043

2474

except KeyError:

2044

try:

2045

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

2046

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

2047

except KeyError:

2048

uid = 65534

2049

gid = 65534

2475

continue

2476

else:

2477

uid = 65534

2478

gid = 65534

2050

2479

try:

2051

2480

os.setgid(gid)

2052

2481

os.setuid(uid)

2053

2482

except OSError as error:

2054

if error[0] != errno.EPERM:

2483

if error.errno != errno.EPERM:

2055

2484

raise error

2056

2485

2057

if not debug and not debuglevel:

2058

logger.setLevel(logging.WARNING)

2059

if debuglevel:

2060

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

2061

logger.setLevel(level)

2062

2063

2486

if debug:

2064

logger.setLevel(logging.DEBUG)

2065

2487

# Enable all possible GnuTLS debugging

2066

2488

2067

2489

# "Use a log level over 10 to enable all debugging options."

2076

2498

.gnutls_global_set_log_function(debug_gnutls))

2077

2499

2078

2500

# Redirect stdin so all checkers get /dev/null

2079

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

2501

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

2080

2502

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

2081

2503

if null > 2:

2082

2504

os.close(null)

2083

else:

2084

# No console logging

2085

logger.removeHandler(console)

2086

2505

2087

2506

# Need to fork before connecting to D-Bus

2088

if not debug:

2507

if not foreground:

2089

2508

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

2090

2509

daemon()

2091

2510

2511

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

2512

# need to inform gobject that threads will be used.

2513

gobject.threads_init()

2514

2092

2515

global main_loop

2093

2516

# From the Avahi example code

2094

DBusGMainLoop(set_as_default=True )

2517

DBusGMainLoop(set_as_default=True)

2095

2518

main_loop = gobject.MainLoop()

2096

2519

bus = dbus.SystemBus()

2097

2520

# End of Avahi example code

2103

2526

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

2104

2527

do_not_queue=True))

2105

2528

except dbus.exceptions.NameExistsException as e:

2106

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

2529

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

2107

2530

use_dbus = False

2108

2531

server_settings["use_dbus"] = False

2109

2532

tcp_server.use_dbus = False

2121

2544

2122

2545

client_class = Client

2123

2546

if use_dbus:

2124

client_class = functools.partial(ClientDBusTransitional,

2125

bus = bus)

2126

2127

special_settings = {

2128

# Some settings need to be accessd by special methods;

2129

# booleans need .getboolean(), etc. Here is a list of them:

2130

"approved_by_default":

2131

lambda section:

2132

client_config.getboolean(section, "approved_by_default"),

2133

}

2134

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

2135

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

2136

# with exceptions for any special settings as defined above

2137

client_settings = dict((clientname,

2138

dict((setting,

2139

(value if

2140

setting not in special_settings

2141

else special_settings[setting]

2142

(clientname)))

2143

for setting, value

2144

in client_config.items(clientname)))

2145

for clientname in client_config.sections())

2146

2547

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

2548

2549

client_settings = Client.config_parser(client_config)

2147

2550

old_client_settings = {}

2148

clients_data = []

2149

2150

# Get client data and settings from last running state.

2551

clients_data = {}

2552

2553

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

2554

global wnull

2555

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

2556

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

2557

# mode

2558

if debug or not foreground:

2559

wnull.close()

2560

2561

# Get client data and settings from last running state.

2151

2562

if server_settings["restore"]:

2152

2563

try:

2153

2564

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

2154

clients_data, old_client_settings = (

2155

pickle.load(stored_state))

2565

clients_data, old_client_settings = (pickle.load

2566

(stored_state))

2156

2567

os.remove(stored_state_path)

2157

2568

except IOError as e:

2158

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

2159

.format(e))

2160

if e.errno != errno.ENOENT:

2569

if e.errno == errno.ENOENT:

2570

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

2571

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

2572

else:

2573

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

2574

exc_info=e)

2161

2575

raise

2162

2163

for client in clients_data:

2164

client_name = client["name"]

2165

2166

# Decide which value to use after restoring saved state.

2167

# We have three different values: Old config file,

2168

# new config file, and saved state.

2169

# New config value takes precedence if it differs from old

2170

# config value, otherwise use saved state.

2171

for name, value in client_settings[client_name].items():

2576

except EOFError as e:

2577

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

2578

"EOFError:", exc_info=e)

2579

2580

with PGPEngine() as pgp:

2581

for client_name, client in clients_data.iteritems():

2582

# Skip removed clients

2583

if client_name not in client_settings:

2584

continue

2585

2586

# Decide which value to use after restoring saved state.

2587

# We have three different values: Old config file,

2588

# new config file, and saved state.

2589

# New config value takes precedence if it differs from old

2590

# config value, otherwise use saved state.

2591

for name, value in client_settings[client_name].items():

2592

try:

2593

# For each value in new config, check if it

2594

# differs from the old config value (Except for

2595

# the "secret" attribute)

2596

if (name != "secret" and

2597

value != old_client_settings[client_name]

2598

[name]):

2599

client[name] = value

2600

except KeyError:

2601

pass

2602

2603

# Clients who has passed its expire date can still be

2604

# enabled if its last checker was successful. Clients

2605

# whose checker succeeded before we stored its state is

2606

# assumed to have successfully run all checkers during

2607

# downtime.

2608

if client["enabled"]:

2609

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

2610

if not client["last_checked_ok"]:

2611

logger.warning(

2612

"disabling client {0} - Client never "

2613

"performed a successful checker"

2614

.format(client_name))

2615

client["enabled"] = False

2616

elif client["last_checker_status"] != 0:

2617

logger.warning(

2618

"disabling client {0} - Client "

2619

"last checker failed with error code {1}"

2620

.format(client_name,

2621

client["last_checker_status"]))

2622

client["enabled"] = False

2623

else:

2624

client["expires"] = (datetime.datetime

2625

.utcnow()

2626

+ client["timeout"])

2627

logger.debug("Last checker succeeded,"

2628

" keeping {0} enabled"

2629

.format(client_name))

2172

2630

try:

2173

# For each value in new config, check if it differs

2174

# from the old config value (Except for the "secret"

2175

# attribute)

2176

if (name != "secret" and

2177

value != old_client_settings[client_name][name]):

2178

setattr(client, name, value)

2179

except KeyError:

2180

pass

2181

2182

# Clients who has passed its expire date, can still be enabled

2183

# if its last checker was sucessful. Clients who checkers

2184

# failed before we stored it state is asumed to had failed

2185

# checker during downtime.

2186

if client["enabled"] and client["last_checked_ok"]:

2187

if ((datetime.datetime.utcnow()

2188

- client["last_checked_ok"]) > client["interval"]):

2189

if client["last_checker_status"] != 0:

2190

client["enabled"] = False

2191

else:

2192

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

2193

+ client["timeout"])

2194

2195

client["changedstate"] = (multiprocessing_manager

2196

.Condition(multiprocessing_manager

2197

.Lock()))

2198

if use_dbus:

2199

new_client = ClientDBusTransitional.__new__(

2200

ClientDBusTransitional)

2201

tcp_server.clients[client_name] = new_client

2202

new_client.bus = bus

2203

for name, value in client.iteritems():

2204

setattr(new_client, name, value)

2205

new_client._approvals_pending = 0

2206

new_client.add_to_dbus()

2207

else:

2208

tcp_server.clients[client_name] = Client.__new__(Client)

2209

for name, value in client.iteritems():

2210

setattr(tcp_server.clients[client_name], name, value)

2211

2212

tcp_server.clients[client_name].decrypt_secret(

2213

client_settings[client_name]["secret"])

2214

2215

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

2216

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

2217

del tcp_server.clients[clientname]

2218

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

2219

tcp_server.clients[clientname] = client_class(name

2220

= clientname,

2221

config =

2222

client_settings

2223

[clientname])

2631

client["secret"] = (

2632

pgp.decrypt(client["encrypted_secret"],

2633

client_settings[client_name]

2634

["secret"]))

2635

except PGPError:

2636

# If decryption fails, we use secret from new settings

2637

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

2638

.format(client_name))

2639

client["secret"] = (

2640

client_settings[client_name]["secret"])

2641

2642

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

2643

for client_name in (set(old_client_settings)

2644

- set(client_settings)):

2645

del clients_data[client_name]

2646

for client_name in (set(client_settings)

2647

- set(old_client_settings)):

2648

clients_data[client_name] = client_settings[client_name]

2649

2650

# Create all client objects

2651

for client_name, client in clients_data.iteritems():

2652

tcp_server.clients[client_name] = client_class(

2653

name = client_name, settings = client,

2654

server_settings = server_settings)

2224

2655

2225

2656

if not tcp_server.clients:

2226

2657

logger.warning("No clients defined")

2227

2228

if not debug:

2229

try:

2230

with pidfile:

2231

pid = os.getpid()

2232

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

2233

del pidfile

2234

except IOError:

2235

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

2236

pidfilename, pid)

2237

except NameError:

2238

# "pidfile" was never created

2239

pass

2658

2659

if not foreground:

2660

if pidfile is not None:

2661

try:

2662

with pidfile:

2663

pid = os.getpid()

2664

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

2665

except IOError:

2666

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

2667

pidfilename, pid)

2668

del pidfile

2240

2669

del pidfilename

2241

2242

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

2243

2670

2244

2671

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

2245

2672

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

2246

2673

2247

2674

if use_dbus:

2248

class MandosDBusService(dbus.service.Object):

2675

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

2676

"se.bsnet.fukt.Mandos"})

2677

class MandosDBusService(DBusObjectWithProperties):

2249

2678

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

2250

2679

def __init__(self):

2251

2680

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

2252

2681

_interface = "se.recompile.Mandos"

2253

2682

2683

@dbus_interface_annotations(_interface)

2684

def _foo(self):

2685

return { "org.freedesktop.DBus.Property"

2686

".EmitsChangedSignal":

2687

"false"}

2688

2254

2689

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

2255

2690

def ClientAdded(self, objpath):

2256

2691

"D-Bus signal"

2298

2733

2299

2734

del _interface

2300

2735

2301

class MandosDBusServiceTransitional(MandosDBusService):

2302

__metaclass__ = AlternateDBusNamesMetaclass

2303

mandos_dbus_service = MandosDBusServiceTransitional()

2736

mandos_dbus_service = MandosDBusService()

2304

2737

2305

2738

def cleanup():

2306

2739

"Cleanup function; run on exit"

2307

2740

service.cleanup()

2308

2741

2309

2742

multiprocessing.active_children()

2743

wnull.close()

2310

2744

if not (tcp_server.clients or client_settings):

2311

2745

return

2312

2746

2313

2747

# Store client before exiting. Secrets are encrypted with key

2314

2748

# based on what config file has. If config file is

2315

2749

# removed/edited, old secret will thus be unrecovable.

2316

clients = []

2317

for client in tcp_server.clients.itervalues():

2318

client.encrypt_secret(

2319

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

2320

2321

client_dict = {}

2322

2323

# A list of attributes that will not be stored when

2324

# shutting down.

2325

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

2326

for name, typ in inspect.getmembers(dbus.service.Object):

2327

exclude.add(name)

2328

2329

client_dict["encrypted_secret"] = client.encrypted_secret

2330

for attr in client.client_structure:

2331

if attr not in exclude:

2332

client_dict[attr] = getattr(client, attr)

2333

2334

clients.append(client_dict)

2335

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

2336

2750

clients = {}

2751

with PGPEngine() as pgp:

2752

for client in tcp_server.clients.itervalues():

2753

key = client_settings[client.name]["secret"]

2754

client.encrypted_secret = pgp.encrypt(client.secret,

2755

key)

2756

client_dict = {}

2757

2758

# A list of attributes that can not be pickled

2759

# + secret.

2760

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

2761

"checker", "server_settings"))

2762

for name, typ in (inspect.getmembers

2763

(dbus.service.Object)):

2764

exclude.add(name)

2765

2766

client_dict["encrypted_secret"] = (client

2767

.encrypted_secret)

2768

for attr in client.client_structure:

2769

if attr not in exclude:

2770

client_dict[attr] = getattr(client, attr)

2771

2772

clients[client.name] = client_dict

2773

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

2774

2337

2775

try:

2338

with os.fdopen(os.open(stored_state_path,

2339

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

2340

stat.S_IRUSR | stat.S_IWUSR),

2341

"wb") as stored_state:

2776

with (tempfile.NamedTemporaryFile

2777

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

2778

dir=os.path.dirname(stored_state_path),

2779

delete=False)) as stored_state:

2342

2780

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

2343

except IOError as e:

2344

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

2345

.format(e))

2346

if e.errno != errno.ENOENT:

2347

raise

2348

2781

tempname=stored_state.name

2782

os.rename(tempname, stored_state_path)

2783

except (IOError, OSError) as e:

2784

if not debug:

2785

try:

2786

os.remove(tempname)

2787

except NameError:

2788

pass

2789

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

2790

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

2791

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

2792

else:

2793

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

2794

exc_info=e)

2795

raise e

2796

2349

2797

# Delete all clients, and settings from config

2350

2798

while tcp_server.clients:

2351

2799

name, client = tcp_server.clients.popitem()

2369

2817

# Need to initiate checking of clients

2370

2818

if client.enabled:

2371

2819

client.init_checker()

2372

2373

2820

2374

2821

tcp_server.enable()

2375

2822

tcp_server.server_activate()

2378

2825

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

2379

2826

if use_ipv6:

2380

2827

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

2381

" flowinfo %d, scope_id %d"

2382

% tcp_server.socket.getsockname())

2828

" flowinfo %d, scope_id %d",

2829

*tcp_server.socket.getsockname())

2383

2830

else: # IPv4

2384

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

2385

% tcp_server.socket.getsockname())

2831

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

2832

*tcp_server.socket.getsockname())

2386

2833

2387

2834

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

2388

2835

2391

2838

try:

2392

2839

service.activate()

2393

2840

except dbus.exceptions.DBusException as error:

2394

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

2841

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

2395

2842

cleanup()

2396

2843

sys.exit(1)

2397

2844

# End of Avahi example code

2404

2851

logger.debug("Starting main loop")

2405

2852

main_loop.run()

2406

2853

except AvahiError as error:

2407

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

2854

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

2408

2855

cleanup()

2409

2856

sys.exit(1)

2410

2857

except KeyboardInterrupt:

2415

2862

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

2416

2863

cleanup()

2417

2864

2418

2419

2865

if __name__ == '__main__':

2420

2866

main()