/mandos/trunk : revision 713

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

92

stored_state_file = "clients.pickle"

89

93

90

94

logger = logging.getLogger()

91

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

92

93

syslogger = (logging.handlers.SysLogHandler

94

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

95

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)

95

syslogger = None

96

97

try:

98

if_nametoindex = (ctypes.cdll.LoadLibrary

99

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

100

.if_nametoindex)

101

except (OSError, AttributeError):

102

def if_nametoindex(interface):

103

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

104

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

105

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

106

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

107

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

108

interface))

109

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

110

ifreq[16:20])[0]

111

return interface_index

112

113

114

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

115

"""init logger and add loglevel"""

116

117

global syslogger

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

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

122

syslogger.setFormatter(logging.Formatter

123

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

124

' %(message)s'))

125

logger.addHandler(syslogger)

126

127

if debug:

128

console = logging.StreamHandler()

129

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

130

' [%(process)d]:'

131

' %(levelname)s:'

132

' %(message)s'))

133

logger.addHandler(console)

134

logger.setLevel(level)

135

136

137

class PGPError(Exception):

138

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

139

pass

140

141

142

class PGPEngine(object):

143

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

144

def __init__(self):

145

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

146

self.gnupgargs = ['--batch',

147

'--home', self.tempdir,

148

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

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

179

if len(encoded) > 2048:

180

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

181

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

182

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

183

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

184

return encoded

185

186

def encrypt(self, data, password):

187

passphrase = self.password_encode(password)

188

with tempfile.NamedTemporaryFile(dir=self.tempdir

189

) as passfile:

190

passfile.write(passphrase)

191

passfile.flush()

192

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

193

'--passphrase-file',

194

passfile.name]

195

+ self.gnupgargs,

196

stdin = subprocess.PIPE,

197

stdout = subprocess.PIPE,

198

stderr = subprocess.PIPE)

199

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

200

if proc.returncode != 0:

201

raise PGPError(err)

202

return ciphertext

203

204

def decrypt(self, data, password):

205

passphrase = self.password_encode(password)

206

with tempfile.NamedTemporaryFile(dir = self.tempdir

207

) as passfile:

208

passfile.write(passphrase)

209

passfile.flush()

210

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

211

'--passphrase-file',

212

passfile.name]

213

+ self.gnupgargs,

214

stdin = subprocess.PIPE,

215

stdout = subprocess.PIPE,

216

stderr = subprocess.PIPE)

217

decrypted_plaintext, err = proc.communicate(input

218

= data)

219

if proc.returncode != 0:

220

raise PGPError(err)

221

return decrypted_plaintext

107

222

108

223

109

224

class AvahiError(Exception):

128

243

Used to optionally bind to the specified interface.

129

244

name: string; Example: 'Mandos'

130

245

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

131

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

246

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

132

247

port: integer; what port to announce

133

248

TXT: list of strings; TXT record for the service

134

249

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

140

255

server: D-Bus Server

141

256

bus: dbus.SystemBus()

142

257

"""

258

143

259

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

144

260

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

145

261

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

158

274

self.server = None

159

275

self.bus = bus

160

276

self.entry_group_state_changed_match = None

277

161

278

def rename(self):

162

279

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

163

280

if self.rename_count >= self.max_renames:

173

290

try:

174

291

self.add()

175

292

except dbus.exceptions.DBusException as error:

176

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

293

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

177

294

self.cleanup()

178

295

os._exit(1)

179

296

self.rename_count += 1

297

180

298

def remove(self):

181

299

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

182

300

if self.entry_group_state_changed_match is not None:

184

302

self.entry_group_state_changed_match = None

185

303

if self.group is not None:

186

304

self.group.Reset()

305

187

306

def add(self):

188

307

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

189

308

self.remove()

206

325

dbus.UInt16(self.port),

207

326

avahi.string_array_to_txt_array(self.TXT))

208

327

self.group.Commit()

328

209

329

def entry_group_state_changed(self, state, error):

210

330

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

211

331

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

218

338

elif state == avahi.ENTRY_GROUP_FAILURE:

219

339

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

220

340

unicode(error))

221

raise AvahiGroupError("State changed: %s"

222

% unicode(error))

341

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

342

.format(error))

343

223

344

def cleanup(self):

224

345

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

225

346

if self.group is not None:

226

347

try:

227

348

self.group.Free()

228

349

except (dbus.exceptions.UnknownMethodException,

229

dbus.exceptions.DBusException) as e:

350

dbus.exceptions.DBusException):

230

351

pass

231

352

self.group = None

232

353

self.remove()

354

233

355

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

234

356

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

235

357

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

254

376

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

255

377

else:

256

378

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

379

257

380

def activate(self):

258

381

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

259

382

if self.server is None:

266

389

self.server_state_changed)

267

390

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

268

391

392

269

393

class AvahiServiceToSyslog(AvahiService):

270

394

def rename(self):

271

395

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

272

396

ret = AvahiService.rename(self)

273

397

syslogger.setFormatter(logging.Formatter

274

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

275

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

276

% self.name))

398

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

399

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

400

.format(self.name)))

277

401

return ret

278

402

279

def _timedelta_to_milliseconds(td):

403

404

def timedelta_to_milliseconds(td):

280

405

"Convert a datetime.timedelta() to milliseconds"

281

406

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

282

407

+ (td.seconds * 1000)

283

408

+ (td.microseconds // 1000))

284

409

410

285

411

class Client(object):

286

412

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

287

413

288

414

Attributes:

289

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

415

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

290

416

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

291

417

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

292

418

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

310

436

interval: datetime.timedelta(); How often to start a new checker

311

437

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

312

438

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

313

last_checker_status: integer between 0 and 255 reflecting exit status

314

of last checker. -1 reflect crashed checker,

315

or None.

316

last_enabled: datetime.datetime(); (UTC)

439

last_checker_status: integer between 0 and 255 reflecting exit

440

status of last checker. -1 reflects crashed

441

checker, -2 means no checker completed yet.

442

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

317

443

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

318

444

D-Bus identifiers

319

445

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

320

446

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

321

447

until this client is disabled

322

extended_timeout: extra long timeout when password has been sent

448

extended_timeout: extra long timeout when secret has been sent

323

449

runtime_expansions: Allowed attributes for runtime expansion.

324

450

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

325

451

disabled, or None

452

server_settings: The server_settings dict from main()

326

453

"""

327

454

328

455

runtime_expansions = ("approval_delay", "approval_duration",

329

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

330

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

456

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

457

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

458

"last_approval_request", "last_checked_ok",

331

459

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

460

client_defaults = { "timeout": "PT5M",

461

"extended_timeout": "PT15M",

462

"interval": "PT2M",

463

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

464

"host": "",

465

"approval_delay": "PT0S",

466

"approval_duration": "PT1S",

467

"approved_by_default": "True",

468

"enabled": "True",

469

}

332

470

333

471

def timeout_milliseconds(self):

334

472

"Return the 'timeout' attribute in milliseconds"

335

return _timedelta_to_milliseconds(self.timeout)

473

return timedelta_to_milliseconds(self.timeout)

336

474

337

475

def extended_timeout_milliseconds(self):

338

476

"Return the 'extended_timeout' attribute in milliseconds"

339

return _timedelta_to_milliseconds(self.extended_timeout)

477

return timedelta_to_milliseconds(self.extended_timeout)

340

478

341

479

def interval_milliseconds(self):

342

480

"Return the 'interval' attribute in milliseconds"

343

return _timedelta_to_milliseconds(self.interval)

481

return timedelta_to_milliseconds(self.interval)

344

482

345

483

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

484

return timedelta_to_milliseconds(self.approval_delay)

485

486

@staticmethod

487

def config_parser(config):

488

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

489

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

490

with exceptions for any special settings as defined above.

491

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

492

value given the same arguments.

493

"""

494

settings = {}

495

for client_name in config.sections():

496

section = dict(config.items(client_name))

497

client = settings[client_name] = {}

498

499

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

500

# Reformat values from string types to Python types

501

client["approved_by_default"] = config.getboolean(

502

client_name, "approved_by_default")

503

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

504

"enabled")

505

506

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

507

.replace(" ", ""))

508

if "secret" in section:

509

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

510

elif "secfile" in section:

511

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

512

(section["secfile"])),

513

"rb") as secfile:

514

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

515

else:

516

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

517

.format(section))

518

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

519

client["extended_timeout"] = string_to_delta(

520

section["extended_timeout"])

521

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

522

client["approval_delay"] = string_to_delta(

523

section["approval_delay"])

524

client["approval_duration"] = string_to_delta(

525

section["approval_duration"])

526

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

527

client["last_approval_request"] = None

528

client["last_checked_ok"] = None

529

client["last_checker_status"] = -2

530

531

return settings

532

533

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

352

534

self.name = name

353

if config is None:

354

config = {}

535

if server_settings is None:

536

server_settings = {}

537

self.server_settings = server_settings

538

# adding all client settings

539

for setting, value in settings.iteritems():

540

setattr(self, setting, value)

541

542

if self.enabled:

543

if not hasattr(self, "last_enabled"):

544

self.last_enabled = datetime.datetime.utcnow()

545

if not hasattr(self, "expires"):

546

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

547

+ self.timeout)

548

else:

549

self.last_enabled = None

550

self.expires = None

551

355

552

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

356

553

# Uppercase and remove spaces from fingerprint for later

357

554

# comparison purposes with return value from the fingerprint()

358

555

# function

359

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

360

.replace(" ", ""))

361

556

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

557

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

558

datetime.datetime.utcnow())

559

560

# attributes specific for this server instance

383

561

self.checker = None

384

562

self.checker_initiator_tag = None

385

563

self.disable_initiator_tag = None

386

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

387

564

self.checker_callback_tag = None

388

self.checker_command = config["checker"]

389

565

self.current_checker_command = None

390

self._approved = None

391

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

392

True)

566

self.approved = None

393

567

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

568

self.changedstate = (multiprocessing_manager

399

569

.Condition(multiprocessing_manager

400

570

.Lock()))

401

self.client_structure = [attr for attr in self.__dict__.iterkeys() if not attr.startswith("_")]

571

self.client_structure = [attr for attr in

572

self.__dict__.iterkeys()

573

if not attr.startswith("_")]

402

574

self.client_structure.append("client_structure")

403

404

575

405

576

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

406

lambda obj: isinstance(obj, property)):

577

lambda obj:

578

isinstance(obj,

579

property)):

407

580

if not name.startswith("_"):

408

581

self.client_structure.append(name)

409

582

417

590

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

418

591

# Already enabled

419

592

return

420

self.send_changedstate()

421

593

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

422

594

self.enabled = True

423

595

self.last_enabled = datetime.datetime.utcnow()

424

596

self.init_checker()

597

self.send_changedstate()

425

598

426

599

def disable(self, quiet=True):

427

600

"""Disable this client."""

428

601

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

429

602

return False

430

603

if not quiet:

431

self.send_changedstate()

432

if not quiet:

433

604

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

434

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

605

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

435

606

gobject.source_remove(self.disable_initiator_tag)

436

607

self.disable_initiator_tag = None

437

608

self.expires = None

438

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

609

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

439

610

gobject.source_remove(self.checker_initiator_tag)

440

611

self.checker_initiator_tag = None

441

612

self.stop_checker()

442

613

self.enabled = False

614

if not quiet:

615

self.send_changedstate()

443

616

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

444

617

return False

445

618

446

619

def __del__(self):

447

620

self.disable()

448

621

449

622

def init_checker(self):

450

623

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

451

624

# and every interval from then on.

625

if self.checker_initiator_tag is not None:

626

gobject.source_remove(self.checker_initiator_tag)

452

627

self.checker_initiator_tag = (gobject.timeout_add

453

628

(self.interval_milliseconds(),

454

629

self.start_checker))

455

630

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

631

if self.disable_initiator_tag is not None:

632

gobject.source_remove(self.disable_initiator_tag)

456

633

self.disable_initiator_tag = (gobject.timeout_add

457

634

(self.timeout_milliseconds(),

458

635

self.disable))

459

636

# Also start a new checker *right now*.

460

637

self.start_checker()

461

462

638

463

639

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

464

640

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

465

641

self.checker_callback_tag = None

466

642

self.checker = None

467

643

if os.WIFEXITED(condition):

468

self.last_checker_status = os.WEXITSTATUS(condition)

644

self.last_checker_status = os.WEXITSTATUS(condition)

469

645

if self.last_checker_status == 0:

470

646

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

471

647

vars(self))

478

654

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

479

655

vars(self))

480

656

481

def checked_ok(self, timeout=None):

482

"""Bump up the timeout for this client.

483

484

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

485

alive and well.

486

"""

657

def checked_ok(self):

658

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

659

self.last_checked_ok = datetime.datetime.utcnow()

660

self.last_checker_status = 0

661

self.bump_timeout()

662

663

def bump_timeout(self, timeout=None):

664

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

487

665

if timeout is None:

488

666

timeout = self.timeout

489

self.last_checked_ok = datetime.datetime.utcnow()

490

667

if self.disable_initiator_tag is not None:

491

668

gobject.source_remove(self.disable_initiator_tag)

669

self.disable_initiator_tag = None

492

670

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

493

671

self.disable_initiator_tag = (gobject.timeout_add

494

(_timedelta_to_milliseconds

672

(timedelta_to_milliseconds

495

673

(timeout), self.disable))

496

674

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

497

675

504

682

If a checker already exists, leave it running and do

505

683

nothing."""

506

684

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

507

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

508

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

509

# client would inevitably timeout, since no checker would get

510

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

685

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

686

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

687

# would inevitably timeout, since no checker would get a

688

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

511

689

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

512

690

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

513

691

# should be.

515

693

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

516

694

try:

517

695

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

518

except (AttributeError, OSError) as error:

519

if (isinstance(error, OSError)

520

and error.errno != errno.ECHILD):

521

raise error

696

except AttributeError:

697

pass

698

except OSError as error:

699

if error.errno != errno.ECHILD:

700

raise

522

701

else:

523

702

if pid:

524

703

logger.warning("Checker was a zombie")

527

706

self.current_checker_command)

528

707

# Start a new checker if needed

529

708

if self.checker is None:

709

# Escape attributes for the shell

710

escaped_attrs = dict(

711

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

712

for attr in

713

self.runtime_expansions)

530

714

try:

531

# In case checker_command has exactly one % operator

532

command = self.checker_command % self.host

533

except TypeError:

534

# Escape attributes for the shell

535

escaped_attrs = dict(

536

(attr,

537

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

538

errors=

539

'replace')))

540

for attr in

541

self.runtime_expansions)

542

543

try:

544

command = self.checker_command % escaped_attrs

545

except TypeError as error:

546

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

547

' %s', self.checker_command, error)

548

return True # Try again later

715

command = self.checker_command % escaped_attrs

716

except TypeError as error:

717

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

718

self.checker_command, exc_info=error)

719

return True # Try again later

549

720

self.current_checker_command = command

550

721

try:

551

722

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

554

725

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

555

726

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

556

727

# always replaced by /dev/null.)

728

# The exception is when not debugging but nevertheless

729

# running in the foreground; use the previously

730

# created wnull.

731

popen_args = {}

732

if (not self.server_settings["debug"]

733

and self.server_settings["foreground"]):

734

popen_args.update({"stdout": wnull,

735

"stderr": wnull })

557

736

self.checker = subprocess.Popen(command,

558

737

close_fds=True,

559

shell=True, cwd="/")

560

self.checker_callback_tag = (gobject.child_watch_add

561

(self.checker.pid,

562

self.checker_callback,

563

data=command))

564

# The checker may have completed before the gobject

565

# watch was added. Check for this.

738

shell=True, cwd="/",

739

**popen_args)

740

except OSError as error:

741

logger.error("Failed to start subprocess",

742

exc_info=error)

743

return True

744

self.checker_callback_tag = (gobject.child_watch_add

745

(self.checker.pid,

746

self.checker_callback,

747

data=command))

748

# The checker may have completed before the gobject

749

# watch was added. Check for this.

750

try:

566

751

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

567

if pid:

568

gobject.source_remove(self.checker_callback_tag)

569

self.checker_callback(pid, status, command)

570

752

except OSError as error:

571

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

572

error)

753

if error.errno == errno.ECHILD:

754

# This should never happen

755

logger.error("Child process vanished",

756

exc_info=error)

757

return True

758

raise

759

if pid:

760

gobject.source_remove(self.checker_callback_tag)

761

self.checker_callback(pid, status, command)

573

762

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

574

763

return True

575

764

582

771

return

583

772

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

584

773

try:

585

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

774

self.checker.terminate()

586

775

#time.sleep(0.5)

587

776

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

588

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

777

# self.checker.kill()

589

778

except OSError as error:

590

779

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

591

780

raise

592

781

self.checker = None

593

782

594

# Encrypts a client secret and stores it in a varible encrypted_secret

595

def encrypt_secret(self, key):

596

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

597

hasheng = hashlib.sha256()

598

hasheng.update(key)

599

encryptionkey = hasheng.digest()

600

601

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

602

hasheng = hashlib.sha256()

603

hasheng.update(self.secret)

604

validationhash = hasheng.digest()

605

606

# Encrypt secret

607

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

608

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

609

Crypto.Cipher.AES.MODE_CFB, iv)

610

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

611

self.encrypted_secret = (ciphertext, iv)

612

613

# Decrypt a encrypted client secret

614

def decrypt_secret(self, key):

615

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

616

hasheng = hashlib.sha256()

617

hasheng.update(key)

618

encryptionkey = hasheng.digest()

619

620

# Decrypt encrypted secret

621

ciphertext, iv = self.encrypted_secret

622

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

623

Crypto.Cipher.AES.MODE_CFB, iv)

624

plain = ciphereng.decrypt(ciphertext)

625

626

# Validate decrypted secret to know if it was succesful

627

hasheng = hashlib.sha256()

628

validationhash = plain[:hasheng.digest_size]

629

secret = plain[hasheng.digest_size:]

630

hasheng.update(secret)

631

632

# if validation fails, we use key as new secret. Otherwhise, we use

633

# the decrypted secret

634

if hasheng.digest() == validationhash:

635

self.secret = secret

636

else:

637

self.secret = key

638

del self.encrypted_secret

639

640

783

641

784

def dbus_service_property(dbus_interface, signature="v",

642

785

access="readwrite", byte_arrays=False):

654

797

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

655

798

if byte_arrays and signature != "ay":

656

799

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

657

" signature %r" % signature)

800

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

658

801

def decorator(func):

659

802

func._dbus_is_property = True

660

803

func._dbus_interface = dbus_interface

668

811

return decorator

669

812

670

813

814

def dbus_interface_annotations(dbus_interface):

815

"""Decorator for marking functions returning interface annotations

816

817

Usage:

818

819

@dbus_interface_annotations("org.example.Interface")

820

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

821

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

822

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

823

"false"}

824

"""

825

def decorator(func):

826

func._dbus_is_interface = True

827

func._dbus_interface = dbus_interface

828

func._dbus_name = dbus_interface

829

return func

830

return decorator

831

832

833

def dbus_annotations(annotations):

834

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

835

Usage:

836

837

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

838

access="r")

839

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

840

"org.freedesktop.DBus.Property."

841

"EmitsChangedSignal": "false"})

842

def Property_dbus_property(self):

843

return dbus.Boolean(False)

844

"""

845

def decorator(func):

846

func._dbus_annotations = annotations

847

return func

848

return decorator

849

850

671

851

class DBusPropertyException(dbus.exceptions.DBusException):

672

852

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

673

853

"""

696

876

"""

697

877

698

878

@staticmethod

699

def _is_dbus_property(obj):

700

return getattr(obj, "_dbus_is_property", False)

879

def _is_dbus_thing(thing):

880

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

881

882

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

883

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

884

"""

885

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

886

False)

701

887

702

def _get_all_dbus_properties(self):

888

def _get_all_dbus_things(self, thing):

703

889

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

704

890

"""

705

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

891

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

892

name),

893

athing.__get__(self))

706

894

for cls in self.__class__.__mro__

707

for name, prop in

708

inspect.getmembers(cls, self._is_dbus_property))

895

for name, athing in

896

inspect.getmembers(cls,

897

self._is_dbus_thing(thing)))

709

898

710

899

def _get_dbus_property(self, interface_name, property_name):

711

900

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

713

902

"""

714

903

for cls in self.__class__.__mro__:

715

904

for name, value in (inspect.getmembers

716

(cls, self._is_dbus_property)):

905

(cls,

906

self._is_dbus_thing("property"))):

717

907

if (value._dbus_name == property_name

718

908

and value._dbus_interface == interface_name):

719

909

return value.__get__(self)

747

937

# The byte_arrays option is not supported yet on

748

938

# signatures other than "ay".

749

939

if prop._dbus_signature != "ay":

750

raise ValueError

751

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

752

for byte in value))

940

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

941

"'ay' signature {0!r}"

942

.format(prop._dbus_signature))

943

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

944

for byte in value))

753

945

prop(value)

754

946

755

947

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

760

952

761

953

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

762

954

"""

763

all = {}

764

for name, prop in self._get_all_dbus_properties():

955

properties = {}

956

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

765

957

if (interface_name

766

958

and interface_name != prop._dbus_interface):

767

959

# Interface non-empty but did not match

771

963

continue

772

964

value = prop()

773

965

if not hasattr(value, "variant_level"):

774

all[name] = value

966

properties[name] = value

775

967

continue

776

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

777

value.variant_level+1)

778

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

968

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

969

value.variant_level+1)

970

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

779

971

780

972

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

781

973

out_signature="s",

782

974

path_keyword='object_path',

783

975

connection_keyword='connection')

784

976

def Introspect(self, object_path, connection):

785

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

977

"""Overloading of standard D-Bus method.

978

979

Inserts property tags and interface annotation tags.

786

980

"""

787

981

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

788

982

connection)

795

989

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

796

990

return e

797

991

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

992

# Add property tags

798

993

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

799

994

for name, prop

800

in self._get_all_dbus_properties()

995

in self._get_all_dbus_things("property")

801

996

if prop._dbus_interface

802

997

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

803

998

if_tag.appendChild(tag)

999

# Add annotation tags

1000

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

1001

for tag in if_tag.getElementsByTagName(typ):

1002

annots = dict()

1003

for name, prop in (self.

1004

_get_all_dbus_things(typ)):

1005

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

1006

and prop._dbus_interface

1007

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

1008

annots.update(getattr

1009

(prop,

1010

"_dbus_annotations",

1011

{}))

1012

for name, value in annots.iteritems():

1013

ann_tag = document.createElement(

1014

"annotation")

1015

ann_tag.setAttribute("name", name)

1016

ann_tag.setAttribute("value", value)

1017

tag.appendChild(ann_tag)

1018

# Add interface annotation tags

1019

for annotation, value in dict(

1020

itertools.chain.from_iterable(

1021

annotations().iteritems()

1022

for name, annotations in

1023

self._get_all_dbus_things("interface")

1024

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

1025

)).iteritems():

1026

ann_tag = document.createElement("annotation")

1027

ann_tag.setAttribute("name", annotation)

1028

ann_tag.setAttribute("value", value)

1029

if_tag.appendChild(ann_tag)

804

1030

# Add the names to the return values for the

805

1031

# "org.freedesktop.DBus.Properties" methods

806

1032

if (if_tag.getAttribute("name")

821

1047

except (AttributeError, xml.dom.DOMException,

822

1048

xml.parsers.expat.ExpatError) as error:

823

1049

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

824

error)

1050

exc_info=error)

825

1051

return xmlstring

826

1052

827

1053

828

def datetime_to_dbus (dt, variant_level=0):

1054

def datetime_to_dbus(dt, variant_level=0):

829

1055

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

830

1056

if dt is None:

831

1057

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

832

1058

return dbus.String(dt.isoformat(),

833

1059

variant_level=variant_level)

834

1060

835

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

836

.__metaclass__):

837

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

838

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

1061

1062

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1063

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

1064

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

1065

interface names according to the "alt_interface_names" mapping.

1066

Usage:

1067

1068

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

1069

"net.example.AlternateInterface"})

1070

class SampleDBusObject(dbus.service.Object):

1071

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

1072

def SampleDBusMethod():

1073

pass

1074

1075

The above "SampleDBusMethod" on "SampleDBusObject" will be

1076

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

1077

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

1078

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

1079

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

1080

1081

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

1082

(from DBusObjectWithProperties) and interfaces (from the

1083

dbus_interface_annotations decorator).

839

1084

"""

840

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

841

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

842

# methods, signals, or properties in them

843

for base in (b for b in bases

844

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

845

# Go though all attributes of the base class

846

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

1085

def wrapper(cls):

1086

for orig_interface_name, alt_interface_name in (

1087

alt_interface_names.iteritems()):

1088

attr = {}

1089

interface_names = set()

1090

# Go though all attributes of the class

1091

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

847

1092

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

848

1093

# with the wrong interface name

849

1094

if (not hasattr(attribute, "_dbus_interface")

850

1095

or not attribute._dbus_interface

851

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

1096

.startswith(orig_interface_name)):

852

1097

continue

853

1098

# Create an alternate D-Bus interface name based on

854

1099

# the current name

855

1100

alt_interface = (attribute._dbus_interface

856

.replace("se.recompile.Mandos",

857

"se.bsnet.fukt.Mandos"))

1101

.replace(orig_interface_name,

1102

alt_interface_name))

1103

interface_names.add(alt_interface)

858

1104

# Is this a D-Bus signal?

859

1105

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

860

# Extract the original non-method function by

861

# black magic

1106

# Extract the original non-method undecorated

1107

# function by black magic

862

1108

nonmethod_func = (dict(

863

1109

zip(attribute.func_code.co_freevars,

864

1110

attribute.__closure__))["func"]

875

1121

nonmethod_func.func_name,

876

1122

nonmethod_func.func_defaults,

877

1123

nonmethod_func.func_closure)))

1124

# Copy annotations, if any

1125

try:

1126

new_function._dbus_annotations = (

1127

dict(attribute._dbus_annotations))

1128

except AttributeError:

1129

pass

878

1130

# Define a creator of a function to call both the

879

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

880

# signals gets sent when the function is called

1131

# original and alternate functions, so both the

1132

# original and alternate signals gets sent when

1133

# the function is called

881

1134

def fixscope(func1, func2):

882

1135

"""This function is a scope container to pass

883

1136

func1 and func2 to the "call_both" function

890

1143

return call_both

891

1144

# Create the "call_both" function and add it to

892

1145

# the class

893

attr[attrname] = fixscope(attribute,

894

new_function)

1146

attr[attrname] = fixscope(attribute, new_function)

895

1147

# Is this a D-Bus method?

896

1148

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

897

1149

# Create a new, but exactly alike, function

908

1160

attribute.func_name,

909

1161

attribute.func_defaults,

910

1162

attribute.func_closure)))

1163

# Copy annotations, if any

1164

try:

1165

attr[attrname]._dbus_annotations = (

1166

dict(attribute._dbus_annotations))

1167

except AttributeError:

1168

pass

911

1169

# Is this a D-Bus property?

912

1170

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

913

1171

# Create a new, but exactly alike, function

927

1185

attribute.func_name,

928

1186

attribute.func_defaults,

929

1187

attribute.func_closure)))

930

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

931

1188

# Copy annotations, if any

1189

try:

1190

attr[attrname]._dbus_annotations = (

1191

dict(attribute._dbus_annotations))

1192

except AttributeError:

1193

pass

1194

# Is this a D-Bus interface?

1195

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

1196

# Create a new, but exactly alike, function

1197

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

1198

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

1199

# to the class.

1200

attr[attrname] = (dbus_interface_annotations

1201

(alt_interface)

1202

(types.FunctionType

1203

(attribute.func_code,

1204

attribute.func_globals,

1205

attribute.func_name,

1206

attribute.func_defaults,

1207

attribute.func_closure)))

1208

if deprecate:

1209

# Deprecate all alternate interfaces

1210

iname="_AlternateDBusNames_interface_annotation{0}"

1211

for interface_name in interface_names:

1212

@dbus_interface_annotations(interface_name)

1213

def func(self):

1214

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

1215

"true" }

1216

# Find an unused name

1217

for aname in (iname.format(i)

1218

for i in itertools.count()):

1219

if aname not in attr:

1220

attr[aname] = func

1221

break

1222

if interface_names:

1223

# Replace the class with a new subclass of it with

1224

# methods, signals, etc. as created above.

1225

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

1226

(cls,), attr)

1227

return cls

1228

return wrapper

1229

1230

1231

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

1232

"se.bsnet.fukt.Mandos"})

932

1233

class ClientDBus(Client, DBusObjectWithProperties):

933

1234

"""A Client class using D-Bus

934

1235

945

1246

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

946

1247

self.bus = bus

947

1248

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

948

949

self._approvals_pending = 0

950

1249

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

951

1250

# the D-Bus

952

1251

client_object_name = unicode(self.name).translate(

956

1255

("/clients/" + client_object_name))

957

1256

DBusObjectWithProperties.__init__(self, self.bus,

958

1257

self.dbus_object_path)

959

1258

960

1259

def notifychangeproperty(transform_func,

961

1260

dbus_name, type_func=lambda x: x,

962

1261

variant_level=1):

963

1262

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

964

1263

its changes to DBus.

965

1264

966

1265

transform_fun: Function that takes a value and a variant_level

967

1266

and transforms it to a D-Bus type.

968

1267

dbus_name: D-Bus name of the variable

985

1284

986

1285

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

987

1286

988

989

1287

expires = notifychangeproperty(datetime_to_dbus, "Expires")

990

1288

approvals_pending = notifychangeproperty(dbus.Boolean,

991

1289

"ApprovalPending",

998

1296

checker is not None)

999

1297

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1000

1298

"LastCheckedOK")

1299

last_checker_status = notifychangeproperty(dbus.Int16,

1300

"LastCheckerStatus")

1001

1301

last_approval_request = notifychangeproperty(

1002

1302

datetime_to_dbus, "LastApprovalRequest")

1003

1303

approved_by_default = notifychangeproperty(dbus.Boolean,

1004

1304

"ApprovedByDefault")

1005

approval_delay = notifychangeproperty(dbus.UInt16,

1305

approval_delay = notifychangeproperty(dbus.UInt64,

1006

1306

"ApprovalDelay",

1007

1307

type_func =

1008

_timedelta_to_milliseconds)

1308

timedelta_to_milliseconds)

1009

1309

approval_duration = notifychangeproperty(

1010

dbus.UInt16, "ApprovalDuration",

1011

type_func = _timedelta_to_milliseconds)

1310

dbus.UInt64, "ApprovalDuration",

1311

type_func = timedelta_to_milliseconds)

1012

1312

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

1013

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

1313

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

1014

1314

type_func =

1015

_timedelta_to_milliseconds)

1315

timedelta_to_milliseconds)

1016

1316

extended_timeout = notifychangeproperty(

1017

dbus.UInt16, "ExtendedTimeout",

1018

type_func = _timedelta_to_milliseconds)

1019

interval = notifychangeproperty(dbus.UInt16,

1317

dbus.UInt64, "ExtendedTimeout",

1318

type_func = timedelta_to_milliseconds)

1319

interval = notifychangeproperty(dbus.UInt64,

1020

1320

"Interval",

1021

1321

type_func =

1022

_timedelta_to_milliseconds)

1322

timedelta_to_milliseconds)

1023

1323

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

1024

1324

1025

1325

del notifychangeproperty

1053

1353

*args, **kwargs)

1054

1354

1055

1355

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

1056

old_checker = self.checker

1057

if self.checker is not None:

1058

old_checker_pid = self.checker.pid

1059

else:

1060

old_checker_pid = None

1356

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

1061

1357

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

1062

1358

# Only if new checker process was started

1063

1359

if (self.checker is not None

1067

1363

return r

1068

1364

1069

1365

def _reset_approved(self):

1070

self._approved = None

1366

self.approved = None

1071

1367

return False

1072

1368

1073

1369

def approve(self, value=True):

1074

self.send_changedstate()

1075

self._approved = value

1076

gobject.timeout_add(_timedelta_to_milliseconds

1370

self.approved = value

1371

gobject.timeout_add(timedelta_to_milliseconds

1077

1372

(self.approval_duration),

1078

1373

self._reset_approved)

1079

1374

self.send_changedstate()

1080

1375

1081

1376

## D-Bus methods, signals & properties

1082

1377

_interface = "se.recompile.Mandos.Client"

1083

1378

1379

## Interfaces

1380

1381

@dbus_interface_annotations(_interface)

1382

def _foo(self):

1383

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

1384

"false"}

1385

1084

1386

## Signals

1085

1387

1086

1388

# CheckerCompleted - signal

1185

1487

access="readwrite")

1186

1488

def ApprovalDuration_dbus_property(self, value=None):

1187

1489

if value is None: # get

1188

return dbus.UInt64(_timedelta_to_milliseconds(

1490

return dbus.UInt64(timedelta_to_milliseconds(

1189

1491

self.approval_duration))

1190

1492

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

1191

1493

1205

1507

def Host_dbus_property(self, value=None):

1206

1508

if value is None: # get

1207

1509

return dbus.String(self.host)

1208

self.host = value

1510

self.host = unicode(value)

1209

1511

1210

1512

# Created - property

1211

1513

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

1212

1514

def Created_dbus_property(self):

1213

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

1515

return datetime_to_dbus(self.created)

1214

1516

1215

1517

# LastEnabled - property

1216

1518

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

1237

1539

return

1238

1540

return datetime_to_dbus(self.last_checked_ok)

1239

1541

1542

# LastCheckerStatus - property

1543

@dbus_service_property(_interface, signature="n",

1544

access="read")

1545

def LastCheckerStatus_dbus_property(self):

1546

return dbus.Int16(self.last_checker_status)

1547

1240

1548

# Expires - property

1241

1549

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

1242

1550

def Expires_dbus_property(self):

1253

1561

def Timeout_dbus_property(self, value=None):

1254

1562

if value is None: # get

1255

1563

return dbus.UInt64(self.timeout_milliseconds())

1564

old_timeout = self.timeout

1256

1565

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

1257

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

1258

return

1259

# Reschedule timeout

1260

gobject.source_remove(self.disable_initiator_tag)

1261

self.disable_initiator_tag = None

1262

self.expires = None

1263

time_to_die = _timedelta_to_milliseconds((self

1264

.last_checked_ok

1265

+ self.timeout)

1266

- datetime.datetime

1267

.utcnow())

1268

if time_to_die <= 0:

1269

# The timeout has passed

1270

self.disable()

1271

else:

1272

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

1273

+ datetime.timedelta(milliseconds =

1274

time_to_die))

1275

self.disable_initiator_tag = (gobject.timeout_add

1276

(time_to_die, self.disable))

1566

# Reschedule disabling

1567

if self.enabled:

1568

now = datetime.datetime.utcnow()

1569

self.expires += self.timeout - old_timeout

1570

if self.expires <= now:

1571

# The timeout has passed

1572

self.disable()

1573

else:

1574

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

1575

is None):

1576

return

1577

gobject.source_remove(self.disable_initiator_tag)

1578

self.disable_initiator_tag = (

1579

gobject.timeout_add(

1580

timedelta_to_milliseconds(self.expires - now),

1581

self.disable))

1277

1582

1278

1583

# ExtendedTimeout - property

1279

1584

@dbus_service_property(_interface, signature="t",

1292

1597

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

1293

1598

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

1294

1599

return

1295

# Reschedule checker run

1296

gobject.source_remove(self.checker_initiator_tag)

1297

self.checker_initiator_tag = (gobject.timeout_add

1298

(value, self.start_checker))

1299

self.start_checker() # Start one now, too

1600

if self.enabled:

1601

# Reschedule checker run

1602

gobject.source_remove(self.checker_initiator_tag)

1603

self.checker_initiator_tag = (gobject.timeout_add

1604

(value, self.start_checker))

1605

self.start_checker() # Start one now, too

1300

1606

1301

1607

# Checker - property

1302

1608

@dbus_service_property(_interface, signature="s",

1304

1610

def Checker_dbus_property(self, value=None):

1305

1611

if value is None: # get

1306

1612

return dbus.String(self.checker_command)

1307

self.checker_command = value

1613

self.checker_command = unicode(value)

1308

1614

1309

1615

# CheckerRunning - property

1310

1616

@dbus_service_property(_interface, signature="b",

1339

1645

raise KeyError()

1340

1646

1341

1647

def __getattribute__(self, name):

1342

if(name == '_pipe'):

1648

if name == '_pipe':

1343

1649

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

1344

1650

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

1345

1651

data = self._pipe.recv()

1352

1658

return func

1353

1659

1354

1660

def __setattr__(self, name, value):

1355

if(name == '_pipe'):

1661

if name == '_pipe':

1356

1662

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

1357

1663

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

1358

1664

1359

class ClientDBusTransitional(ClientDBus):

1360

__metaclass__ = AlternateDBusNamesMetaclass

1361

1665

1362

1666

class ClientHandler(socketserver.BaseRequestHandler, object):

1363

1667

"""A class to handle client connections.

1400

1704

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

1401

1705

try:

1402

1706

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

1403

raise RuntimeError

1707

raise RuntimeError(line)

1404

1708

except (ValueError, IndexError, RuntimeError) as error:

1405

1709

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

1406

1710

return

1446

1750

client.Rejected("Disabled")

1447

1751

return

1448

1752

1449

if client._approved or not client.approval_delay:

1753

if client.approved or not client.approval_delay:

1450

1754

#We are approved or approval is disabled

1451

1755

break

1452

elif client._approved is None:

1756

elif client.approved is None:

1453

1757

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

1454

1758

client.name)

1455

1759

if self.server.use_dbus:

1468

1772

#wait until timeout or approved

1469

1773

time = datetime.datetime.now()

1470

1774

client.changedstate.acquire()

1471

(client.changedstate.wait

1472

(float(client._timedelta_to_milliseconds(delay)

1473

/ 1000)))

1775

client.changedstate.wait(

1776

float(timedelta_to_milliseconds(delay)

1777

/ 1000))

1474

1778

client.changedstate.release()

1475

1779

time2 = datetime.datetime.now()

1476

1780

if (time2 - time) >= delay:

1492

1796

try:

1493

1797

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

1494

1798

except gnutls.errors.GNUTLSError as error:

1495

logger.warning("gnutls send failed")

1799

logger.warning("gnutls send failed",

1800

exc_info=error)

1496

1801

return

1497

1802

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

1498

1803

sent, len(client.secret)

1501

1806

1502

1807

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

1503

1808

# bump the timeout using extended_timeout

1504

client.checked_ok(client.extended_timeout)

1809

client.bump_timeout(client.extended_timeout)

1505

1810

if self.server.use_dbus:

1506

1811

# Emit D-Bus signal

1507

1812

client.GotSecret()

1512

1817

try:

1513

1818

session.bye()

1514

1819

except gnutls.errors.GNUTLSError as error:

1515

logger.warning("GnuTLS bye failed")

1820

logger.warning("GnuTLS bye failed",

1821

exc_info=error)

1516

1822

1517

1823

@staticmethod

1518

1824

def peer_certificate(session):

1574

1880

# Convert the buffer to a Python bytestring

1575

1881

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

1576

1882

# Convert the bytestring to hexadecimal notation

1577

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

1883

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

1578

1884

return hex_fpr

1579

1885

1580

1886

1583

1889

def sub_process_main(self, request, address):

1584

1890

try:

1585

1891

self.finish_request(request, address)

1586

except:

1892

except Exception:

1587

1893

self.handle_error(request, address)

1588

1894

self.close_request(request)

1589

1895

1590

1896

def process_request(self, request, address):

1591

1897

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

1592

1898

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

1593

args = (request,

1594

address))

1899

args = (request, address))

1595

1900

proc.start()

1596

1901

return proc

1597

1902

1612

1917

1613

1918

def add_pipe(self, parent_pipe, proc):

1614

1919

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

1615

raise NotImplementedError

1920

raise NotImplementedError()

1616

1921

1617

1922

1618

1923

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1625

1930

use_ipv6: Boolean; to use IPv6 or not

1626

1931

"""

1627

1932

def __init__(self, server_address, RequestHandlerClass,

1628

interface=None, use_ipv6=True):

1933

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

1934

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

1935

creating a new one with socket.socket().

1936

"""

1629

1937

self.interface = interface

1630

1938

if use_ipv6:

1631

1939

self.address_family = socket.AF_INET6

1940

if socketfd is not None:

1941

# Save the file descriptor

1942

self.socketfd = socketfd

1943

# Save the original socket.socket() function

1944

self.socket_socket = socket.socket

1945

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

1946

#

1947

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

1948

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

1949

# patching socket.socket.)

1950

#

1951

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

1952

@functools.wraps(socket.socket)

1953

def socket_wrapper(*args, **kwargs):

1954

# Restore original function so subsequent calls are

1955

# not affected.

1956

socket.socket = self.socket_socket

1957

del self.socket_socket

1958

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

1959

# saved file descriptor.

1960

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

1961

# Replace socket.socket() function with wrapper

1962

socket.socket = socket_wrapper

1963

# The socketserver.TCPServer.__init__ will call

1964

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

1965

# socket_wrapper(), if socketfd was set.

1632

1966

socketserver.TCPServer.__init__(self, server_address,

1633

1967

RequestHandlerClass)

1968

1634

1969

def server_bind(self):

1635

1970

"""This overrides the normal server_bind() function

1636

1971

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

1644

1979

try:

1645

1980

self.socket.setsockopt(socket.SOL_SOCKET,

1646

1981

SO_BINDTODEVICE,

1647

str(self.interface

1648

+ '\0'))

1982

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

1649

1983

except socket.error as error:

1650

if error[0] == errno.EPERM:

1651

logger.error("No permission to"

1652

" bind to interface %s",

1653

self.interface)

1654

elif error[0] == errno.ENOPROTOOPT:

1984

if error.errno == errno.EPERM:

1985

logger.error("No permission to bind to"

1986

" interface %s", self.interface)

1987

elif error.errno == errno.ENOPROTOOPT:

1655

1988

logger.error("SO_BINDTODEVICE not available;"

1656

1989

" cannot bind to interface %s",

1657

1990

self.interface)

1991

elif error.errno == errno.ENODEV:

1992

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

1993

" cannot bind", self.interface)

1658

1994

else:

1659

1995

raise

1660

1996

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

1663

1999

if self.address_family == socket.AF_INET6:

1664

2000

any_address = "::" # in6addr_any

1665

2001

else:

1666

any_address = socket.INADDR_ANY

2002

any_address = "0.0.0.0" # INADDR_ANY

1667

2003

self.server_address = (any_address,

1668

2004

self.server_address[1])

1669

2005

elif not self.server_address[1]:

1690

2026

"""

1691

2027

def __init__(self, server_address, RequestHandlerClass,

1692

2028

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

1693

gnutls_priority=None, use_dbus=True):

2029

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

1694

2030

self.enabled = False

1695

2031

self.clients = clients

1696

2032

if self.clients is None:

1700

2036

IPv6_TCPServer.__init__(self, server_address,

1701

2037

RequestHandlerClass,

1702

2038

interface = interface,

1703

use_ipv6 = use_ipv6)

2039

use_ipv6 = use_ipv6,

2040

socketfd = socketfd)

1704

2041

def server_activate(self):

1705

2042

if self.enabled:

1706

2043

return socketserver.TCPServer.server_activate(self)

1719

2056

1720

2057

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

1721

2058

proc = None, client_object=None):

1722

condition_names = {

1723

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

1724

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

1725

# blocking).

1726

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

1727

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

1728

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

1729

# broken, usually for pipes and

1730

# sockets).

1731

}

1732

conditions_string = ' | '.join(name

1733

for cond, name in

1734

condition_names.iteritems()

1735

if cond & condition)

1736

2059

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

1737

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

2060

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

1738

2061

# Wait for other process to exit

1739

2062

proc.join()

1740

2063

return False

1798

2121

return True

1799

2122

1800

2123

2124

def rfc3339_duration_to_delta(duration):

2125

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

2126

2127

>>> rfc3339_duration_to_delta("P7D")

2128

datetime.timedelta(7)

2129

>>> rfc3339_duration_to_delta("PT60S")

2130

datetime.timedelta(0, 60)

2131

>>> rfc3339_duration_to_delta("PT60M")

2132

datetime.timedelta(0, 3600)

2133

>>> rfc3339_duration_to_delta("PT24H")

2134

datetime.timedelta(1)

2135

>>> rfc3339_duration_to_delta("P1W")

2136

datetime.timedelta(7)

2137

>>> rfc3339_duration_to_delta("PT5M30S")

2138

datetime.timedelta(0, 330)

2139

>>> rfc3339_duration_to_delta("P1DT3M20S")

2140

datetime.timedelta(1, 200)

2141

"""

2142

2143

# Parsing an RFC 3339 duration with regular expressions is not

2144

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

2145

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

2146

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

2147

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

2148

# avoid excessive use of external libraries.

2149

2150

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

2151

Token = collections.namedtuple("Token",

2152

("regexp", # To match token; if

2153

# "value" is not None,

2154

# must have a "group"

2155

# containing digits

2156

"value", # datetime.timedelta or

2157

# None

2158

"followers")) # Tokens valid after

2159

# this token

2160

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

2161

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

2162

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

2163

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

2164

datetime.timedelta(seconds=1),

2165

frozenset((token_end,)))

2166

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

2167

datetime.timedelta(minutes=1),

2168

frozenset((token_second, token_end)))

2169

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

2170

datetime.timedelta(hours=1),

2171

frozenset((token_minute, token_end)))

2172

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

2173

None,

2174

frozenset((token_hour, token_minute,

2175

token_second)))

2176

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

2177

datetime.timedelta(days=1),

2178

frozenset((token_time, token_end)))

2179

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

2180

datetime.timedelta(weeks=4),

2181

frozenset((token_day, token_end)))

2182

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

2183

datetime.timedelta(weeks=52),

2184

frozenset((token_month, token_end)))

2185

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

2186

datetime.timedelta(weeks=1),

2187

frozenset((token_end,)))

2188

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

2189

frozenset((token_year, token_month,

2190

token_day, token_time,

2191

token_week))),

2192

# Define starting values

2193

value = datetime.timedelta() # Value so far

2194

found_token = None

2195

followers = frozenset(token_duration,) # Following valid tokens

2196

s = duration # String left to parse

2197

# Loop until end token is found

2198

while found_token is not token_end:

2199

# Search for any currently valid tokens

2200

for token in followers:

2201

match = token.regexp.match(s)

2202

if match is not None:

2203

# Token found

2204

if token.value is not None:

2205

# Value found, parse digits

2206

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

2207

# Add to value so far

2208

value += factor * token.value

2209

# Strip token from string

2210

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

2211

# Go to found token

2212

found_token = token

2213

# Set valid next tokens

2214

followers = found_token.followers

2215

break

2216

else:

2217

# No currently valid tokens were found

2218

raise ValueError("Invalid RFC 3339 duration")

2219

# End token found

2220

return value

2221

2222

1801

2223

def string_to_delta(interval):

1802

2224

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

1803

2225

1814

2236

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

1815

2237

datetime.timedelta(0, 330)

1816

2238

"""

2239

2240

try:

2241

return rfc3339_duration_to_delta(interval)

2242

except ValueError:

2243

pass

2244

1817

2245

timevalue = datetime.timedelta(0)

1818

2246

for s in interval.split():

1819

2247

try:

1830

2258

elif suffix == "w":

1831

2259

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

1832

2260

else:

1833

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

1834

except (ValueError, IndexError) as e:

2261

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

2262

.format(suffix))

2263

except IndexError as e:

1835

2264

raise ValueError(*(e.args))

1836

2265

timevalue += delta

1837

2266

return timevalue

1838

2267

1839

2268

1840

def if_nametoindex(interface):

1841

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

1842

1843

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

1844

global if_nametoindex

1845

try:

1846

if_nametoindex = (ctypes.cdll.LoadLibrary

1847

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

1848

.if_nametoindex)

1849

except (OSError, AttributeError):

1850

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

1851

def if_nametoindex(interface):

1852

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

1853

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

1854

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

1855

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1856

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

1857

interface))

1858

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

1859

ifreq[16:20])[0]

1860

return interface_index

1861

return if_nametoindex(interface)

1862

1863

1864

2269

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

1865

2270

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

1866

2271

1874

2279

sys.exit()

1875

2280

if not noclose:

1876

2281

# Close all standard open file descriptors

1877

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

2282

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

1878

2283

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

1879

2284

raise OSError(errno.ENODEV,

1880

"%s not a character device"

1881

% os.path.devnull)

2285

"{0} not a character device"

2286

.format(os.devnull))

1882

2287

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

1883

2288

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

1884

2289

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

1893

2298

1894

2299

parser = argparse.ArgumentParser()

1895

2300

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

1896

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

2301

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

1897

2302

help="show version number and exit")

1898

2303

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

1899

2304

help="Bind to interface IF")

1905

2310

help="Run self-test")

1906

2311

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

1907

2312

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

1908

" to terminal")

2313

" to terminal", default=None)

1909

2314

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

1910

2315

help="Debug level for stdout output")

1911

2316

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

1918

2323

" files")

1919

2324

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

1920

2325

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

1921

" system bus interface")

2326

" system bus interface", default=None)

1922

2327

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

1923

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

2328

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

2329

default=None)

1924

2330

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

1925

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

1926

default=True)

1927

2331

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

2332

" state", default=None)

2333

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

2334

help="Specify a file descriptor to a network"

2335

" socket to use instead of creating one")

2336

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

2337

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

2338

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

2339

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

2340

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

2341

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

2342

default=None)

2343

1928

2344

options = parser.parse_args()

1929

2345

1930

2346

if options.check:

1931

2347

import doctest

1932

doctest.testmod()

1933

sys.exit()

2348

fail_count, test_count = doctest.testmod()

2349

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

1934

2350

1935

2351

# Default values for config file for server-global settings

1936

2352

server_defaults = { "interface": "",

1938

2354

"port": "",

1939

2355

"debug": "False",

1940

2356

"priority":

1941

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

2357

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

1942

2358

"servicename": "Mandos",

1943

2359

"use_dbus": "True",

1944

2360

"use_ipv6": "True",

1945

2361

"debuglevel": "",

2362

"restore": "True",

2363

"socket": "",

2364

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

2365

"foreground": "False",

2366

"zeroconf": "True",

1946

2367

}

1947

2368

1948

2369

# Parse config file for server-global settings

1953

2374

# Convert the SafeConfigParser object to a dict

1954

2375

server_settings = server_config.defaults()

1955

2376

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

1956

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

2377

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

1957

2378

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

1958

2379

option)

1959

2380

if server_settings["port"]:

1960

2381

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

1961

2382

"port")

2383

if server_settings["socket"]:

2384

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

2385

"socket")

2386

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

2387

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

2388

# happen with a supplied network socket.

2389

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

2390

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

2391

["socket"])

1962

2392

del server_config

1963

2393

1964

2394

# Override the settings from the config file with command line

1965

2395

# options, if set.

1966

2396

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

1967

2397

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

1968

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

2398

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

2399

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

1969

2400

value = getattr(options, option)

1970

2401

if value is not None:

1971

2402

server_settings[option] = value

1974

2405

for option in server_settings.keys():

1975

2406

if type(server_settings[option]) is str:

1976

2407

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

2408

# Force all boolean options to be boolean

2409

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

2410

"foreground", "zeroconf"):

2411

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

2412

# Debug implies foreground

2413

if server_settings["debug"]:

2414

server_settings["foreground"] = True

1977

2415

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

1978

2416

1979

2417

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

1980

2418

2419

if (not server_settings["zeroconf"] and

2420

not (server_settings["port"]

2421

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

2422

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

2423

" Zeroconf")

2424

1981

2425

# For convenience

1982

2426

debug = server_settings["debug"]

1983

2427

debuglevel = server_settings["debuglevel"]

1984

2428

use_dbus = server_settings["use_dbus"]

1985

2429

use_ipv6 = server_settings["use_ipv6"]

2430

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

2431

stored_state_file)

2432

foreground = server_settings["foreground"]

2433

zeroconf = server_settings["zeroconf"]

2434

2435

if debug:

2436

initlogger(debug, logging.DEBUG)

2437

else:

2438

if not debuglevel:

2439

initlogger(debug)

2440

else:

2441

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

2442

initlogger(debug, level)

1986

2443

1987

2444

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

1988

2445

syslogger.setFormatter(logging.Formatter

1989

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

1990

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

1991

% server_settings["servicename"]))

2446

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

2447

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

2448

.format(server_settings

2449

["servicename"])))

1992

2450

1993

2451

# Parse config file with clients

1994

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

1995

"extended_timeout": "15m",

1996

"interval": "2m",

1997

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

1998

"host": "",

1999

"approval_delay": "0s",

2000

"approval_duration": "1s",

2001

}

2002

client_config = configparser.SafeConfigParser(client_defaults)

2452

client_config = configparser.SafeConfigParser(Client

2453

.client_defaults)

2003

2454

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

2004

2455

"clients.conf"))

2005

2456

2006

2457

global mandos_dbus_service

2007

2458

mandos_dbus_service = None

2008

2459

2460

socketfd = None

2461

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

2462

socketfd = server_settings["socket"]

2009

2463

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

2010

2464

server_settings["port"]),

2011

2465

ClientHandler,

2014

2468

use_ipv6=use_ipv6,

2015

2469

gnutls_priority=

2016

2470

server_settings["priority"],

2017

use_dbus=use_dbus)

2018

if not debug:

2019

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

2471

use_dbus=use_dbus,

2472

socketfd=socketfd)

2473

if not foreground:

2474

pidfilename = "/run/mandos.pid"

2475

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

2476

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

2477

pidfile = None

2020

2478

try:

2021

2479

pidfile = open(pidfilename, "w")

2022

except IOError:

2023

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

2480

except IOError as e:

2481

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

2482

exc_info=e)

2024

2483

2025

try:

2026

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

2027

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

2028

except KeyError:

2484

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

2029

2485

try:

2030

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

2031

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

2486

uid = pwd.getpwnam(name).pw_uid

2487

gid = pwd.getpwnam(name).pw_gid

2488

break

2032

2489

except KeyError:

2033

try:

2034

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

2035

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

2036

except KeyError:

2037

uid = 65534

2038

gid = 65534

2490

continue

2491

else:

2492

uid = 65534

2493

gid = 65534

2039

2494

try:

2040

2495

os.setgid(gid)

2041

2496

os.setuid(uid)

2042

2497

except OSError as error:

2043

if error[0] != errno.EPERM:

2044

raise error

2045

2046

if not debug and not debuglevel:

2047

logger.setLevel(logging.WARNING)

2048

if debuglevel:

2049

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

2050

logger.setLevel(level)

2498

if error.errno != errno.EPERM:

2499

raise

2051

2500

2052

2501

if debug:

2053

logger.setLevel(logging.DEBUG)

2054

2502

# Enable all possible GnuTLS debugging

2055

2503

2056

2504

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

2065

2513

.gnutls_global_set_log_function(debug_gnutls))

2066

2514

2067

2515

# Redirect stdin so all checkers get /dev/null

2068

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

2516

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

2069

2517

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

2070

2518

if null > 2:

2071

2519

os.close(null)

2072

else:

2073

# No console logging

2074

logger.removeHandler(console)

2075

2520

2076

2521

# Need to fork before connecting to D-Bus

2077

if not debug:

2522

if not foreground:

2078

2523

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

2079

2524

daemon()

2080

2525

2526

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

2527

# need to inform gobject that threads will be used.

2528

gobject.threads_init()

2529

2081

2530

global main_loop

2082

2531

# From the Avahi example code

2083

DBusGMainLoop(set_as_default=True )

2532

DBusGMainLoop(set_as_default=True)

2084

2533

main_loop = gobject.MainLoop()

2085

2534

bus = dbus.SystemBus()

2086

2535

# End of Avahi example code

2092

2541

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

2093

2542

do_not_queue=True))

2094

2543

except dbus.exceptions.NameExistsException as e:

2095

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

2544

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

2096

2545

use_dbus = False

2097

2546

server_settings["use_dbus"] = False

2098

2547

tcp_server.use_dbus = False

2099

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2100

service = AvahiServiceToSyslog(name =

2101

server_settings["servicename"],

2102

servicetype = "_mandos._tcp",

2103

protocol = protocol, bus = bus)

2104

if server_settings["interface"]:

2105

service.interface = (if_nametoindex

2106

(str(server_settings["interface"])))

2548

if zeroconf:

2549

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2550

service = AvahiServiceToSyslog(name =

2551

server_settings["servicename"],

2552

servicetype = "_mandos._tcp",

2553

protocol = protocol, bus = bus)

2554

if server_settings["interface"]:

2555

service.interface = (if_nametoindex

2556

(str(server_settings["interface"])))

2107

2557

2108

2558

global multiprocessing_manager

2109

2559

multiprocessing_manager = multiprocessing.Manager()

2110

2560

2111

2561

client_class = Client

2112

2562

if use_dbus:

2113

client_class = functools.partial(ClientDBusTransitional,

2114

bus = bus)

2115

2116

special_settings = {

2117

# Some settings need to be accessd by special methods;

2118

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

2119

"approved_by_default":

2120

lambda section:

2121

client_config.getboolean(section, "approved_by_default"),

2122

}

2123

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

2124

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

2125

# with exceptions for any special settings as defined above

2126

client_settings = dict((clientname,

2127

dict((setting,

2128

(value if setting not in special_settings

2129

else special_settings[setting](clientname)))

2130

for setting, value in client_config.items(clientname)))

2131

for clientname in client_config.sections())

2132

2563

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

2564

2565

client_settings = Client.config_parser(client_config)

2133

2566

old_client_settings = {}

2134

clients_data = []

2135

2136

# Get client data and settings from last running state.

2567

clients_data = {}

2568

2569

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

2570

global wnull

2571

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

2572

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

2573

# mode

2574

if debug or not foreground:

2575

wnull.close()

2576

2577

# Get client data and settings from last running state.

2137

2578

if server_settings["restore"]:

2138

2579

try:

2139

2580

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

2140

clients_data, old_client_settings = pickle.load(stored_state)

2581

clients_data, old_client_settings = (pickle.load

2582

(stored_state))

2141

2583

os.remove(stored_state_path)

2142

2584

except IOError as e:

2143

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

2144

if e.errno != errno.ENOENT:

2585

if e.errno == errno.ENOENT:

2586

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

2587

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

2588

else:

2589

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

2590

exc_info=e)

2145

2591

raise

2146

2147

for client in clients_data:

2148

client_name = client["name"]

2149

2150

# Decide which value to use after restoring saved state.

2151

# We have three different values: Old config file,

2152

# new config file, and saved state.

2153

# New config value takes precedence if it differs from old

2154

# config value, otherwise use saved state.

2155

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

2592

except EOFError as e:

2593

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

2594

"EOFError:", exc_info=e)

2595

2596

with PGPEngine() as pgp:

2597

for client_name, client in clients_data.iteritems():

2598

# Skip removed clients

2599

if client_name not in client_settings:

2600

continue

2601

2602

# Decide which value to use after restoring saved state.

2603

# We have three different values: Old config file,

2604

# new config file, and saved state.

2605

# New config value takes precedence if it differs from old

2606

# config value, otherwise use saved state.

2607

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

2608

try:

2609

# For each value in new config, check if it

2610

# differs from the old config value (Except for

2611

# the "secret" attribute)

2612

if (name != "secret" and

2613

value != old_client_settings[client_name]

2614

[name]):

2615

client[name] = value

2616

except KeyError:

2617

pass

2618

2619

# Clients who has passed its expire date can still be

2620

# enabled if its last checker was successful. Clients

2621

# whose checker succeeded before we stored its state is

2622

# assumed to have successfully run all checkers during

2623

# downtime.

2624

if client["enabled"]:

2625

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

2626

if not client["last_checked_ok"]:

2627

logger.warning(

2628

"disabling client {0} - Client never "

2629

"performed a successful checker"

2630

.format(client_name))

2631

client["enabled"] = False

2632

elif client["last_checker_status"] != 0:

2633

logger.warning(

2634

"disabling client {0} - Client "

2635

"last checker failed with error code {1}"

2636

.format(client_name,

2637

client["last_checker_status"]))

2638

client["enabled"] = False

2639

else:

2640

client["expires"] = (datetime.datetime

2641

.utcnow()

2642

+ client["timeout"])

2643

logger.debug("Last checker succeeded,"

2644

" keeping {0} enabled"

2645

.format(client_name))

2156

2646

try:

2157

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

2158

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

2159

# attribute)

2160

if name != "secret" and value != old_client_settings[client_name][name]:

2161

setattr(client, name, value)

2162

except KeyError:

2163

pass

2164

2165

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

2166

# last checker was sucessful. Clients who checkers failed before we

2167

# stored it state is asumed to had failed checker during downtime.

2168

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

2169

if ((datetime.datetime.utcnow() - client["last_checked_ok"])

2170

> client["interval"]):

2171

if client["last_checker_status"] != 0:

2172

client["enabled"] = False

2173

else:

2174

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

2175

2176

client["changedstate"] = (multiprocessing_manager

2177

.Condition(multiprocessing_manager

2178

.Lock()))

2179

if use_dbus:

2180

new_client = ClientDBusTransitional.__new__(ClientDBusTransitional)

2181

tcp_server.clients[client_name] = new_client

2182

new_client.bus = bus

2183

for name, value in client.iteritems():

2184

setattr(new_client, name, value)

2185

client_object_name = unicode(client_name).translate(

2186

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

2187

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

2188

new_client.dbus_object_path = (dbus.ObjectPath

2189

("/clients/" + client_object_name))

2190

DBusObjectWithProperties.__init__(new_client,

2191

new_client.bus,

2192

new_client.dbus_object_path)

2193

else:

2194

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

2195

for name, value in client.iteritems():

2196

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

2197

2198

tcp_server.clients[client_name].decrypt_secret(

2199

client_settings[client_name]["secret"])

2200

2201

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

2202

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

2203

del tcp_server.clients[clientname]

2204

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

2205

tcp_server.clients[clientname] = (client_class(name = clientname,

2206

config =

2207

client_settings

2208

[clientname]))

2209

2210

2647

client["secret"] = (

2648

pgp.decrypt(client["encrypted_secret"],

2649

client_settings[client_name]

2650

["secret"]))

2651

except PGPError:

2652

# If decryption fails, we use secret from new settings

2653

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

2654

.format(client_name))

2655

client["secret"] = (

2656

client_settings[client_name]["secret"])

2657

2658

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

2659

for client_name in (set(old_client_settings)

2660

- set(client_settings)):

2661

del clients_data[client_name]

2662

for client_name in (set(client_settings)

2663

- set(old_client_settings)):

2664

clients_data[client_name] = client_settings[client_name]

2665

2666

# Create all client objects

2667

for client_name, client in clients_data.iteritems():

2668

tcp_server.clients[client_name] = client_class(

2669

name = client_name, settings = client,

2670

server_settings = server_settings)

2671

2211

2672

if not tcp_server.clients:

2212

2673

logger.warning("No clients defined")

2213

2214

if not debug:

2215

try:

2216

with pidfile:

2217

pid = os.getpid()

2218

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

2219

del pidfile

2220

except IOError:

2221

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

2222

pidfilename, pid)

2223

except NameError:

2224

# "pidfile" was never created

2225

pass

2674

2675

if not foreground:

2676

if pidfile is not None:

2677

try:

2678

with pidfile:

2679

pid = os.getpid()

2680

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

2681

except IOError:

2682

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

2683

pidfilename, pid)

2684

del pidfile

2226

2685

del pidfilename

2227

2228

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

2229

2686

2230

2687

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

2231

2688

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

2232

2689

2233

2690

if use_dbus:

2234

class MandosDBusService(dbus.service.Object):

2691

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

2692

"se.bsnet.fukt.Mandos"})

2693

class MandosDBusService(DBusObjectWithProperties):

2235

2694

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

2236

2695

def __init__(self):

2237

2696

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

2238

2697

_interface = "se.recompile.Mandos"

2239

2698

2699

@dbus_interface_annotations(_interface)

2700

def _foo(self):

2701

return { "org.freedesktop.DBus.Property"

2702

".EmitsChangedSignal":

2703

"false"}

2704

2240

2705

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

2241

2706

def ClientAdded(self, objpath):

2242

2707

"D-Bus signal"

2284

2749

2285

2750

del _interface

2286

2751

2287

class MandosDBusServiceTransitional(MandosDBusService):

2288

__metaclass__ = AlternateDBusNamesMetaclass

2289

mandos_dbus_service = MandosDBusServiceTransitional()

2752

mandos_dbus_service = MandosDBusService()

2290

2753

2291

2754

def cleanup():

2292

2755

"Cleanup function; run on exit"

2293

service.cleanup()

2756

if zeroconf:

2757

service.cleanup()

2294

2758

2295

2759

multiprocessing.active_children()

2760

wnull.close()

2296

2761

if not (tcp_server.clients or client_settings):

2297

2762

return

2298

2299

# Store client before exiting. Secrets are encrypted with key based

2300

# on what config file has. If config file is removed/edited, old

2301

# secret will thus be unrecovable.

2302

clients = []

2303

for client in tcp_server.clients.itervalues():

2304

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

2305

2306

client_dict = {}

2307

2308

# A list of attributes that will not be stored when shuting down.

2309

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

2310

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

2311

exclude.add(name)

2312

2313

client_dict["encrypted_secret"] = client.encrypted_secret

2314

for attr in client.client_structure:

2315

if attr not in exclude:

2316

client_dict[attr] = getattr(client, attr)

2317

2318

clients.append(client_dict)

2319

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

2320

2763

2764

# Store client before exiting. Secrets are encrypted with key

2765

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

2766

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

2767

clients = {}

2768

with PGPEngine() as pgp:

2769

for client in tcp_server.clients.itervalues():

2770

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

2771

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

2772

key)

2773

client_dict = {}

2774

2775

# A list of attributes that can not be pickled

2776

# + secret.

2777

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

2778

"checker", "server_settings"))

2779

for name, typ in (inspect.getmembers

2780

(dbus.service.Object)):

2781

exclude.add(name)

2782

2783

client_dict["encrypted_secret"] = (client

2784

.encrypted_secret)

2785

for attr in client.client_structure:

2786

if attr not in exclude:

2787

client_dict[attr] = getattr(client, attr)

2788

2789

clients[client.name] = client_dict

2790

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

2791

2321

2792

try:

2322

with os.fdopen(os.open(stored_state_path, os.O_CREAT|os.O_WRONLY|os.O_TRUNC, 0600), "wb") as stored_state:

2793

with (tempfile.NamedTemporaryFile

2794

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

2795

dir=os.path.dirname(stored_state_path),

2796

delete=False)) as stored_state:

2323

2797

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

2324

except IOError as e:

2325

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

2326

if e.errno != errno.ENOENT:

2798

tempname=stored_state.name

2799

os.rename(tempname, stored_state_path)

2800

except (IOError, OSError) as e:

2801

if not debug:

2802

try:

2803

os.remove(tempname)

2804

except NameError:

2805

pass

2806

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

2807

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

2808

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

2809

else:

2810

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

2811

exc_info=e)

2327

2812

raise

2328

2813

2329

2814

# Delete all clients, and settings from config

2330

2815

while tcp_server.clients:

2331

2816

name, client = tcp_server.clients.popitem()

2349

2834

# Need to initiate checking of clients

2350

2835

if client.enabled:

2351

2836

client.init_checker()

2352

2353

2837

2354

2838

tcp_server.enable()

2355

2839

tcp_server.server_activate()

2356

2840

2357

2841

# Find out what port we got

2358

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

2842

if zeroconf:

2843

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

2359

2844

if use_ipv6:

2360

2845

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

2361

" flowinfo %d, scope_id %d"

2362

% tcp_server.socket.getsockname())

2846

" flowinfo %d, scope_id %d",

2847

*tcp_server.socket.getsockname())

2363

2848

else: # IPv4

2364

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

2365

% tcp_server.socket.getsockname())

2849

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

2850

*tcp_server.socket.getsockname())

2366

2851

2367

2852

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

2368

2853

2369

2854

try:

2370

# From the Avahi example code

2371

try:

2372

service.activate()

2373

except dbus.exceptions.DBusException as error:

2374

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

2375

cleanup()

2376

sys.exit(1)

2377

# End of Avahi example code

2855

if zeroconf:

2856

# From the Avahi example code

2857

try:

2858

service.activate()

2859

except dbus.exceptions.DBusException as error:

2860

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

2861

cleanup()

2862

sys.exit(1)

2863

# End of Avahi example code

2378

2864

2379

2865

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

2380

2866

lambda *args, **kwargs:

2384

2870

logger.debug("Starting main loop")

2385

2871

main_loop.run()

2386

2872

except AvahiError as error:

2387

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

2873

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

2388

2874

cleanup()

2389

2875

sys.exit(1)

2390

2876

except KeyboardInterrupt:

2395

2881

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

2396

2882

cleanup()

2397

2883

2398

2399

2884

if __name__ == '__main__':

2400

2885

main()