/mandos/release : revision 237.7.159

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

82

import GnuPGInterface

78

83

79

84

try:

80

85

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

84

89

except ImportError:

85

90

SO_BINDTODEVICE = None

86

91

87

88

version = "1.4.1"

92

version = "1.6.0"

93

stored_state_file = "clients.pickle"

89

94

90

95

logger = logging.getLogger()

91

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

92

93

96

syslogger = (logging.handlers.SysLogHandler

94

97

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

95

98

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)

99

100

try:

101

if_nametoindex = (ctypes.cdll.LoadLibrary

102

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

103

.if_nametoindex)

104

except (OSError, AttributeError):

105

def if_nametoindex(interface):

106

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

107

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

108

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

109

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

110

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

111

interface))

112

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

113

ifreq[16:20])[0]

114

return interface_index

115

116

117

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

118

"""init logger and add loglevel"""

119

120

syslogger.setFormatter(logging.Formatter

121

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

122

' %(message)s'))

123

logger.addHandler(syslogger)

124

125

if debug:

126

console = logging.StreamHandler()

127

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

128

' [%(process)d]:'

129

' %(levelname)s:'

130

' %(message)s'))

131

logger.addHandler(console)

132

logger.setLevel(level)

133

134

135

class PGPError(Exception):

136

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

137

pass

138

139

140

class PGPEngine(object):

141

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

142

def __init__(self):

143

self.gnupg = GnuPGInterface.GnuPG()

144

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

145

self.gnupg = GnuPGInterface.GnuPG()

146

self.gnupg.options.meta_interactive = False

147

self.gnupg.options.homedir = self.tempdir

148

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

149

'--quiet',

150

'--no-use-agent'])

151

152

def __enter__(self):

153

return self

154

155

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

156

self._cleanup()

157

return False

158

159

def __del__(self):

160

self._cleanup()

161

162

def _cleanup(self):

163

if self.tempdir is not None:

164

# Delete contents of tempdir

165

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

166

topdown = False):

167

for filename in files:

168

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

169

for dirname in dirs:

170

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

171

# Remove tempdir

172

os.rmdir(self.tempdir)

173

self.tempdir = None

174

175

def password_encode(self, password):

176

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

177

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

178

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

179

180

def encrypt(self, data, password):

181

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

182

with open(os.devnull, "w") as devnull:

183

try:

184

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

185

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

186

attach_fhs={'stderr': devnull})

187

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

188

f.write(data)

189

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

190

ciphertext = f.read()

191

proc.wait()

192

except IOError as e:

193

raise PGPError(e)

194

self.gnupg.passphrase = None

195

return ciphertext

196

197

def decrypt(self, data, password):

198

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

199

with open(os.devnull, "w") as devnull:

200

try:

201

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

202

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

203

attach_fhs={'stderr': devnull})

204

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

205

f.write(data)

206

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

207

decrypted_plaintext = f.read()

208

proc.wait()

209

except IOError as e:

210

raise PGPError(e)

211

self.gnupg.passphrase = None

212

return decrypted_plaintext

107

213

108

214

109

215

class AvahiError(Exception):

140

246

server: D-Bus Server

141

247

bus: dbus.SystemBus()

142

248

"""

249

143

250

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

144

251

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

145

252

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

158

265

self.server = None

159

266

self.bus = bus

160

267

self.entry_group_state_changed_match = None

268

161

269

def rename(self):

162

270

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

163

271

if self.rename_count >= self.max_renames:

173

281

try:

174

282

self.add()

175

283

except dbus.exceptions.DBusException as error:

176

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

284

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

177

285

self.cleanup()

178

286

os._exit(1)

179

287

self.rename_count += 1

288

180

289

def remove(self):

181

290

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

182

291

if self.entry_group_state_changed_match is not None:

184

293

self.entry_group_state_changed_match = None

185

294

if self.group is not None:

186

295

self.group.Reset()

296

187

297

def add(self):

188

298

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

189

299

self.remove()

206

316

dbus.UInt16(self.port),

207

317

avahi.string_array_to_txt_array(self.TXT))

208

318

self.group.Commit()

319

209

320

def entry_group_state_changed(self, state, error):

210

321

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

211

322

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

218

329

elif state == avahi.ENTRY_GROUP_FAILURE:

219

330

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

220

331

unicode(error))

221

raise AvahiGroupError("State changed: %s"

222

% unicode(error))

332

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

333

.format(error))

334

223

335

def cleanup(self):

224

336

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

225

337

if self.group is not None:

226

338

try:

227

339

self.group.Free()

228

340

except (dbus.exceptions.UnknownMethodException,

229

dbus.exceptions.DBusException) as e:

341

dbus.exceptions.DBusException):

230

342

pass

231

343

self.group = None

232

344

self.remove()

345

233

346

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

234

347

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

235

348

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

254

367

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

255

368

else:

256

369

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

370

257

371

def activate(self):

258

372

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

259

373

if self.server is None:

266

380

self.server_state_changed)

267

381

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

268

382

383

269

384

class AvahiServiceToSyslog(AvahiService):

270

385

def rename(self):

271

386

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

272

387

ret = AvahiService.rename(self)

273

388

syslogger.setFormatter(logging.Formatter

274

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

275

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

276

% self.name))

389

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

390

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

391

.format(self.name)))

277

392

return ret

278

393

279

def _timedelta_to_milliseconds(td):

394

395

def timedelta_to_milliseconds(td):

280

396

"Convert a datetime.timedelta() to milliseconds"

281

397

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

282

398

+ (td.seconds * 1000)

283

399

+ (td.microseconds // 1000))

284

400

401

285

402

class Client(object):

286

403

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

287

404

288

405

Attributes:

289

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

406

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

290

407

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

291

408

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

292

409

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

311

428

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

312

429

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

313

430

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)

431

status of last checker. -1 reflects crashed

432

checker, -2 means no checker completed yet.

433

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

317

434

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

318

435

D-Bus identifiers

319

436

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

320

437

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

321

438

until this client is disabled

322

extended_timeout: extra long timeout when password has been sent

439

extended_timeout: extra long timeout when secret has been sent

323

440

runtime_expansions: Allowed attributes for runtime expansion.

324

441

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

325

442

disabled, or None

326

443

"""

327

444

328

445

runtime_expansions = ("approval_delay", "approval_duration",

329

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

330

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

446

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

447

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

448

"last_approval_request", "last_checked_ok",

331

449

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

450

client_defaults = { "timeout": "PT5M",

451

"extended_timeout": "PT15M",

452

"interval": "PT2M",

453

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

454

"host": "",

455

"approval_delay": "PT0S",

456

"approval_duration": "PT1S",

457

"approved_by_default": "True",

458

"enabled": "True",

459

}

332

460

333

461

def timeout_milliseconds(self):

334

462

"Return the 'timeout' attribute in milliseconds"

335

return _timedelta_to_milliseconds(self.timeout)

463

return timedelta_to_milliseconds(self.timeout)

336

464

337

465

def extended_timeout_milliseconds(self):

338

466

"Return the 'extended_timeout' attribute in milliseconds"

339

return _timedelta_to_milliseconds(self.extended_timeout)

467

return timedelta_to_milliseconds(self.extended_timeout)

340

468

341

469

def interval_milliseconds(self):

342

470

"Return the 'interval' attribute in milliseconds"

343

return _timedelta_to_milliseconds(self.interval)

471

return timedelta_to_milliseconds(self.interval)

344

472

345

473

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

474

return timedelta_to_milliseconds(self.approval_delay)

475

476

@staticmethod

477

def config_parser(config):

478

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

479

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

480

with exceptions for any special settings as defined above.

481

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

482

value given the same arguments.

483

"""

484

settings = {}

485

for client_name in config.sections():

486

section = dict(config.items(client_name))

487

client = settings[client_name] = {}

488

489

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

490

# Reformat values from string types to Python types

491

client["approved_by_default"] = config.getboolean(

492

client_name, "approved_by_default")

493

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

494

"enabled")

495

496

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

497

.replace(" ", ""))

498

if "secret" in section:

499

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

500

elif "secfile" in section:

501

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

502

(section["secfile"])),

503

"rb") as secfile:

504

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

505

else:

506

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

507

.format(section))

508

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

509

client["extended_timeout"] = string_to_delta(

510

section["extended_timeout"])

511

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

512

client["approval_delay"] = string_to_delta(

513

section["approval_delay"])

514

client["approval_duration"] = string_to_delta(

515

section["approval_duration"])

516

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

517

client["last_approval_request"] = None

518

client["last_checked_ok"] = None

519

client["last_checker_status"] = -2

520

521

return settings

522

523

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

352

524

self.name = name

353

if config is None:

354

config = {}

525

# adding all client settings

526

for setting, value in settings.iteritems():

527

setattr(self, setting, value)

528

529

if self.enabled:

530

if not hasattr(self, "last_enabled"):

531

self.last_enabled = datetime.datetime.utcnow()

532

if not hasattr(self, "expires"):

533

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

534

+ self.timeout)

535

else:

536

self.last_enabled = None

537

self.expires = None

538

355

539

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

356

540

# Uppercase and remove spaces from fingerprint for later

357

541

# comparison purposes with return value from the fingerprint()

358

542

# function

359

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

360

.replace(" ", ""))

361

543

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

544

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

545

datetime.datetime.utcnow())

546

547

# attributes specific for this server instance

383

548

self.checker = None

384

549

self.checker_initiator_tag = None

385

550

self.disable_initiator_tag = None

386

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

387

551

self.checker_callback_tag = None

388

self.checker_command = config["checker"]

389

552

self.current_checker_command = None

390

self._approved = None

391

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

392

True)

553

self.approved = None

393

554

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

555

self.changedstate = (multiprocessing_manager

399

556

.Condition(multiprocessing_manager

400

557

.Lock()))

401

self.client_structure = [attr for attr

402

in self.__dict__.iterkeys()

558

self.client_structure = [attr for attr in

559

self.__dict__.iterkeys()

403

560

if not attr.startswith("_")]

404

561

self.client_structure.append("client_structure")

405

406

562

407

563

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

408

564

lambda obj:

409

565

isinstance(obj,

421

577

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

422

578

# Already enabled

423

579

return

424

self.send_changedstate()

425

580

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

426

581

self.enabled = True

427

582

self.last_enabled = datetime.datetime.utcnow()

428

583

self.init_checker()

584

self.send_changedstate()

429

585

430

586

def disable(self, quiet=True):

431

587

"""Disable this client."""

432

588

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

433

589

return False

434

590

if not quiet:

435

self.send_changedstate()

436

if not quiet:

437

591

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

438

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

592

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

439

593

gobject.source_remove(self.disable_initiator_tag)

440

594

self.disable_initiator_tag = None

441

595

self.expires = None

442

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

596

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

443

597

gobject.source_remove(self.checker_initiator_tag)

444

598

self.checker_initiator_tag = None

445

599

self.stop_checker()

446

600

self.enabled = False

601

if not quiet:

602

self.send_changedstate()

447

603

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

448

604

return False

449

605

450

606

def __del__(self):

451

607

self.disable()

452

608

453

609

def init_checker(self):

454

610

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

455

611

# and every interval from then on.

612

if self.checker_initiator_tag is not None:

613

gobject.source_remove(self.checker_initiator_tag)

456

614

self.checker_initiator_tag = (gobject.timeout_add

457

615

(self.interval_milliseconds(),

458

616

self.start_checker))

459

617

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

618

if self.disable_initiator_tag is not None:

619

gobject.source_remove(self.disable_initiator_tag)

460

620

self.disable_initiator_tag = (gobject.timeout_add

461

621

(self.timeout_milliseconds(),

462

622

self.disable))

463

623

# Also start a new checker *right now*.

464

624

self.start_checker()

465

466

625

467

626

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

468

627

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

469

628

self.checker_callback_tag = None

470

629

self.checker = None

471

630

if os.WIFEXITED(condition):

472

self.last_checker_status = os.WEXITSTATUS(condition)

631

self.last_checker_status = os.WEXITSTATUS(condition)

473

632

if self.last_checker_status == 0:

474

633

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

475

634

vars(self))

482

641

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

483

642

vars(self))

484

643

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

"""

644

def checked_ok(self):

645

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

646

self.last_checked_ok = datetime.datetime.utcnow()

647

self.last_checker_status = 0

648

self.bump_timeout()

649

650

def bump_timeout(self, timeout=None):

651

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

491

652

if timeout is None:

492

653

timeout = self.timeout

493

self.last_checked_ok = datetime.datetime.utcnow()

494

654

if self.disable_initiator_tag is not None:

495

655

gobject.source_remove(self.disable_initiator_tag)

656

self.disable_initiator_tag = None

496

657

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

497

658

self.disable_initiator_tag = (gobject.timeout_add

498

(_timedelta_to_milliseconds

659

(timedelta_to_milliseconds

499

660

(timeout), self.disable))

500

661

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

501

662

508

669

If a checker already exists, leave it running and do

509

670

nothing."""

510

671

# 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

672

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

673

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

674

# would inevitably timeout, since no checker would get a

675

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

515

676

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

516

677

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

517

678

# should be.

531

692

self.current_checker_command)

532

693

# Start a new checker if needed

533

694

if self.checker is None:

695

# Escape attributes for the shell

696

escaped_attrs = dict(

697

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

698

for attr in

699

self.runtime_expansions)

534

700

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

701

command = self.checker_command % escaped_attrs

702

except TypeError as error:

703

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

704

self.checker_command, exc_info=error)

705

return True # Try again later

553

706

self.current_checker_command = command

554

707

try:

555

708

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

561

714

self.checker = subprocess.Popen(command,

562

715

close_fds=True,

563

716

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.

717

except OSError as error:

718

logger.error("Failed to start subprocess",

719

exc_info=error)

720

return True

721

self.checker_callback_tag = (gobject.child_watch_add

722

(self.checker.pid,

723

self.checker_callback,

724

data=command))

725

# The checker may have completed before the gobject

726

# watch was added. Check for this.

727

try:

570

728

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

729

except OSError as error:

575

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

576

error)

730

if error.errno == errno.ECHILD:

731

# This should never happen

732

logger.error("Child process vanished",

733

exc_info=error)

734

return True

735

raise

736

if pid:

737

gobject.source_remove(self.checker_callback_tag)

738

self.checker_callback(pid, status, command)

577

739

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

578

740

return True

579

741

586

748

return

587

749

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

588

750

try:

589

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

751

self.checker.terminate()

590

752

#time.sleep(0.5)

591

753

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

592

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

754

# self.checker.kill()

593

755

except OSError as error:

594

756

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

595

757

raise

596

758

self.checker = None

597

759

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

760

649

761

def dbus_service_property(dbus_interface, signature="v",

650

762

access="readwrite", byte_arrays=False):

662

774

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

663

775

if byte_arrays and signature != "ay":

664

776

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

665

" signature %r" % signature)

777

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

666

778

def decorator(func):

667

779

func._dbus_is_property = True

668

780

func._dbus_interface = dbus_interface

676

788

return decorator

677

789

678

790

791

def dbus_interface_annotations(dbus_interface):

792

"""Decorator for marking functions returning interface annotations

793

794

Usage:

795

796

@dbus_interface_annotations("org.example.Interface")

797

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

798

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

799

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

800

"false"}

801

"""

802

def decorator(func):

803

func._dbus_is_interface = True

804

func._dbus_interface = dbus_interface

805

func._dbus_name = dbus_interface

806

return func

807

return decorator

808

809

810

def dbus_annotations(annotations):

811

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

812

Usage:

813

814

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

815

access="r")

816

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

817

"org.freedesktop.DBus.Property."

818

"EmitsChangedSignal": "false"})

819

def Property_dbus_property(self):

820

return dbus.Boolean(False)

821

"""

822

def decorator(func):

823

func._dbus_annotations = annotations

824

return func

825

return decorator

826

827

679

828

class DBusPropertyException(dbus.exceptions.DBusException):

680

829

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

681

830

"""

704

853

"""

705

854

706

855

@staticmethod

707

def _is_dbus_property(obj):

708

return getattr(obj, "_dbus_is_property", False)

856

def _is_dbus_thing(thing):

857

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

858

859

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

860

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

861

"""

862

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

863

False)

709

864

710

def _get_all_dbus_properties(self):

865

def _get_all_dbus_things(self, thing):

711

866

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

712

867

"""

713

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

868

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

869

name),

870

athing.__get__(self))

714

871

for cls in self.__class__.__mro__

715

for name, prop in

716

inspect.getmembers(cls, self._is_dbus_property))

872

for name, athing in

873

inspect.getmembers(cls,

874

self._is_dbus_thing(thing)))

717

875

718

876

def _get_dbus_property(self, interface_name, property_name):

719

877

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

721

879

"""

722

880

for cls in self.__class__.__mro__:

723

881

for name, value in (inspect.getmembers

724

(cls, self._is_dbus_property)):

882

(cls,

883

self._is_dbus_thing("property"))):

725

884

if (value._dbus_name == property_name

726

885

and value._dbus_interface == interface_name):

727

886

return value.__get__(self)

756

915

# signatures other than "ay".

757

916

if prop._dbus_signature != "ay":

758

917

raise ValueError

759

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

760

for byte in value))

918

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

919

for byte in value))

761

920

prop(value)

762

921

763

922

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

768

927

769

928

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

770

929

"""

771

all = {}

772

for name, prop in self._get_all_dbus_properties():

930

properties = {}

931

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

773

932

if (interface_name

774

933

and interface_name != prop._dbus_interface):

775

934

# Interface non-empty but did not match

779

938

continue

780

939

value = prop()

781

940

if not hasattr(value, "variant_level"):

782

all[name] = value

941

properties[name] = value

783

942

continue

784

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

785

value.variant_level+1)

786

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

943

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

944

value.variant_level+1)

945

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

787

946

788

947

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

789

948

out_signature="s",

790

949

path_keyword='object_path',

791

950

connection_keyword='connection')

792

951

def Introspect(self, object_path, connection):

793

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

952

"""Overloading of standard D-Bus method.

953

954

Inserts property tags and interface annotation tags.

794

955

"""

795

956

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

796

957

connection)

803

964

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

804

965

return e

805

966

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

967

# Add property tags

806

968

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

807

969

for name, prop

808

in self._get_all_dbus_properties()

970

in self._get_all_dbus_things("property")

809

971

if prop._dbus_interface

810

972

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

811

973

if_tag.appendChild(tag)

974

# Add annotation tags

975

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

976

for tag in if_tag.getElementsByTagName(typ):

977

annots = dict()

978

for name, prop in (self.

979

_get_all_dbus_things(typ)):

980

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

981

and prop._dbus_interface

982

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

983

annots.update(getattr

984

(prop,

985

"_dbus_annotations",

986

{}))

987

for name, value in annots.iteritems():

988

ann_tag = document.createElement(

989

"annotation")

990

ann_tag.setAttribute("name", name)

991

ann_tag.setAttribute("value", value)

992

tag.appendChild(ann_tag)

993

# Add interface annotation tags

994

for annotation, value in dict(

995

itertools.chain.from_iterable(

996

annotations().iteritems()

997

for name, annotations in

998

self._get_all_dbus_things("interface")

999

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

1000

)).iteritems():

1001

ann_tag = document.createElement("annotation")

1002

ann_tag.setAttribute("name", annotation)

1003

ann_tag.setAttribute("value", value)

1004

if_tag.appendChild(ann_tag)

812

1005

# Add the names to the return values for the

813

1006

# "org.freedesktop.DBus.Properties" methods

814

1007

if (if_tag.getAttribute("name")

829

1022

except (AttributeError, xml.dom.DOMException,

830

1023

xml.parsers.expat.ExpatError) as error:

831

1024

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

832

error)

1025

exc_info=error)

833

1026

return xmlstring

834

1027

835

1028

836

def datetime_to_dbus (dt, variant_level=0):

1029

def datetime_to_dbus(dt, variant_level=0):

837

1030

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

838

1031

if dt is None:

839

1032

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

840

1033

return dbus.String(dt.isoformat(),

841

1034

variant_level=variant_level)

842

1035

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.

1036

1037

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1038

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

1039

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

1040

interface names according to the "alt_interface_names" mapping.

1041

Usage:

1042

1043

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

1044

"net.example.AlternateInterface"})

1045

class SampleDBusObject(dbus.service.Object):

1046

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

1047

def SampleDBusMethod():

1048

pass

1049

1050

The above "SampleDBusMethod" on "SampleDBusObject" will be

1051

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

1052

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

1053

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

1054

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

1055

1056

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

1057

(from DBusObjectWithProperties) and interfaces (from the

1058

dbus_interface_annotations decorator).

847

1059

"""

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

1060

def wrapper(cls):

1061

for orig_interface_name, alt_interface_name in (

1062

alt_interface_names.iteritems()):

1063

attr = {}

1064

interface_names = set()

1065

# Go though all attributes of the class

1066

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

855

1067

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

856

1068

# with the wrong interface name

857

1069

if (not hasattr(attribute, "_dbus_interface")

858

1070

or not attribute._dbus_interface

859

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

1071

.startswith(orig_interface_name)):

860

1072

continue

861

1073

# Create an alternate D-Bus interface name based on

862

1074

# the current name

863

1075

alt_interface = (attribute._dbus_interface

864

.replace("se.recompile.Mandos",

865

"se.bsnet.fukt.Mandos"))

1076

.replace(orig_interface_name,

1077

alt_interface_name))

1078

interface_names.add(alt_interface)

866

1079

# Is this a D-Bus signal?

867

1080

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

868

1081

# Extract the original non-method function by

883

1096

nonmethod_func.func_name,

884

1097

nonmethod_func.func_defaults,

885

1098

nonmethod_func.func_closure)))

1099

# Copy annotations, if any

1100

try:

1101

new_function._dbus_annotations = (

1102

dict(attribute._dbus_annotations))

1103

except AttributeError:

1104

pass

886

1105

# 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

1106

# original and alternate functions, so both the

1107

# original and alternate signals gets sent when

1108

# the function is called

889

1109

def fixscope(func1, func2):

890

1110

"""This function is a scope container to pass

891

1111

func1 and func2 to the "call_both" function

898

1118

return call_both

899

1119

# Create the "call_both" function and add it to

900

1120

# the class

901

attr[attrname] = fixscope(attribute,

902

new_function)

1121

attr[attrname] = fixscope(attribute, new_function)

903

1122

# Is this a D-Bus method?

904

1123

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

905

1124

# Create a new, but exactly alike, function

916

1135

attribute.func_name,

917

1136

attribute.func_defaults,

918

1137

attribute.func_closure)))

1138

# Copy annotations, if any

1139

try:

1140

attr[attrname]._dbus_annotations = (

1141

dict(attribute._dbus_annotations))

1142

except AttributeError:

1143

pass

919

1144

# Is this a D-Bus property?

920

1145

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

921

1146

# Create a new, but exactly alike, function

935

1160

attribute.func_name,

936

1161

attribute.func_defaults,

937

1162

attribute.func_closure)))

938

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

939

1163

# Copy annotations, if any

1164

try:

1165

attr[attrname]._dbus_annotations = (

1166

dict(attribute._dbus_annotations))

1167

except AttributeError:

1168

pass

1169

# Is this a D-Bus interface?

1170

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

1171

# Create a new, but exactly alike, function

1172

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

1173

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

1174

# to the class.

1175

attr[attrname] = (dbus_interface_annotations

1176

(alt_interface)

1177

(types.FunctionType

1178

(attribute.func_code,

1179

attribute.func_globals,

1180

attribute.func_name,

1181

attribute.func_defaults,

1182

attribute.func_closure)))

1183

if deprecate:

1184

# Deprecate all alternate interfaces

1185

iname="_AlternateDBusNames_interface_annotation{0}"

1186

for interface_name in interface_names:

1187

@dbus_interface_annotations(interface_name)

1188

def func(self):

1189

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

1190

"true" }

1191

# Find an unused name

1192

for aname in (iname.format(i)

1193

for i in itertools.count()):

1194

if aname not in attr:

1195

attr[aname] = func

1196

break

1197

if interface_names:

1198

# Replace the class with a new subclass of it with

1199

# methods, signals, etc. as created above.

1200

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

1201

(cls,), attr)

1202

return cls

1203

return wrapper

1204

1205

1206

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

1207

"se.bsnet.fukt.Mandos"})

940

1208

class ClientDBus(Client, DBusObjectWithProperties):

941

1209

"""A Client class using D-Bus

942

1210

952

1220

953

1221

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

954

1222

self.bus = bus

955

self._approvals_pending = 0

956

1223

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

957

self.add_to_dbus()

958

959

def add_to_dbus(self):

960

1224

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

961

1225

# the D-Bus

962

1226

client_object_name = unicode(self.name).translate(

966

1230

("/clients/" + client_object_name))

967

1231

DBusObjectWithProperties.__init__(self, self.bus,

968

1232

self.dbus_object_path)

969

1233

970

1234

def notifychangeproperty(transform_func,

971

1235

dbus_name, type_func=lambda x: x,

972

1236

variant_level=1):

973

1237

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

974

1238

its changes to DBus.

975

1239

976

1240

transform_fun: Function that takes a value and a variant_level

977

1241

and transforms it to a D-Bus type.

978

1242

dbus_name: D-Bus name of the variable

995

1259

996

1260

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

997

1261

998

999

1262

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1000

1263

approvals_pending = notifychangeproperty(dbus.Boolean,

1001

1264

"ApprovalPending",

1008

1271

checker is not None)

1009

1272

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1010

1273

"LastCheckedOK")

1274

last_checker_status = notifychangeproperty(dbus.Int16,

1275

"LastCheckerStatus")

1011

1276

last_approval_request = notifychangeproperty(

1012

1277

datetime_to_dbus, "LastApprovalRequest")

1013

1278

approved_by_default = notifychangeproperty(dbus.Boolean,

1015

1280

approval_delay = notifychangeproperty(dbus.UInt64,

1016

1281

"ApprovalDelay",

1017

1282

type_func =

1018

_timedelta_to_milliseconds)

1283

timedelta_to_milliseconds)

1019

1284

approval_duration = notifychangeproperty(

1020

1285

dbus.UInt64, "ApprovalDuration",

1021

type_func = _timedelta_to_milliseconds)

1286

type_func = timedelta_to_milliseconds)

1022

1287

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

1023

1288

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

1024

1289

type_func =

1025

_timedelta_to_milliseconds)

1290

timedelta_to_milliseconds)

1026

1291

extended_timeout = notifychangeproperty(

1027

1292

dbus.UInt64, "ExtendedTimeout",

1028

type_func = _timedelta_to_milliseconds)

1293

type_func = timedelta_to_milliseconds)

1029

1294

interval = notifychangeproperty(dbus.UInt64,

1030

1295

"Interval",

1031

1296

type_func =

1032

_timedelta_to_milliseconds)

1297

timedelta_to_milliseconds)

1033

1298

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

1034

1299

1035

1300

del notifychangeproperty

1077

1342

return r

1078

1343

1079

1344

def _reset_approved(self):

1080

self._approved = None

1345

self.approved = None

1081

1346

return False

1082

1347

1083

1348

def approve(self, value=True):

1084

self.send_changedstate()

1085

self._approved = value

1086

gobject.timeout_add(_timedelta_to_milliseconds

1349

self.approved = value

1350

gobject.timeout_add(timedelta_to_milliseconds

1087

1351

(self.approval_duration),

1088

1352

self._reset_approved)

1089

1353

self.send_changedstate()

1090

1354

1091

1355

## D-Bus methods, signals & properties

1092

1356

_interface = "se.recompile.Mandos.Client"

1093

1357

1358

## Interfaces

1359

1360

@dbus_interface_annotations(_interface)

1361

def _foo(self):

1362

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

1363

"false"}

1364

1094

1365

## Signals

1095

1366

1096

1367

# CheckerCompleted - signal

1195

1466

access="readwrite")

1196

1467

def ApprovalDuration_dbus_property(self, value=None):

1197

1468

if value is None: # get

1198

return dbus.UInt64(_timedelta_to_milliseconds(

1469

return dbus.UInt64(timedelta_to_milliseconds(

1199

1470

self.approval_duration))

1200

1471

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

1201

1472

1215

1486

def Host_dbus_property(self, value=None):

1216

1487

if value is None: # get

1217

1488

return dbus.String(self.host)

1218

self.host = value

1489

self.host = unicode(value)

1219

1490

1220

1491

# Created - property

1221

1492

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

1222

1493

def Created_dbus_property(self):

1223

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

1494

return datetime_to_dbus(self.created)

1224

1495

1225

1496

# LastEnabled - property

1226

1497

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

1247

1518

return

1248

1519

return datetime_to_dbus(self.last_checked_ok)

1249

1520

1521

# LastCheckerStatus - property

1522

@dbus_service_property(_interface, signature="n",

1523

access="read")

1524

def LastCheckerStatus_dbus_property(self):

1525

return dbus.Int16(self.last_checker_status)

1526

1250

1527

# Expires - property

1251

1528

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

1252

1529

def Expires_dbus_property(self):

1263

1540

def Timeout_dbus_property(self, value=None):

1264

1541

if value is None: # get

1265

1542

return dbus.UInt64(self.timeout_milliseconds())

1543

old_timeout = self.timeout

1266

1544

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

1545

# Reschedule disabling

1546

if self.enabled:

1547

now = datetime.datetime.utcnow()

1548

self.expires += self.timeout - old_timeout

1549

if self.expires <= now:

1550

# The timeout has passed

1551

self.disable()

1552

else:

1553

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

1554

is None):

1555

return

1556

gobject.source_remove(self.disable_initiator_tag)

1557

self.disable_initiator_tag = (

1558

gobject.timeout_add(

1559

timedelta_to_milliseconds(self.expires - now),

1560

self.disable))

1287

1561

1288

1562

# ExtendedTimeout - property

1289

1563

@dbus_service_property(_interface, signature="t",

1302

1576

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

1303

1577

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

1304

1578

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

1579

if self.enabled:

1580

# Reschedule checker run

1581

gobject.source_remove(self.checker_initiator_tag)

1582

self.checker_initiator_tag = (gobject.timeout_add

1583

(value, self.start_checker))

1584

self.start_checker() # Start one now, too

1310

1585

1311

1586

# Checker - property

1312

1587

@dbus_service_property(_interface, signature="s",

1314

1589

def Checker_dbus_property(self, value=None):

1315

1590

if value is None: # get

1316

1591

return dbus.String(self.checker_command)

1317

self.checker_command = value

1592

self.checker_command = unicode(value)

1318

1593

1319

1594

# CheckerRunning - property

1320

1595

@dbus_service_property(_interface, signature="b",

1349

1624

raise KeyError()

1350

1625

1351

1626

def __getattribute__(self, name):

1352

if(name == '_pipe'):

1627

if name == '_pipe':

1353

1628

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

1354

1629

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

1355

1630

data = self._pipe.recv()

1362

1637

return func

1363

1638

1364

1639

def __setattr__(self, name, value):

1365

if(name == '_pipe'):

1640

if name == '_pipe':

1366

1641

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

1367

1642

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

1368

1643

1369

class ClientDBusTransitional(ClientDBus):

1370

__metaclass__ = AlternateDBusNamesMetaclass

1371

1644

1372

1645

class ClientHandler(socketserver.BaseRequestHandler, object):

1373

1646

"""A class to handle client connections.

1456

1729

client.Rejected("Disabled")

1457

1730

return

1458

1731

1459

if client._approved or not client.approval_delay:

1732

if client.approved or not client.approval_delay:

1460

1733

#We are approved or approval is disabled

1461

1734

break

1462

elif client._approved is None:

1735

elif client.approved is None:

1463

1736

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

1464

1737

client.name)

1465

1738

if self.server.use_dbus:

1478

1751

#wait until timeout or approved

1479

1752

time = datetime.datetime.now()

1480

1753

client.changedstate.acquire()

1481

(client.changedstate.wait

1482

(float(client._timedelta_to_milliseconds(delay)

1483

/ 1000)))

1754

client.changedstate.wait(

1755

float(timedelta_to_milliseconds(delay)

1756

/ 1000))

1484

1757

client.changedstate.release()

1485

1758

time2 = datetime.datetime.now()

1486

1759

if (time2 - time) >= delay:

1502

1775

try:

1503

1776

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

1504

1777

except gnutls.errors.GNUTLSError as error:

1505

logger.warning("gnutls send failed")

1778

logger.warning("gnutls send failed",

1779

exc_info=error)

1506

1780

return

1507

1781

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

1508

1782

sent, len(client.secret)

1511

1785

1512

1786

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

1513

1787

# bump the timeout using extended_timeout

1514

client.checked_ok(client.extended_timeout)

1788

client.bump_timeout(client.extended_timeout)

1515

1789

if self.server.use_dbus:

1516

1790

# Emit D-Bus signal

1517

1791

client.GotSecret()

1522

1796

try:

1523

1797

session.bye()

1524

1798

except gnutls.errors.GNUTLSError as error:

1525

logger.warning("GnuTLS bye failed")

1799

logger.warning("GnuTLS bye failed",

1800

exc_info=error)

1526

1801

1527

1802

@staticmethod

1528

1803

def peer_certificate(session):

1584

1859

# Convert the buffer to a Python bytestring

1585

1860

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

1586

1861

# Convert the bytestring to hexadecimal notation

1587

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

1862

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

1588

1863

return hex_fpr

1589

1864

1590

1865

1593

1868

def sub_process_main(self, request, address):

1594

1869

try:

1595

1870

self.finish_request(request, address)

1596

except:

1871

except Exception:

1597

1872

self.handle_error(request, address)

1598

1873

self.close_request(request)

1599

1874

1600

1875

def process_request(self, request, address):

1601

1876

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

1602

1877

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

1603

args = (request,

1604

address))

1878

args = (request, address))

1605

1879

proc.start()

1606

1880

return proc

1607

1881

1635

1909

use_ipv6: Boolean; to use IPv6 or not

1636

1910

"""

1637

1911

def __init__(self, server_address, RequestHandlerClass,

1638

interface=None, use_ipv6=True):

1912

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

1913

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

1914

creating a new one with socket.socket().

1915

"""

1639

1916

self.interface = interface

1640

1917

if use_ipv6:

1641

1918

self.address_family = socket.AF_INET6

1919

if socketfd is not None:

1920

# Save the file descriptor

1921

self.socketfd = socketfd

1922

# Save the original socket.socket() function

1923

self.socket_socket = socket.socket

1924

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

1925

#

1926

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

1927

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

1928

# patching socket.socket.)

1929

#

1930

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

1931

@functools.wraps(socket.socket)

1932

def socket_wrapper(*args, **kwargs):

1933

# Restore original function so subsequent calls are

1934

# not affected.

1935

socket.socket = self.socket_socket

1936

del self.socket_socket

1937

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

1938

# saved file descriptor.

1939

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

1940

# Replace socket.socket() function with wrapper

1941

socket.socket = socket_wrapper

1942

# The socketserver.TCPServer.__init__ will call

1943

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

1944

# socket_wrapper(), if socketfd was set.

1642

1945

socketserver.TCPServer.__init__(self, server_address,

1643

1946

RequestHandlerClass)

1947

1644

1948

def server_bind(self):

1645

1949

"""This overrides the normal server_bind() function

1646

1950

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

1654

1958

try:

1655

1959

self.socket.setsockopt(socket.SOL_SOCKET,

1656

1960

SO_BINDTODEVICE,

1657

str(self.interface

1658

+ '\0'))

1961

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

1659

1962

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:

1963

if error.errno == errno.EPERM:

1964

logger.error("No permission to bind to"

1965

" interface %s", self.interface)

1966

elif error.errno == errno.ENOPROTOOPT:

1665

1967

logger.error("SO_BINDTODEVICE not available;"

1666

1968

" cannot bind to interface %s",

1667

1969

self.interface)

1970

elif error.errno == errno.ENODEV:

1971

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

1972

" cannot bind", self.interface)

1668

1973

else:

1669

1974

raise

1670

1975

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

1700

2005

"""

1701

2006

def __init__(self, server_address, RequestHandlerClass,

1702

2007

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

1703

gnutls_priority=None, use_dbus=True):

2008

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

1704

2009

self.enabled = False

1705

2010

self.clients = clients

1706

2011

if self.clients is None:

1710

2015

IPv6_TCPServer.__init__(self, server_address,

1711

2016

RequestHandlerClass,

1712

2017

interface = interface,

1713

use_ipv6 = use_ipv6)

2018

use_ipv6 = use_ipv6,

2019

socketfd = socketfd)

1714

2020

def server_activate(self):

1715

2021

if self.enabled:

1716

2022

return socketserver.TCPServer.server_activate(self)

1729

2035

1730

2036

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

1731

2037

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

2038

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

1747

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

2039

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

1748

2040

# Wait for other process to exit

1749

2041

proc.join()

1750

2042

return False

1808

2100

return True

1809

2101

1810

2102

2103

def rfc3339_duration_to_delta(duration):

2104

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

2105

2106

>>> rfc3339_duration_to_delta("P7D")

2107

datetime.timedelta(7)

2108

>>> rfc3339_duration_to_delta("PT60S")

2109

datetime.timedelta(0, 60)

2110

>>> rfc3339_duration_to_delta("PT60M")

2111

datetime.timedelta(0, 3600)

2112

>>> rfc3339_duration_to_delta("PT24H")

2113

datetime.timedelta(1)

2114

>>> rfc3339_duration_to_delta("P1W")

2115

datetime.timedelta(7)

2116

>>> rfc3339_duration_to_delta("PT5M30S")

2117

datetime.timedelta(0, 330)

2118

>>> rfc3339_duration_to_delta("P1DT3M20S")

2119

datetime.timedelta(1, 200)

2120

"""

2121

2122

# Parsing an RFC 3339 duration with regular expressions is not

2123

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

2124

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

2125

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

2126

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

2127

# avoid excessive use of external libraries.

2128

2129

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

2130

Token = collections.namedtuple("Token",

2131

("regexp", # To match token; if

2132

# "value" is not None,

2133

# must have a "group"

2134

# containing digits

2135

"value", # datetime.timedelta or

2136

# None

2137

"followers")) # Tokens valid after

2138

# this token

2139

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

2140

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

2141

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

2142

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

2143

datetime.timedelta(seconds=1),

2144

frozenset((token_end,)))

2145

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

2146

datetime.timedelta(minutes=1),

2147

frozenset((token_second, token_end)))

2148

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

2149

datetime.timedelta(hours=1),

2150

frozenset((token_minute, token_end)))

2151

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

2152

None,

2153

frozenset((token_hour, token_minute,

2154

token_second)))

2155

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

2156

datetime.timedelta(days=1),

2157

frozenset((token_time, token_end)))

2158

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

2159

datetime.timedelta(weeks=4),

2160

frozenset((token_day, token_end)))

2161

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

2162

datetime.timedelta(weeks=52),

2163

frozenset((token_month, token_end)))

2164

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

2165

datetime.timedelta(weeks=1),

2166

frozenset((token_end,)))

2167

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

2168

frozenset((token_year, token_month,

2169

token_day, token_time,

2170

token_week))),

2171

# Define starting values

2172

value = datetime.timedelta() # Value so far

2173

found_token = None

2174

followers = frozenset(token_duration,) # Following valid tokens

2175

s = duration # String left to parse

2176

# Loop until end token is found

2177

while found_token is not token_end:

2178

# Search for any currently valid tokens

2179

for token in followers:

2180

match = token.regexp.match(s)

2181

if match is not None:

2182

# Token found

2183

if token.value is not None:

2184

# Value found, parse digits

2185

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

2186

# Add to value so far

2187

value += factor * token.value

2188

# Strip token from string

2189

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

2190

# Go to found token

2191

found_token = token

2192

# Set valid next tokens

2193

followers = found_token.followers

2194

break

2195

else:

2196

# No currently valid tokens were found

2197

raise ValueError("Invalid RFC 3339 duration")

2198

# End token found

2199

return value

2200

2201

1811

2202

def string_to_delta(interval):

1812

2203

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

1813

2204

1824

2215

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

1825

2216

datetime.timedelta(0, 330)

1826

2217

"""

2218

2219

try:

2220

return rfc3339_duration_to_delta(interval)

2221

except ValueError:

2222

pass

2223

1827

2224

timevalue = datetime.timedelta(0)

1828

2225

for s in interval.split():

1829

2226

try:

1840

2237

elif suffix == "w":

1841

2238

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

1842

2239

else:

1843

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

2240

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

2241

.format(suffix))

1844

2242

except (ValueError, IndexError) as e:

1845

2243

raise ValueError(*(e.args))

1846

2244

timevalue += delta

1847

2245

return timevalue

1848

2246

1849

2247

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

2248

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

1875

2249

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

1876

2250

1884

2258

sys.exit()

1885

2259

if not noclose:

1886

2260

# Close all standard open file descriptors

1887

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

2261

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

1888

2262

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

1889

2263

raise OSError(errno.ENODEV,

1890

"%s not a character device"

1891

% os.path.devnull)

2264

"{0} not a character device"

2265

.format(os.devnull))

1892

2266

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

1893

2267

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

1894

2268

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

1903

2277

1904

2278

parser = argparse.ArgumentParser()

1905

2279

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

1906

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

2280

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

1907

2281

help="show version number and exit")

1908

2282

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

1909

2283

help="Bind to interface IF")

1932

2306

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

1933

2307

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

1934

2308

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

1935

dest="restore",

1936

help="Do not restore stored state",

1937

default=True)

1938

2309

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

2310

" state")

2311

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

2312

help="Specify a file descriptor to a network"

2313

" socket to use instead of creating one")

2314

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

2315

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

2316

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

2317

help="Run in foreground")

2318

1939

2319

options = parser.parse_args()

1940

2320

1941

2321

if options.check:

1954

2334

"use_dbus": "True",

1955

2335

"use_ipv6": "True",

1956

2336

"debuglevel": "",

2337

"restore": "True",

2338

"socket": "",

2339

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

2340

"foreground": "False",

1957

2341

}

1958

2342

1959

2343

# Parse config file for server-global settings

1964

2348

# Convert the SafeConfigParser object to a dict

1965

2349

server_settings = server_config.defaults()

1966

2350

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

1967

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

2351

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

1968

2352

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

1969

2353

option)

1970

2354

if server_settings["port"]:

1971

2355

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

1972

2356

"port")

2357

if server_settings["socket"]:

2358

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

2359

"socket")

2360

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

2361

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

2362

# happen with a supplied network socket.

2363

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

2364

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

2365

["socket"])

1973

2366

del server_config

1974

2367

1975

2368

# Override the settings from the config file with command line

1976

2369

# options, if set.

1977

2370

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

1978

2371

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

1979

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

2372

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

2373

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

1980

2374

value = getattr(options, option)

1981

2375

if value is not None:

1982

2376

server_settings[option] = value

1985

2379

for option in server_settings.keys():

1986

2380

if type(server_settings[option]) is str:

1987

2381

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

2382

# Debug implies foreground

2383

if server_settings["debug"]:

2384

server_settings["foreground"] = True

1988

2385

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

1989

2386

1990

2387

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

1994

2391

debuglevel = server_settings["debuglevel"]

1995

2392

use_dbus = server_settings["use_dbus"]

1996

2393

use_ipv6 = server_settings["use_ipv6"]

2394

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

2395

stored_state_file)

2396

foreground = server_settings["foreground"]

2397

2398

if debug:

2399

initlogger(debug, logging.DEBUG)

2400

else:

2401

if not debuglevel:

2402

initlogger(debug)

2403

else:

2404

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

2405

initlogger(debug, level)

1997

2406

1998

2407

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

1999

2408

syslogger.setFormatter(logging.Formatter

2000

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

2001

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

2002

% server_settings["servicename"]))

2409

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

2410

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

2411

.format(server_settings

2412

["servicename"])))

2003

2413

2004

2414

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

2415

client_config = configparser.SafeConfigParser(Client

2416

.client_defaults)

2014

2417

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

2015

2418

"clients.conf"))

2016

2419

2025

2428

use_ipv6=use_ipv6,

2026

2429

gnutls_priority=

2027

2430

server_settings["priority"],

2028

use_dbus=use_dbus)

2029

if not debug:

2431

use_dbus=use_dbus,

2432

socketfd=(server_settings["socket"]

2433

or None))

2434

if not foreground:

2030

2435

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

2436

pidfile = None

2031

2437

try:

2032

2438

pidfile = open(pidfilename, "w")

2033

except IOError:

2034

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

2439

except IOError as e:

2440

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

2441

exc_info=e)

2035

2442

2036

try:

2037

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

2038

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

2039

except KeyError:

2443

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

2040

2444

try:

2041

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

2042

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

2445

uid = pwd.getpwnam(name).pw_uid

2446

gid = pwd.getpwnam(name).pw_gid

2447

break

2043

2448

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

2449

continue

2450

else:

2451

uid = 65534

2452

gid = 65534

2050

2453

try:

2051

2454

os.setgid(gid)

2052

2455

os.setuid(uid)

2053

2456

except OSError as error:

2054

if error[0] != errno.EPERM:

2457

if error.errno != errno.EPERM:

2055

2458

raise error

2056

2459

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

2460

if debug:

2064

logger.setLevel(logging.DEBUG)

2065

2461

# Enable all possible GnuTLS debugging

2066

2462

2067

2463

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

2076

2472

.gnutls_global_set_log_function(debug_gnutls))

2077

2473

2078

2474

# Redirect stdin so all checkers get /dev/null

2079

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

2475

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

2080

2476

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

2081

2477

if null > 2:

2082

2478

os.close(null)

2083

else:

2084

# No console logging

2085

logger.removeHandler(console)

2086

2479

2087

2480

# Need to fork before connecting to D-Bus

2088

if not debug:

2481

if not foreground:

2089

2482

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

2090

2483

daemon()

2091

2484

2485

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

2486

# need to inform gobject that threads will be used.

2487

gobject.threads_init()

2488

2092

2489

global main_loop

2093

2490

# From the Avahi example code

2094

DBusGMainLoop(set_as_default=True )

2491

DBusGMainLoop(set_as_default=True)

2095

2492

main_loop = gobject.MainLoop()

2096

2493

bus = dbus.SystemBus()

2097

2494

# End of Avahi example code

2103

2500

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

2104

2501

do_not_queue=True))

2105

2502

except dbus.exceptions.NameExistsException as e:

2106

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

2503

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

2107

2504

use_dbus = False

2108

2505

server_settings["use_dbus"] = False

2109

2506

tcp_server.use_dbus = False

2121

2518

2122

2519

client_class = Client

2123

2520

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

2521

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

2522

2523

client_settings = Client.config_parser(client_config)

2147

2524

old_client_settings = {}

2148

clients_data = []

2149

2150

# Get client data and settings from last running state.

2525

clients_data = {}

2526

2527

# Get client data and settings from last running state.

2151

2528

if server_settings["restore"]:

2152

2529

try:

2153

2530

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

2154

clients_data, old_client_settings = (

2155

pickle.load(stored_state))

2531

clients_data, old_client_settings = (pickle.load

2532

(stored_state))

2156

2533

os.remove(stored_state_path)

2157

2534

except IOError as e:

2158

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

2159

.format(e))

2160

if e.errno != errno.ENOENT:

2535

if e.errno == errno.ENOENT:

2536

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

2537

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

2538

else:

2539

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

2540

exc_info=e)

2161

2541

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

2542

except EOFError as e:

2543

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

2544

"EOFError:", exc_info=e)

2545

2546

with PGPEngine() as pgp:

2547

for client_name, client in clients_data.iteritems():

2548

# Decide which value to use after restoring saved state.

2549

# We have three different values: Old config file,

2550

# new config file, and saved state.

2551

# New config value takes precedence if it differs from old

2552

# config value, otherwise use saved state.

2553

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

2554

try:

2555

# For each value in new config, check if it

2556

# differs from the old config value (Except for

2557

# the "secret" attribute)

2558

if (name != "secret" and

2559

value != old_client_settings[client_name]

2560

[name]):

2561

client[name] = value

2562

except KeyError:

2563

pass

2564

2565

# Clients who has passed its expire date can still be

2566

# enabled if its last checker was successful. Clients

2567

# whose checker succeeded before we stored its state is

2568

# assumed to have successfully run all checkers during

2569

# downtime.

2570

if client["enabled"]:

2571

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

2572

if not client["last_checked_ok"]:

2573

logger.warning(

2574

"disabling client {0} - Client never "

2575

"performed a successful checker"

2576

.format(client_name))

2577

client["enabled"] = False

2578

elif client["last_checker_status"] != 0:

2579

logger.warning(

2580

"disabling client {0} - Client "

2581

"last checker failed with error code {1}"

2582

.format(client_name,

2583

client["last_checker_status"]))

2584

client["enabled"] = False

2585

else:

2586

client["expires"] = (datetime.datetime

2587

.utcnow()

2588

+ client["timeout"])

2589

logger.debug("Last checker succeeded,"

2590

" keeping {0} enabled"

2591

.format(client_name))

2172

2592

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

2593

client["secret"] = (

2594

pgp.decrypt(client["encrypted_secret"],

2595

client_settings[client_name]

2596

["secret"]))

2597

except PGPError:

2598

# If decryption fails, we use secret from new settings

2599

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

2600

.format(client_name))

2601

client["secret"] = (

2602

client_settings[client_name]["secret"])

2603

2604

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

2605

for client_name in (set(old_client_settings)

2606

- set(client_settings)):

2607

del clients_data[client_name]

2608

for client_name in (set(client_settings)

2609

- set(old_client_settings)):

2610

clients_data[client_name] = client_settings[client_name]

2611

2612

# Create all client objects

2613

for client_name, client in clients_data.iteritems():

2614

tcp_server.clients[client_name] = client_class(

2615

name = client_name, settings = client)

2224

2616

2225

2617

if not tcp_server.clients:

2226

2618

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

2619

2620

if not foreground:

2621

if pidfile is not None:

2622

try:

2623

with pidfile:

2624

pid = os.getpid()

2625

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

2626

except IOError:

2627

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

2628

pidfilename, pid)

2629

del pidfile

2240

2630

del pidfilename

2241

2242

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

2243

2631

2244

2632

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

2245

2633

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

2246

2634

2247

2635

if use_dbus:

2248

class MandosDBusService(dbus.service.Object):

2636

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

2637

"se.bsnet.fukt.Mandos"})

2638

class MandosDBusService(DBusObjectWithProperties):

2249

2639

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

2250

2640

def __init__(self):

2251

2641

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

2252

2642

_interface = "se.recompile.Mandos"

2253

2643

2644

@dbus_interface_annotations(_interface)

2645

def _foo(self):

2646

return { "org.freedesktop.DBus.Property"

2647

".EmitsChangedSignal":

2648

"false"}

2649

2254

2650

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

2255

2651

def ClientAdded(self, objpath):

2256

2652

"D-Bus signal"

2298

2694

2299

2695

del _interface

2300

2696

2301

class MandosDBusServiceTransitional(MandosDBusService):

2302

__metaclass__ = AlternateDBusNamesMetaclass

2303

mandos_dbus_service = MandosDBusServiceTransitional()

2697

mandos_dbus_service = MandosDBusService()

2304

2698

2305

2699

def cleanup():

2306

2700

"Cleanup function; run on exit"

2309

2703

multiprocessing.active_children()

2310

2704

if not (tcp_server.clients or client_settings):

2311

2705

return

2312

2706

2313

2707

# Store client before exiting. Secrets are encrypted with key

2314

2708

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

2315

2709

# 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

2710

clients = {}

2711

with PGPEngine() as pgp:

2712

for client in tcp_server.clients.itervalues():

2713

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

2714

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

2715

key)

2716

client_dict = {}

2717

2718

# A list of attributes that can not be pickled

2719

# + secret.

2720

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

2721

"checker"))

2722

for name, typ in (inspect.getmembers

2723

(dbus.service.Object)):

2724

exclude.add(name)

2725

2726

client_dict["encrypted_secret"] = (client

2727

.encrypted_secret)

2728

for attr in client.client_structure:

2729

if attr not in exclude:

2730

client_dict[attr] = getattr(client, attr)

2731

2732

clients[client.name] = client_dict

2733

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

2734

2337

2735

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:

2736

with (tempfile.NamedTemporaryFile

2737

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

2738

dir=os.path.dirname(stored_state_path),

2739

delete=False)) as stored_state:

2342

2740

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

2741

tempname=stored_state.name

2742

os.rename(tempname, stored_state_path)

2743

except (IOError, OSError) as e:

2744

if not debug:

2745

try:

2746

os.remove(tempname)

2747

except NameError:

2748

pass

2749

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

2750

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

2751

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

2752

else:

2753

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

2754

exc_info=e)

2755

raise e

2756

2349

2757

# Delete all clients, and settings from config

2350

2758

while tcp_server.clients:

2351

2759

name, client = tcp_server.clients.popitem()

2369

2777

# Need to initiate checking of clients

2370

2778

if client.enabled:

2371

2779

client.init_checker()

2372

2373

2780

2374

2781

tcp_server.enable()

2375

2782

tcp_server.server_activate()

2378

2785

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

2379

2786

if use_ipv6:

2380

2787

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

2381

" flowinfo %d, scope_id %d"

2382

% tcp_server.socket.getsockname())

2788

" flowinfo %d, scope_id %d",

2789

*tcp_server.socket.getsockname())

2383

2790

else: # IPv4

2384

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

2385

% tcp_server.socket.getsockname())

2791

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

2792

*tcp_server.socket.getsockname())

2386

2793

2387

2794

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

2388

2795

2391

2798

try:

2392

2799

service.activate()

2393

2800

except dbus.exceptions.DBusException as error:

2394

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

2801

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

2395

2802

cleanup()

2396

2803

sys.exit(1)

2397

2804

# End of Avahi example code

2404

2811

logger.debug("Starting main loop")

2405

2812

main_loop.run()

2406

2813

except AvahiError as error:

2407

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

2814

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

2408

2815

cleanup()

2409

2816

sys.exit(1)

2410

2817

except KeyboardInterrupt:

2415

2822

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

2416

2823

cleanup()

2417

2824

2418

2419

2825

if __name__ == '__main__':

2420

2826

main()