/mandos/trunk : revision 505.2.2

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

65

63

import cPickle as pickle

66

64

import multiprocessing

67

65

import types

68

import binascii

69

import tempfile

70

import itertools

71

import collections

72

66

73

67

import dbus

74

68

import dbus.service

79

73

import ctypes.util

80

74

import xml.dom.minidom

81

75

import inspect

82

import GnuPGInterface

83

76

84

77

try:

85

78

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

89

82

except ImportError:

90

83

SO_BINDTODEVICE = None

91

84

92

version = "1.6.0"

93

stored_state_file = "clients.pickle"

94

95

logger = logging.getLogger()

85

86

version = "1.4.1"

87

88

#logger = logging.getLogger('mandos')

89

logger = logging.Logger('mandos')

96

90

syslogger = (logging.handlers.SysLogHandler

97

91

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

98

92

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

99

100

try:

101

if_nametoindex = (ctypes.cdll.LoadLibrary

102

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

103

.if_nametoindex)

104

except (OSError, AttributeError):

105

def if_nametoindex(interface):

106

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

107

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

108

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

109

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

110

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

111

interface))

112

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

113

ifreq[16:20])[0]

114

return interface_index

115

116

117

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

118

"""init logger and add loglevel"""

119

120

syslogger.setFormatter(logging.Formatter

121

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

122

' %(message)s'))

123

logger.addHandler(syslogger)

124

125

if debug:

126

console = logging.StreamHandler()

127

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

128

' [%(process)d]:'

129

' %(levelname)s:'

130

' %(message)s'))

131

logger.addHandler(console)

132

logger.setLevel(level)

133

134

135

class PGPError(Exception):

136

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

137

pass

138

139

140

class PGPEngine(object):

141

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

142

def __init__(self):

143

self.gnupg = GnuPGInterface.GnuPG()

144

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

145

self.gnupg = GnuPGInterface.GnuPG()

146

self.gnupg.options.meta_interactive = False

147

self.gnupg.options.homedir = self.tempdir

148

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

149

'--quiet',

150

'--no-use-agent'])

151

152

def __enter__(self):

153

return self

154

155

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

156

self._cleanup()

157

return False

158

159

def __del__(self):

160

self._cleanup()

161

162

def _cleanup(self):

163

if self.tempdir is not None:

164

# Delete contents of tempdir

165

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

166

topdown = False):

167

for filename in files:

168

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

169

for dirname in dirs:

170

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

171

# Remove tempdir

172

os.rmdir(self.tempdir)

173

self.tempdir = None

174

175

def password_encode(self, password):

176

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

177

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

178

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

179

180

def encrypt(self, data, password):

181

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

182

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

183

try:

184

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

185

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

186

attach_fhs={'stderr': devnull})

187

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

188

f.write(data)

189

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

190

ciphertext = f.read()

191

proc.wait()

192

except IOError as e:

193

raise PGPError(e)

194

self.gnupg.passphrase = None

195

return ciphertext

196

197

def decrypt(self, data, password):

198

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

199

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

200

try:

201

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

202

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

203

attach_fhs={'stderr': devnull})

204

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

205

f.write(data)

206

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

207

decrypted_plaintext = f.read()

208

proc.wait()

209

except IOError as e:

210

raise PGPError(e)

211

self.gnupg.passphrase = None

212

return decrypted_plaintext

213

93

syslogger.setFormatter(logging.Formatter

94

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

95

' %(message)s'))

96

logger.addHandler(syslogger)

97

98

console = logging.StreamHandler()

99

console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'

100

' %(levelname)s:'

101

' %(message)s'))

102

logger.addHandler(console)

214

103

215

104

class AvahiError(Exception):

216

105

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

246

135

server: D-Bus Server

247

136

bus: dbus.SystemBus()

248

137

"""

249

250

138

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

251

139

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

252

140

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

265

153

self.server = None

266

154

self.bus = bus

267

155

self.entry_group_state_changed_match = None

268

269

156

def rename(self):

270

157

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

271

158

if self.rename_count >= self.max_renames:

277

164

.GetAlternativeServiceName(self.name))

278

165

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

279

166

self.name)

167

syslogger.setFormatter(logging.Formatter

168

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

169

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

170

% self.name))

280

171

self.remove()

281

172

try:

282

173

self.add()

283

174

except dbus.exceptions.DBusException as error:

284

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

175

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

285

176

self.cleanup()

286

177

os._exit(1)

287

178

self.rename_count += 1

288

289

179

def remove(self):

290

180

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

291

181

if self.entry_group_state_changed_match is not None:

293

183

self.entry_group_state_changed_match = None

294

184

if self.group is not None:

295

185

self.group.Reset()

296

297

186

def add(self):

298

187

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

299

188

self.remove()

304

193

avahi.DBUS_INTERFACE_ENTRY_GROUP)

305

194

self.entry_group_state_changed_match = (

306

195

self.group.connect_to_signal(

307

'StateChanged', self.entry_group_state_changed))

196

'StateChanged', self .entry_group_state_changed))

308

197

logger.debug("Adding Zeroconf service '%s' of type '%s' ...",

309

198

self.name, self.type)

310

199

self.group.AddService(

316

205

dbus.UInt16(self.port),

317

206

avahi.string_array_to_txt_array(self.TXT))

318

207

self.group.Commit()

319

320

208

def entry_group_state_changed(self, state, error):

321

209

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

322

210

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

329

217

elif state == avahi.ENTRY_GROUP_FAILURE:

330

218

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

331

219

unicode(error))

332

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

333

.format(error))

334

220

raise AvahiGroupError("State changed: %s"

221

% unicode(error))

335

222

def cleanup(self):

336

223

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

337

224

if self.group is not None:

338

225

try:

339

226

self.group.Free()

340

227

except (dbus.exceptions.UnknownMethodException,

341

dbus.exceptions.DBusException):

228

dbus.exceptions.DBusException) as e:

342

229

pass

343

230

self.group = None

344

231

self.remove()

345

346

232

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

347

233

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

348

234

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

367

253

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

368

254

else:

369

255

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

370

371

256

def activate(self):

372

257

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

373

258

if self.server is None:

381

266

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

382

267

383

268

384

class AvahiServiceToSyslog(AvahiService):

385

def rename(self):

386

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

387

ret = AvahiService.rename(self)

388

syslogger.setFormatter(logging.Formatter

389

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

390

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

391

.format(self.name)))

392

return ret

393

394

395

def timedelta_to_milliseconds(td):

269

def _timedelta_to_milliseconds(td):

396

270

"Convert a datetime.timedelta() to milliseconds"

397

271

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

398

272

+ (td.seconds * 1000)

399

273

+ (td.microseconds // 1000))

400

401

274

402

275

class Client(object):

403

276

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

404

277

405

278

Attributes:

406

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

279

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

407

280

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

408

281

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

409

282

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

416

289

instance %(name)s can be used in the command.

417

290

checker_initiator_tag: a gobject event source tag, or None

418

291

created: datetime.datetime(); (UTC) object creation

419

client_structure: Object describing what attributes a client has

420

and is used for storing the client at exit

421

292

current_checker_command: string; current running checker_command

293

disable_hook: If set, called by disable() as disable_hook(self)

422

294

disable_initiator_tag: a gobject event source tag, or None

423

295

enabled: bool()

424

296

fingerprint: string (40 or 32 hexadecimal digits); used to

427

299

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

428

300

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

429

301

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

430

last_checker_status: integer between 0 and 255 reflecting exit

431

status of last checker. -1 reflects crashed

432

checker, -2 means no checker completed yet.

433

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

302

last_enabled: datetime.datetime(); (UTC)

434

303

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

435

304

D-Bus identifiers

436

305

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

437

306

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

438

307

until this client is disabled

439

extended_timeout: extra long timeout when secret has been sent

308

extended_timeout: extra long timeout when password has been sent

440

309

runtime_expansions: Allowed attributes for runtime expansion.

441

310

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

442

311

disabled, or None

443

312

"""

444

313

445

314

runtime_expansions = ("approval_delay", "approval_duration",

446

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

447

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

448

"last_approval_request", "last_checked_ok",

315

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

316

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

449

317

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

450

client_defaults = { "timeout": "PT5M",

451

"extended_timeout": "PT15M",

452

"interval": "PT2M",

453

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

454

"host": "",

455

"approval_delay": "PT0S",

456

"approval_duration": "PT1S",

457

"approved_by_default": "True",

458

"enabled": "True",

459

}

460

318

461

319

def timeout_milliseconds(self):

462

320

"Return the 'timeout' attribute in milliseconds"

463

return timedelta_to_milliseconds(self.timeout)

321

return _timedelta_to_milliseconds(self.timeout)

464

322

465

323

def extended_timeout_milliseconds(self):

466

324

"Return the 'extended_timeout' attribute in milliseconds"

467

return timedelta_to_milliseconds(self.extended_timeout)

325

return _timedelta_to_milliseconds(self.extended_timeout)

468

326

469

327

def interval_milliseconds(self):

470

328

"Return the 'interval' attribute in milliseconds"

471

return timedelta_to_milliseconds(self.interval)

329

return _timedelta_to_milliseconds(self.interval)

472

330

473

331

def approval_delay_milliseconds(self):

474

return timedelta_to_milliseconds(self.approval_delay)

475

476

@staticmethod

477

def config_parser(config):

478

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

479

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

480

with exceptions for any special settings as defined above.

481

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

482

value given the same arguments.

483

"""

484

settings = {}

485

for client_name in config.sections():

486

section = dict(config.items(client_name))

487

client = settings[client_name] = {}

488

489

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

490

# Reformat values from string types to Python types

491

client["approved_by_default"] = config.getboolean(

492

client_name, "approved_by_default")

493

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

494

"enabled")

495

496

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

497

.replace(" ", ""))

498

if "secret" in section:

499

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

500

elif "secfile" in section:

501

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

502

(section["secfile"])),

503

"rb") as secfile:

504

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

505

else:

506

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

507

.format(section))

508

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

509

client["extended_timeout"] = string_to_delta(

510

section["extended_timeout"])

511

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

512

client["approval_delay"] = string_to_delta(

513

section["approval_delay"])

514

client["approval_duration"] = string_to_delta(

515

section["approval_duration"])

516

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

517

client["last_approval_request"] = None

518

client["last_checked_ok"] = None

519

client["last_checker_status"] = -2

520

521

return settings

522

523

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

332

return _timedelta_to_milliseconds(self.approval_delay)

333

334

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

335

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

336

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

337

attribute."""

524

338

self.name = name

525

# adding all client settings

526

for setting, value in settings.iteritems():

527

setattr(self, setting, value)

528

529

if self.enabled:

530

if not hasattr(self, "last_enabled"):

531

self.last_enabled = datetime.datetime.utcnow()

532

if not hasattr(self, "expires"):

533

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

534

+ self.timeout)

535

else:

536

self.last_enabled = None

537

self.expires = None

538

339

if config is None:

340

config = {}

539

341

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

540

342

# Uppercase and remove spaces from fingerprint for later

541

343

# comparison purposes with return value from the fingerprint()

542

344

# function

345

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

346

.replace(" ", ""))

543

347

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

544

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

545

datetime.datetime.utcnow())

546

547

# attributes specific for this server instance

348

if "secret" in config:

349

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

350

elif "secfile" in config:

351

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

352

(config["secfile"])),

353

"rb") as secfile:

354

self.secret = secfile.read()

355

else:

356

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

357

% self.name)

358

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

359

self.created = datetime.datetime.utcnow()

360

self.enabled = False

361

self.last_approval_request = None

362

self.last_enabled = None

363

self.last_checked_ok = None

364

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

365

self.extended_timeout = string_to_delta(config

366

["extended_timeout"])

367

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

368

self.disable_hook = disable_hook

548

369

self.checker = None

549

370

self.checker_initiator_tag = None

550

371

self.disable_initiator_tag = None

372

self.expires = None

551

373

self.checker_callback_tag = None

374

self.checker_command = config["checker"]

552

375

self.current_checker_command = None

553

self.approved = None

376

self.last_connect = None

377

self._approved = None

378

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

379

True)

554

380

self.approvals_pending = 0

381

self.approval_delay = string_to_delta(

382

config["approval_delay"])

383

self.approval_duration = string_to_delta(

384

config["approval_duration"])

555

385

self.changedstate = (multiprocessing_manager

556

386

.Condition(multiprocessing_manager

557

387

.Lock()))

558

self.client_structure = [attr for attr in

559

self.__dict__.iterkeys()

560

if not attr.startswith("_")]

561

self.client_structure.append("client_structure")

562

563

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

564

lambda obj:

565

isinstance(obj,

566

property)):

567

if not name.startswith("_"):

568

self.client_structure.append(name)

569

388

570

# Send notice to process children that client state has changed

571

389

def send_changedstate(self):

572

with self.changedstate:

573

self.changedstate.notify_all()

390

self.changedstate.acquire()

391

self.changedstate.notify_all()

392

self.changedstate.release()

574

393

575

394

def enable(self):

576

395

"""Start this client's checker and timeout hooks"""

577

396

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

578

397

# Already enabled

579

398

return

580

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

581

self.enabled = True

582

self.last_enabled = datetime.datetime.utcnow()

583

self.init_checker()

584

399

self.send_changedstate()

585

586

def disable(self, quiet=True):

587

"""Disable this client."""

588

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

589

return False

590

if not quiet:

591

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

592

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

593

gobject.source_remove(self.disable_initiator_tag)

594

self.disable_initiator_tag = None

595

self.expires = None

596

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

597

gobject.source_remove(self.checker_initiator_tag)

598

self.checker_initiator_tag = None

599

self.stop_checker()

600

self.enabled = False

601

if not quiet:

602

self.send_changedstate()

603

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

604

return False

605

606

def __del__(self):

607

self.disable()

608

609

def init_checker(self):

610

400

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

611

401

# and every interval from then on.

612

if self.checker_initiator_tag is not None:

613

gobject.source_remove(self.checker_initiator_tag)

614

402

self.checker_initiator_tag = (gobject.timeout_add

615

403

(self.interval_milliseconds(),

616

404

self.start_checker))

617

405

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

618

if self.disable_initiator_tag is not None:

619

gobject.source_remove(self.disable_initiator_tag)

406

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

620

407

self.disable_initiator_tag = (gobject.timeout_add

621

408

(self.timeout_milliseconds(),

622

409

self.disable))

410

self.enabled = True

411

self.last_enabled = datetime.datetime.utcnow()

623

412

# Also start a new checker *right now*.

624

413

self.start_checker()

625

414

415

def disable(self, quiet=True):

416

"""Disable this client."""

417

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

418

return False

419

if not quiet:

420

self.send_changedstate()

421

if not quiet:

422

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

423

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

424

gobject.source_remove(self.disable_initiator_tag)

425

self.disable_initiator_tag = None

426

self.expires = None

427

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

428

gobject.source_remove(self.checker_initiator_tag)

429

self.checker_initiator_tag = None

430

self.stop_checker()

431

if self.disable_hook:

432

self.disable_hook(self)

433

self.enabled = False

434

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

435

return False

436

437

def __del__(self):

438

self.disable_hook = None

439

self.disable()

440

626

441

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

627

442

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

628

443

self.checker_callback_tag = None

629

444

self.checker = None

630

445

if os.WIFEXITED(condition):

631

self.last_checker_status = os.WEXITSTATUS(condition)

632

if self.last_checker_status == 0:

446

exitstatus = os.WEXITSTATUS(condition)

447

if exitstatus == 0:

633

448

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

634

449

vars(self))

635

450

self.checked_ok()

637

452

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

638

453

vars(self))

639

454

else:

640

self.last_checker_status = -1

641

455

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

642

456

vars(self))

643

457

644

def checked_ok(self):

645

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

646

self.last_checked_ok = datetime.datetime.utcnow()

647

self.last_checker_status = 0

648

self.bump_timeout()

649

650

def bump_timeout(self, timeout=None):

651

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

458

def checked_ok(self, timeout=None):

459

"""Bump up the timeout for this client.

460

461

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

462

alive and well.

463

"""

652

464

if timeout is None:

653

465

timeout = self.timeout

466

self.last_checked_ok = datetime.datetime.utcnow()

654

467

if self.disable_initiator_tag is not None:

655

468

gobject.source_remove(self.disable_initiator_tag)

656

self.disable_initiator_tag = None

657

469

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

658

470

self.disable_initiator_tag = (gobject.timeout_add

659

(timedelta_to_milliseconds

471

(_timedelta_to_milliseconds

660

472

(timeout), self.disable))

661

473

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

662

474

669

481

If a checker already exists, leave it running and do

670

482

nothing."""

671

483

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

672

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

673

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

674

# would inevitably timeout, since no checker would get a

675

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

484

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

485

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

486

# client would inevitably timeout, since no checker would get

487

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

676

488

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

677

489

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

678

490

# should be.

692

504

self.current_checker_command)

693

505

# Start a new checker if needed

694

506

if self.checker is None:

695

# Escape attributes for the shell

696

escaped_attrs = dict(

697

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

698

for attr in

699

self.runtime_expansions)

700

507

try:

701

command = self.checker_command % escaped_attrs

702

except TypeError as error:

703

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

704

self.checker_command, exc_info=error)

705

return True # Try again later

508

# In case checker_command has exactly one % operator

509

command = self.checker_command % self.host

510

except TypeError:

511

# Escape attributes for the shell

512

escaped_attrs = dict(

513

(attr,

514

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

515

errors=

516

'replace')))

517

for attr in

518

self.runtime_expansions)

519

520

try:

521

command = self.checker_command % escaped_attrs

522

except TypeError as error:

523

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

524

' %s', self.checker_command, error)

525

return True # Try again later

706

526

self.current_checker_command = command

707

527

try:

708

528

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

714

534

self.checker = subprocess.Popen(command,

715

535

close_fds=True,

716

536

shell=True, cwd="/")

717

except OSError as error:

718

logger.error("Failed to start subprocess",

719

exc_info=error)

720

return True

721

self.checker_callback_tag = (gobject.child_watch_add

722

(self.checker.pid,

723

self.checker_callback,

724

data=command))

725

# The checker may have completed before the gobject

726

# watch was added. Check for this.

727

try:

537

self.checker_callback_tag = (gobject.child_watch_add

538

(self.checker.pid,

539

self.checker_callback,

540

data=command))

541

# The checker may have completed before the gobject

542

# watch was added. Check for this.

728

543

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

544

if pid:

545

gobject.source_remove(self.checker_callback_tag)

546

self.checker_callback(pid, status, command)

729

547

except OSError as error:

730

if error.errno == errno.ECHILD:

731

logger.error("Child process vanished", exc_info=error)

732

return True

733

raise

734

if pid:

735

gobject.source_remove(self.checker_callback_tag)

736

self.checker_callback(pid, status, command)

548

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

549

error)

737

550

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

738

551

return True

739

552

746

559

return

747

560

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

748

561

try:

749

self.checker.terminate()

562

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

750

563

#time.sleep(0.5)

751

564

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

752

# self.checker.kill()

565

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

753

566

except OSError as error:

754

567

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

755

568

raise

772

585

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

773

586

if byte_arrays and signature != "ay":

774

587

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

775

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

588

" signature %r" % signature)

776

589

def decorator(func):

777

590

func._dbus_is_property = True

778

591

func._dbus_interface = dbus_interface

786

599

return decorator

787

600

788

601

789

def dbus_interface_annotations(dbus_interface):

790

"""Decorator for marking functions returning interface annotations

791

792

Usage:

793

794

@dbus_interface_annotations("org.example.Interface")

795

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

796

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

797

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

798

"false"}

799

"""

800

def decorator(func):

801

func._dbus_is_interface = True

802

func._dbus_interface = dbus_interface

803

func._dbus_name = dbus_interface

804

return func

805

return decorator

806

807

808

def dbus_annotations(annotations):

809

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

810

Usage:

811

812

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

813

access="r")

814

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

815

"org.freedesktop.DBus.Property."

816

"EmitsChangedSignal": "false"})

817

def Property_dbus_property(self):

818

return dbus.Boolean(False)

819

"""

820

def decorator(func):

821

func._dbus_annotations = annotations

822

return func

823

return decorator

824

825

826

602

class DBusPropertyException(dbus.exceptions.DBusException):

827

603

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

828

604

"""

851

627

"""

852

628

853

629

@staticmethod

854

def _is_dbus_thing(thing):

855

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

856

857

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

858

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

859

"""

860

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

861

False)

630

def _is_dbus_property(obj):

631

return getattr(obj, "_dbus_is_property", False)

862

632

863

def _get_all_dbus_things(self, thing):

633

def _get_all_dbus_properties(self):

864

634

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

865

635

"""

866

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

867

name),

868

athing.__get__(self))

636

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

869

637

for cls in self.__class__.__mro__

870

for name, athing in

871

inspect.getmembers(cls,

872

self._is_dbus_thing(thing)))

638

for name, prop in

639

inspect.getmembers(cls, self._is_dbus_property))

873

640

874

641

def _get_dbus_property(self, interface_name, property_name):

875

642

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

877

644

"""

878

645

for cls in self.__class__.__mro__:

879

646

for name, value in (inspect.getmembers

880

(cls,

881

self._is_dbus_thing("property"))):

647

(cls, self._is_dbus_property)):

882

648

if (value._dbus_name == property_name

883

649

and value._dbus_interface == interface_name):

884

650

return value.__get__(self)

913

679

# signatures other than "ay".

914

680

if prop._dbus_signature != "ay":

915

681

raise ValueError

916

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

917

for byte in value))

682

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

683

for byte in value))

918

684

prop(value)

919

685

920

686

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

925

691

926

692

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

927

693

"""

928

properties = {}

929

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

694

all = {}

695

for name, prop in self._get_all_dbus_properties():

930

696

if (interface_name

931

697

and interface_name != prop._dbus_interface):

932

698

# Interface non-empty but did not match

936

702

continue

937

703

value = prop()

938

704

if not hasattr(value, "variant_level"):

939

properties[name] = value

705

all[name] = value

940

706

continue

941

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

942

value.variant_level+1)

943

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

707

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

708

value.variant_level+1)

709

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

944

710

945

711

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

946

712

out_signature="s",

947

713

path_keyword='object_path',

948

714

connection_keyword='connection')

949

715

def Introspect(self, object_path, connection):

950

"""Overloading of standard D-Bus method.

951

952

Inserts property tags and interface annotation tags.

716

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

953

717

"""

954

718

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

955

719

connection)

962

726

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

963

727

return e

964

728

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

965

# Add property tags

966

729

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

967

730

for name, prop

968

in self._get_all_dbus_things("property")

731

in self._get_all_dbus_properties()

969

732

if prop._dbus_interface

970

733

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

971

734

if_tag.appendChild(tag)

972

# Add annotation tags

973

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

974

for tag in if_tag.getElementsByTagName(typ):

975

annots = dict()

976

for name, prop in (self.

977

_get_all_dbus_things(typ)):

978

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

979

and prop._dbus_interface

980

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

981

annots.update(getattr

982

(prop,

983

"_dbus_annotations",

984

{}))

985

for name, value in annots.iteritems():

986

ann_tag = document.createElement(

987

"annotation")

988

ann_tag.setAttribute("name", name)

989

ann_tag.setAttribute("value", value)

990

tag.appendChild(ann_tag)

991

# Add interface annotation tags

992

for annotation, value in dict(

993

itertools.chain.from_iterable(

994

annotations().iteritems()

995

for name, annotations in

996

self._get_all_dbus_things("interface")

997

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

998

)).iteritems():

999

ann_tag = document.createElement("annotation")

1000

ann_tag.setAttribute("name", annotation)

1001

ann_tag.setAttribute("value", value)

1002

if_tag.appendChild(ann_tag)

1003

735

# Add the names to the return values for the

1004

736

# "org.freedesktop.DBus.Properties" methods

1005

737

if (if_tag.getAttribute("name")

1020

752

except (AttributeError, xml.dom.DOMException,

1021

753

xml.parsers.expat.ExpatError) as error:

1022

754

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

1023

exc_info=error)

755

error)

1024

756

return xmlstring

1025

757

1026

758

1027

def datetime_to_dbus(dt, variant_level=0):

759

def datetime_to_dbus (dt, variant_level=0):

1028

760

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

1029

761

if dt is None:

1030

762

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

1031

763

return dbus.String(dt.isoformat(),

1032

764

variant_level=variant_level)

1033

765

1034

1035

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1036

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

1037

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

1038

interface names according to the "alt_interface_names" mapping.

1039

Usage:

1040

1041

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

1042

"net.example.AlternateInterface"})

1043

class SampleDBusObject(dbus.service.Object):

1044

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

1045

def SampleDBusMethod():

1046

pass

1047

1048

The above "SampleDBusMethod" on "SampleDBusObject" will be

1049

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

1050

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

1051

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

1052

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

1053

1054

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

1055

(from DBusObjectWithProperties) and interfaces (from the

1056

dbus_interface_annotations decorator).

766

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

767

.__metaclass__):

768

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

769

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

1057

770

"""

1058

def wrapper(cls):

1059

for orig_interface_name, alt_interface_name in (

1060

alt_interface_names.iteritems()):

1061

attr = {}

1062

interface_names = set()

1063

# Go though all attributes of the class

1064

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

771

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

772

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

773

# methods, signals, or properties in them

774

for base in (b for b in bases

775

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

776

# Go though all attributes of the base class

777

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

1065

778

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

1066

779

# with the wrong interface name

1067

780

if (not hasattr(attribute, "_dbus_interface")

1068

781

or not attribute._dbus_interface

1069

.startswith(orig_interface_name)):

782

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

1070

783

continue

1071

784

# Create an alternate D-Bus interface name based on

1072

785

# the current name

1073

786

alt_interface = (attribute._dbus_interface

1074

.replace(orig_interface_name,

1075

alt_interface_name))

1076

interface_names.add(alt_interface)

787

.replace("se.recompile.Mandos",

788

"se.bsnet.fukt.Mandos"))

1077

789

# Is this a D-Bus signal?

1078

790

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

1079

791

# Extract the original non-method function by

1094

806

nonmethod_func.func_name,

1095

807

nonmethod_func.func_defaults,

1096

808

nonmethod_func.func_closure)))

1097

# Copy annotations, if any

1098

try:

1099

new_function._dbus_annotations = (

1100

dict(attribute._dbus_annotations))

1101

except AttributeError:

1102

pass

1103

809

# Define a creator of a function to call both the

1104

# original and alternate functions, so both the

1105

# original and alternate signals gets sent when

1106

# the function is called

810

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

811

# signals gets sent when the function is called

1107

812

def fixscope(func1, func2):

1108

813

"""This function is a scope container to pass

1109

814

func1 and func2 to the "call_both" function

1116

821

return call_both

1117

822

# Create the "call_both" function and add it to

1118

823

# the class

1119

attr[attrname] = fixscope(attribute, new_function)

824

attr[attrname] = fixscope(attribute,

825

new_function)

1120

826

# Is this a D-Bus method?

1121

827

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

1122

828

# Create a new, but exactly alike, function

1133

839

attribute.func_name,

1134

840

attribute.func_defaults,

1135

841

attribute.func_closure)))

1136

# Copy annotations, if any

1137

try:

1138

attr[attrname]._dbus_annotations = (

1139

dict(attribute._dbus_annotations))

1140

except AttributeError:

1141

pass

1142

842

# Is this a D-Bus property?

1143

843

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

1144

844

# Create a new, but exactly alike, function

1158

858

attribute.func_name,

1159

859

attribute.func_defaults,

1160

860

attribute.func_closure)))

1161

# Copy annotations, if any

1162

try:

1163

attr[attrname]._dbus_annotations = (

1164

dict(attribute._dbus_annotations))

1165

except AttributeError:

1166

pass

1167

# Is this a D-Bus interface?

1168

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

1169

# Create a new, but exactly alike, function

1170

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

1171

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

1172

# to the class.

1173

attr[attrname] = (dbus_interface_annotations

1174

(alt_interface)

1175

(types.FunctionType

1176

(attribute.func_code,

1177

attribute.func_globals,

1178

attribute.func_name,

1179

attribute.func_defaults,

1180

attribute.func_closure)))

1181

if deprecate:

1182

# Deprecate all alternate interfaces

1183

iname="_AlternateDBusNames_interface_annotation{0}"

1184

for interface_name in interface_names:

1185

@dbus_interface_annotations(interface_name)

1186

def func(self):

1187

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

1188

"true" }

1189

# Find an unused name

1190

for aname in (iname.format(i)

1191

for i in itertools.count()):

1192

if aname not in attr:

1193

attr[aname] = func

1194

break

1195

if interface_names:

1196

# Replace the class with a new subclass of it with

1197

# methods, signals, etc. as created above.

1198

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

1199

(cls,), attr)

1200

return cls

1201

return wrapper

1202

1203

1204

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

1205

"se.bsnet.fukt.Mandos"})

861

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

862

1206

863

class ClientDBus(Client, DBusObjectWithProperties):

1207

864

"""A Client class using D-Bus

1208

865

1217

874

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

1218

875

1219

876

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

877

self._approvals_pending = 0

1220

878

self.bus = bus

1221

879

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

1222

880

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

1228

886

("/clients/" + client_object_name))

1229

887

DBusObjectWithProperties.__init__(self, self.bus,

1230

888

self.dbus_object_path)

1231

889

1232

890

def notifychangeproperty(transform_func,

1233

891

dbus_name, type_func=lambda x: x,

1234

892

variant_level=1):

1235

893

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

1236

894

its changes to DBus.

1237

895

1238

896

transform_fun: Function that takes a value and a variant_level

1239

897

and transforms it to a D-Bus type.

1240

898

dbus_name: D-Bus name of the variable

1257

915

1258

916

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

1259

917

918

1260

919

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1261

920

approvals_pending = notifychangeproperty(dbus.Boolean,

1262

921

"ApprovalPending",

1269

928

checker is not None)

1270

929

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1271

930

"LastCheckedOK")

1272

last_checker_status = notifychangeproperty(dbus.Int16,

1273

"LastCheckerStatus")

1274

931

last_approval_request = notifychangeproperty(

1275

932

datetime_to_dbus, "LastApprovalRequest")

1276

933

approved_by_default = notifychangeproperty(dbus.Boolean,

1277

934

"ApprovedByDefault")

1278

approval_delay = notifychangeproperty(dbus.UInt64,

935

approval_delay = notifychangeproperty(dbus.UInt16,

1279

936

"ApprovalDelay",

1280

937

type_func =

1281

timedelta_to_milliseconds)

938

_timedelta_to_milliseconds)

1282

939

approval_duration = notifychangeproperty(

1283

dbus.UInt64, "ApprovalDuration",

1284

type_func = timedelta_to_milliseconds)

940

dbus.UInt16, "ApprovalDuration",

941

type_func = _timedelta_to_milliseconds)

1285

942

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

1286

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

943

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

1287

944

type_func =

1288

timedelta_to_milliseconds)

945

_timedelta_to_milliseconds)

1289

946

extended_timeout = notifychangeproperty(

1290

dbus.UInt64, "ExtendedTimeout",

1291

type_func = timedelta_to_milliseconds)

1292

interval = notifychangeproperty(dbus.UInt64,

947

dbus.UInt16, "ExtendedTimeout",

948

type_func = _timedelta_to_milliseconds)

949

interval = notifychangeproperty(dbus.UInt16,

1293

950

"Interval",

1294

951

type_func =

1295

timedelta_to_milliseconds)

952

_timedelta_to_milliseconds)

1296

953

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

1297

954

1298

955

del notifychangeproperty

1340

997

return r

1341

998

1342

999

def _reset_approved(self):

1343

self.approved = None

1000

self._approved = None

1344

1001

return False

1345

1002

1346

1003

def approve(self, value=True):

1347

self.approved = value

1348

gobject.timeout_add(timedelta_to_milliseconds

1004

self.send_changedstate()

1005

self._approved = value

1006

gobject.timeout_add(_timedelta_to_milliseconds

1349

1007

(self.approval_duration),

1350

1008

self._reset_approved)

1351

self.send_changedstate()

1009

1352

1010

1353

1011

## D-Bus methods, signals & properties

1354

1012

_interface = "se.recompile.Mandos.Client"

1355

1013

1356

## Interfaces

1357

1358

@dbus_interface_annotations(_interface)

1359

def _foo(self):

1360

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

1361

"false"}

1362

1363

1014

## Signals

1364

1015

1365

1016

# CheckerCompleted - signal

1464

1115

access="readwrite")

1465

1116

def ApprovalDuration_dbus_property(self, value=None):

1466

1117

if value is None: # get

1467

return dbus.UInt64(timedelta_to_milliseconds(

1118

return dbus.UInt64(_timedelta_to_milliseconds(

1468

1119

self.approval_duration))

1469

1120

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

1470

1121

1484

1135

def Host_dbus_property(self, value=None):

1485

1136

if value is None: # get

1486

1137

return dbus.String(self.host)

1487

self.host = unicode(value)

1138

self.host = value

1488

1139

1489

1140

# Created - property

1490

1141

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

1491

1142

def Created_dbus_property(self):

1492

return datetime_to_dbus(self.created)

1143

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

1493

1144

1494

1145

# LastEnabled - property

1495

1146

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

1516

1167

return

1517

1168

return datetime_to_dbus(self.last_checked_ok)

1518

1169

1519

# LastCheckerStatus - property

1520

@dbus_service_property(_interface, signature="n",

1521

access="read")

1522

def LastCheckerStatus_dbus_property(self):

1523

return dbus.Int16(self.last_checker_status)

1524

1525

1170

# Expires - property

1526

1171

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

1527

1172

def Expires_dbus_property(self):

1538

1183

def Timeout_dbus_property(self, value=None):

1539

1184

if value is None: # get

1540

1185

return dbus.UInt64(self.timeout_milliseconds())

1541

old_timeout = self.timeout

1542

1186

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

1543

# Reschedule disabling

1544

if self.enabled:

1545

now = datetime.datetime.utcnow()

1546

self.expires += self.timeout - old_timeout

1547

if self.expires <= now:

1548

# The timeout has passed

1549

self.disable()

1550

else:

1551

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

1552

is None):

1553

return

1554

gobject.source_remove(self.disable_initiator_tag)

1555

self.disable_initiator_tag = (

1556

gobject.timeout_add(

1557

timedelta_to_milliseconds(self.expires - now),

1558

self.disable))

1187

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

1188

return

1189

# Reschedule timeout

1190

gobject.source_remove(self.disable_initiator_tag)

1191

self.disable_initiator_tag = None

1192

self.expires = None

1193

time_to_die = _timedelta_to_milliseconds((self

1194

.last_checked_ok

1195

+ self.timeout)

1196

- datetime.datetime

1197

.utcnow())

1198

if time_to_die <= 0:

1199

# The timeout has passed

1200

self.disable()

1201

else:

1202

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

1203

+ datetime.timedelta(milliseconds =

1204

time_to_die))

1205

self.disable_initiator_tag = (gobject.timeout_add

1206

(time_to_die, self.disable))

1559

1207

1560

1208

# ExtendedTimeout - property

1561

1209

@dbus_service_property(_interface, signature="t",

1574

1222

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

1575

1223

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

1576

1224

return

1577

if self.enabled:

1578

# Reschedule checker run

1579

gobject.source_remove(self.checker_initiator_tag)

1580

self.checker_initiator_tag = (gobject.timeout_add

1581

(value, self.start_checker))

1582

self.start_checker() # Start one now, too

1225

# Reschedule checker run

1226

gobject.source_remove(self.checker_initiator_tag)

1227

self.checker_initiator_tag = (gobject.timeout_add

1228

(value, self.start_checker))

1229

self.start_checker() # Start one now, too

1583

1230

1584

1231

# Checker - property

1585

1232

@dbus_service_property(_interface, signature="s",

1587

1234

def Checker_dbus_property(self, value=None):

1588

1235

if value is None: # get

1589

1236

return dbus.String(self.checker_command)

1590

self.checker_command = unicode(value)

1237

self.checker_command = value

1591

1238

1592

1239

# CheckerRunning - property

1593

1240

@dbus_service_property(_interface, signature="b",

1622

1269

raise KeyError()

1623

1270

1624

1271

def __getattribute__(self, name):

1625

if name == '_pipe':

1272

if(name == '_pipe'):

1626

1273

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

1627

1274

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

1628

1275

data = self._pipe.recv()

1635

1282

return func

1636

1283

1637

1284

def __setattr__(self, name, value):

1638

if name == '_pipe':

1285

if(name == '_pipe'):

1639

1286

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

1640

1287

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

1641

1288

1289

class ClientDBusTransitional(ClientDBus):

1290

__metaclass__ = AlternateDBusNamesMetaclass

1642

1291

1643

1292

class ClientHandler(socketserver.BaseRequestHandler, object):

1644

1293

"""A class to handle client connections.

1727

1376

client.Rejected("Disabled")

1728

1377

return

1729

1378

1730

if client.approved or not client.approval_delay:

1379

if client._approved or not client.approval_delay:

1731

1380

#We are approved or approval is disabled

1732

1381

break

1733

elif client.approved is None:

1382

elif client._approved is None:

1734

1383

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

1735

1384

client.name)

1736

1385

if self.server.use_dbus:

1749

1398

#wait until timeout or approved

1750

1399

time = datetime.datetime.now()

1751

1400

client.changedstate.acquire()

1752

client.changedstate.wait(

1753

float(timedelta_to_milliseconds(delay)

1754

/ 1000))

1401

(client.changedstate.wait

1402

(float(client._timedelta_to_milliseconds(delay)

1403

/ 1000)))

1755

1404

client.changedstate.release()

1756

1405

time2 = datetime.datetime.now()

1757

1406

if (time2 - time) >= delay:

1773

1422

try:

1774

1423

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

1775

1424

except gnutls.errors.GNUTLSError as error:

1776

logger.warning("gnutls send failed",

1777

exc_info=error)

1425

logger.warning("gnutls send failed")

1778

1426

return

1779

1427

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

1780

1428

sent, len(client.secret)

1783

1431

1784

1432

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

1785

1433

# bump the timeout using extended_timeout

1786

client.bump_timeout(client.extended_timeout)

1434

client.checked_ok(client.extended_timeout)

1787

1435

if self.server.use_dbus:

1788

1436

# Emit D-Bus signal

1789

1437

client.GotSecret()

1794

1442

try:

1795

1443

session.bye()

1796

1444

except gnutls.errors.GNUTLSError as error:

1797

logger.warning("GnuTLS bye failed",

1798

exc_info=error)

1445

logger.warning("GnuTLS bye failed")

1799

1446

1800

1447

@staticmethod

1801

1448

def peer_certificate(session):

1857

1504

# Convert the buffer to a Python bytestring

1858

1505

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

1859

1506

# Convert the bytestring to hexadecimal notation

1860

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

1507

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

1861

1508

return hex_fpr

1862

1509

1863

1510

1866

1513

def sub_process_main(self, request, address):

1867

1514

try:

1868

1515

self.finish_request(request, address)

1869

except Exception:

1516

except:

1870

1517

self.handle_error(request, address)

1871

1518

self.close_request(request)

1872

1519

1873

1520

def process_request(self, request, address):

1874

1521

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

1875

1522

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

1876

args = (request, address))

1523

args = (request,

1524

address))

1877

1525

proc.start()

1878

1526

return proc

1879

1527

1907

1555

use_ipv6: Boolean; to use IPv6 or not

1908

1556

"""

1909

1557

def __init__(self, server_address, RequestHandlerClass,

1910

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

1911

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

1912

creating a new one with socket.socket().

1913

"""

1558

interface=None, use_ipv6=True):

1914

1559

self.interface = interface

1915

1560

if use_ipv6:

1916

1561

self.address_family = socket.AF_INET6

1917

if socketfd is not None:

1918

# Save the file descriptor

1919

self.socketfd = socketfd

1920

# Save the original socket.socket() function

1921

self.socket_socket = socket.socket

1922

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

1923

#

1924

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

1925

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

1926

# patching socket.socket.)

1927

#

1928

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

1929

@functools.wraps(socket.socket)

1930

def socket_wrapper(*args, **kwargs):

1931

# Restore original function so subsequent calls are

1932

# not affected.

1933

socket.socket = self.socket_socket

1934

del self.socket_socket

1935

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

1936

# saved file descriptor.

1937

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

1938

# Replace socket.socket() function with wrapper

1939

socket.socket = socket_wrapper

1940

# The socketserver.TCPServer.__init__ will call

1941

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

1942

# socket_wrapper(), if socketfd was set.

1943

1562

socketserver.TCPServer.__init__(self, server_address,

1944

1563

RequestHandlerClass)

1945

1946

1564

def server_bind(self):

1947

1565

"""This overrides the normal server_bind() function

1948

1566

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

1956

1574

try:

1957

1575

self.socket.setsockopt(socket.SOL_SOCKET,

1958

1576

SO_BINDTODEVICE,

1959

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

1577

str(self.interface

1578

+ '\0'))

1960

1579

except socket.error as error:

1961

if error.errno == errno.EPERM:

1962

logger.error("No permission to bind to"

1963

" interface %s", self.interface)

1964

elif error.errno == errno.ENOPROTOOPT:

1580

if error[0] == errno.EPERM:

1581

logger.error("No permission to"

1582

" bind to interface %s",

1583

self.interface)

1584

elif error[0] == errno.ENOPROTOOPT:

1965

1585

logger.error("SO_BINDTODEVICE not available;"

1966

1586

" cannot bind to interface %s",

1967

1587

self.interface)

1968

elif error.errno == errno.ENODEV:

1969

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

1970

" cannot bind", self.interface)

1971

1588

else:

1972

1589

raise

1973

1590

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

2003

1620

"""

2004

1621

def __init__(self, server_address, RequestHandlerClass,

2005

1622

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

2006

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

1623

gnutls_priority=None, use_dbus=True):

2007

1624

self.enabled = False

2008

1625

self.clients = clients

2009

1626

if self.clients is None:

2010

self.clients = {}

1627

self.clients = set()

2011

1628

self.use_dbus = use_dbus

2012

1629

self.gnutls_priority = gnutls_priority

2013

1630

IPv6_TCPServer.__init__(self, server_address,

2014

1631

RequestHandlerClass,

2015

1632

interface = interface,

2016

use_ipv6 = use_ipv6,

2017

socketfd = socketfd)

1633

use_ipv6 = use_ipv6)

2018

1634

def server_activate(self):

2019

1635

if self.enabled:

2020

1636

return socketserver.TCPServer.server_activate(self)

2033

1649

2034

1650

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

2035

1651

proc = None, client_object=None):

1652

condition_names = {

1653

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

1654

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

1655

# blocking).

1656

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

1657

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

1658

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

1659

# broken, usually for pipes and

1660

# sockets).

1661

}

1662

conditions_string = ' | '.join(name

1663

for cond, name in

1664

condition_names.iteritems()

1665

if cond & condition)

2036

1666

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

2037

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

1667

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

2038

1668

# Wait for other process to exit

2039

1669

proc.join()

2040

1670

return False

2047

1677

fpr = request[1]

2048

1678

address = request[2]

2049

1679

2050

for c in self.clients.itervalues():

1680

for c in self.clients:

2051

1681

if c.fingerprint == fpr:

2052

1682

client = c

2053

1683

break

2098

1728

return True

2099

1729

2100

1730

2101

def rfc3339_duration_to_delta(duration):

2102

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

2103

2104

>>> rfc3339_duration_to_delta("P7D")

2105

datetime.timedelta(7)

2106

>>> rfc3339_duration_to_delta("PT60S")

2107

datetime.timedelta(0, 60)

2108

>>> rfc3339_duration_to_delta("PT60M")

2109

datetime.timedelta(0, 3600)

2110

>>> rfc3339_duration_to_delta("PT24H")

2111

datetime.timedelta(1)

2112

>>> rfc3339_duration_to_delta("P1W")

2113

datetime.timedelta(7)

2114

>>> rfc3339_duration_to_delta("PT5M30S")

2115

datetime.timedelta(0, 330)

2116

>>> rfc3339_duration_to_delta("P1DT3M20S")

2117

datetime.timedelta(1, 200)

2118

"""

2119

2120

# Parsing an RFC 3339 duration with regular expressions is not

2121

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

2122

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

2123

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

2124

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

2125

# avoid excessive use of external libraries.

2126

2127

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

2128

Token = collections.namedtuple("Token",

2129

("regexp", # To match token; if

2130

# "value" is not None,

2131

# must have a "group"

2132

# containing digits

2133

"value", # datetime.timedelta or

2134

# None

2135

"followers")) # Tokens valid after

2136

# this token

2137

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

2138

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

2139

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

2140

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

2141

datetime.timedelta(seconds=1),

2142

frozenset((token_end,)))

2143

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

2144

datetime.timedelta(minutes=1),

2145

frozenset((token_second, token_end)))

2146

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

2147

datetime.timedelta(hours=1),

2148

frozenset((token_minute, token_end)))

2149

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

2150

None,

2151

frozenset((token_hour, token_minute,

2152

token_second)))

2153

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

2154

datetime.timedelta(days=1),

2155

frozenset((token_time, token_end)))

2156

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

2157

datetime.timedelta(weeks=4),

2158

frozenset((token_day, token_end)))

2159

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

2160

datetime.timedelta(weeks=52),

2161

frozenset((token_month, token_end)))

2162

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

2163

datetime.timedelta(weeks=1),

2164

frozenset((token_end,)))

2165

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

2166

frozenset((token_year, token_month,

2167

token_day, token_time,

2168

token_week))),

2169

# Define starting values

2170

value = datetime.timedelta() # Value so far

2171

found_token = None

2172

followers = frozenset(token_duration,) # Following valid tokens

2173

s = duration # String left to parse

2174

# Loop until end token is found

2175

while found_token is not token_end:

2176

# Search for any currently valid tokens

2177

for token in followers:

2178

match = token.regexp.match(s)

2179

if match is not None:

2180

# Token found

2181

if token.value is not None:

2182

# Value found, parse digits

2183

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

2184

# Add to value so far

2185

value += factor * token.value

2186

# Strip token from string

2187

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

2188

# Go to found token

2189

found_token = token

2190

# Set valid next tokens

2191

followers = found_token.followers

2192

break

2193

else:

2194

# No currently valid tokens were found

2195

raise ValueError("Invalid RFC 3339 duration")

2196

# End token found

2197

return value

2198

2199

2200

1731

def string_to_delta(interval):

2201

1732

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

2202

1733

2213

1744

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

2214

1745

datetime.timedelta(0, 330)

2215

1746

"""

2216

2217

try:

2218

return rfc3339_duration_to_delta(interval)

2219

except ValueError:

2220

pass

2221

2222

1747

timevalue = datetime.timedelta(0)

2223

1748

for s in interval.split():

2224

1749

try:

2235

1760

elif suffix == "w":

2236

1761

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

2237

1762

else:

2238

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

2239

.format(suffix))

1763

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

2240

1764

except (ValueError, IndexError) as e:

2241

1765

raise ValueError(*(e.args))

2242

1766

timevalue += delta

2243

1767

return timevalue

2244

1768

2245

1769

1770

def if_nametoindex(interface):

1771

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

1772

1773

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

1774

global if_nametoindex

1775

try:

1776

if_nametoindex = (ctypes.cdll.LoadLibrary

1777

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

1778

.if_nametoindex)

1779

except (OSError, AttributeError):

1780

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

1781

def if_nametoindex(interface):

1782

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

1783

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

1784

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

1785

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1786

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

1787

interface))

1788

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

1789

ifreq[16:20])[0]

1790

return interface_index

1791

return if_nametoindex(interface)

1792

1793

2246

1794

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

2247

1795

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

2248

1796

2256

1804

sys.exit()

2257

1805

if not noclose:

2258

1806

# Close all standard open file descriptors

2259

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

1807

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

2260

1808

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

2261

1809

raise OSError(errno.ENODEV,

2262

"{0} not a character device"

2263

.format(os.devnull))

1810

"%s not a character device"

1811

% os.path.devnull)

2264

1812

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

2265

1813

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

2266

1814

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

2275

1823

2276

1824

parser = argparse.ArgumentParser()

2277

1825

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

2278

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

1826

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

2279

1827

help="show version number and exit")

2280

1828

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

2281

1829

help="Bind to interface IF")

2303

1851

" system bus interface")

2304

1852

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

2305

1853

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

2306

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

2307

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

2308

" state")

2309

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

2310

help="Specify a file descriptor to a network"

2311

" socket to use instead of creating one")

2312

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

2313

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

2314

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

2315

help="Run in foreground")

2316

2317

1854

options = parser.parse_args()

2318

1855

2319

1856

if options.check:

2332

1869

"use_dbus": "True",

2333

1870

"use_ipv6": "True",

2334

1871

"debuglevel": "",

2335

"restore": "True",

2336

"socket": "",

2337

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

2338

"foreground": "False",

2339

1872

}

2340

1873

2341

1874

# Parse config file for server-global settings

2346

1879

# Convert the SafeConfigParser object to a dict

2347

1880

server_settings = server_config.defaults()

2348

1881

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

2349

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

1882

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

2350

1883

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

2351

1884

option)

2352

1885

if server_settings["port"]:

2353

1886

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

2354

1887

"port")

2355

if server_settings["socket"]:

2356

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

2357

"socket")

2358

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

2359

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

2360

# happen with a supplied network socket.

2361

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

2362

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

2363

["socket"])

2364

1888

del server_config

2365

1889

2366

1890

# Override the settings from the config file with command line

2367

1891

# options, if set.

2368

1892

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

2369

1893

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

2370

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

2371

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

1894

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

2372

1895

value = getattr(options, option)

2373

1896

if value is not None:

2374

1897

server_settings[option] = value

2377

1900

for option in server_settings.keys():

2378

1901

if type(server_settings[option]) is str:

2379

1902

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

2380

# Debug implies foreground

2381

if server_settings["debug"]:

2382

server_settings["foreground"] = True

2383

1903

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

2384

1904

2385

1905

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

2389

1909

debuglevel = server_settings["debuglevel"]

2390

1910

use_dbus = server_settings["use_dbus"]

2391

1911

use_ipv6 = server_settings["use_ipv6"]

2392

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

2393

stored_state_file)

2394

foreground = server_settings["foreground"]

2395

2396

if debug:

2397

initlogger(debug, logging.DEBUG)

2398

else:

2399

if not debuglevel:

2400

initlogger(debug)

2401

else:

2402

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

2403

initlogger(debug, level)

2404

1912

2405

1913

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

2406

1914

syslogger.setFormatter(logging.Formatter

2407

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

2408

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

2409

.format(server_settings

2410

["servicename"])))

1915

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

1916

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

1917

% server_settings["servicename"]))

2411

1918

2412

1919

# Parse config file with clients

2413

client_config = configparser.SafeConfigParser(Client

2414

.client_defaults)

1920

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

1921

"extended_timeout": "15m",

1922

"interval": "2m",

1923

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

1924

"host": "",

1925

"approval_delay": "0s",

1926

"approval_duration": "1s",

1927

}

1928

client_config = configparser.SafeConfigParser(client_defaults)

2415

1929

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

2416

1930

"clients.conf"))

2417

1931

2426

1940

use_ipv6=use_ipv6,

2427

1941

gnutls_priority=

2428

1942

server_settings["priority"],

2429

use_dbus=use_dbus,

2430

socketfd=(server_settings["socket"]

2431

or None))

2432

if not foreground:

1943

use_dbus=use_dbus)

1944

if not debug:

2433

1945

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

2434

pidfile = None

2435

1946

try:

2436

1947

pidfile = open(pidfilename, "w")

2437

except IOError as e:

2438

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

2439

exc_info=e)

1948

except IOError:

1949

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

2440

1950

2441

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

1951

try:

1952

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

1953

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

1954

except KeyError:

2442

1955

try:

2443

uid = pwd.getpwnam(name).pw_uid

2444

gid = pwd.getpwnam(name).pw_gid

2445

break

1956

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

1957

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

2446

1958

except KeyError:

2447

continue

2448

else:

2449

uid = 65534

2450

gid = 65534

1959

try:

1960

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

1961

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

1962

except KeyError:

1963

uid = 65534

1964

gid = 65534

2451

1965

try:

2452

1966

os.setgid(gid)

2453

1967

os.setuid(uid)

2454

1968

except OSError as error:

2455

if error.errno != errno.EPERM:

1969

if error[0] != errno.EPERM:

2456

1970

raise error

2457

1971

1972

if not debug and not debuglevel:

1973

syslogger.setLevel(logging.WARNING)

1974

console.setLevel(logging.WARNING)

1975

if debuglevel:

1976

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

1977

syslogger.setLevel(level)

1978

console.setLevel(level)

1979

2458

1980

if debug:

2459

1981

# Enable all possible GnuTLS debugging

2460

1982

2470

1992

.gnutls_global_set_log_function(debug_gnutls))

2471

1993

2472

1994

# Redirect stdin so all checkers get /dev/null

2473

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

1995

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

2474

1996

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

2475

1997

if null > 2:

2476

1998

os.close(null)

1999

else:

2000

# No console logging

2001

logger.removeHandler(console)

2477

2002

2478

2003

# Need to fork before connecting to D-Bus

2479

if not foreground:

2004

if not debug:

2480

2005

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

2481

2006

daemon()

2482

2007

2483

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

2484

# need to inform gobject that threads will be used.

2485

gobject.threads_init()

2486

2487

2008

global main_loop

2488

2009

# From the Avahi example code

2489

DBusGMainLoop(set_as_default=True)

2010

DBusGMainLoop(set_as_default=True )

2490

2011

main_loop = gobject.MainLoop()

2491

2012

bus = dbus.SystemBus()

2492

2013

# End of Avahi example code

2498

2019

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

2499

2020

do_not_queue=True))

2500

2021

except dbus.exceptions.NameExistsException as e:

2501

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

2022

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

2502

2023

use_dbus = False

2503

2024

server_settings["use_dbus"] = False

2504

2025

tcp_server.use_dbus = False

2505

2026

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2506

service = AvahiServiceToSyslog(name =

2507

server_settings["servicename"],

2508

servicetype = "_mandos._tcp",

2509

protocol = protocol, bus = bus)

2027

service = AvahiService(name = server_settings["servicename"],

2028

servicetype = "_mandos._tcp",

2029

protocol = protocol, bus = bus)

2510

2030

if server_settings["interface"]:

2511

2031

service.interface = (if_nametoindex

2512

2032

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

2516

2036

2517

2037

client_class = Client

2518

2038

if use_dbus:

2519

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

2520

2521

client_settings = Client.config_parser(client_config)

2522

old_client_settings = {}

2523

clients_data = {}

2524

2525

# Get client data and settings from last running state.

2526

if server_settings["restore"]:

2527

try:

2528

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

2529

clients_data, old_client_settings = (pickle.load

2530

(stored_state))

2531

os.remove(stored_state_path)

2532

except IOError as e:

2533

if e.errno == errno.ENOENT:

2534

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

2535

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

2536

else:

2537

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

2538

exc_info=e)

2539

raise

2540

except EOFError as e:

2541

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

2542

"EOFError:", exc_info=e)

2543

2544

with PGPEngine() as pgp:

2545

for client_name, client in clients_data.iteritems():

2546

# Decide which value to use after restoring saved state.

2547

# We have three different values: Old config file,

2548

# new config file, and saved state.

2549

# New config value takes precedence if it differs from old

2550

# config value, otherwise use saved state.

2551

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

2552

try:

2553

# For each value in new config, check if it

2554

# differs from the old config value (Except for

2555

# the "secret" attribute)

2556

if (name != "secret" and

2557

value != old_client_settings[client_name]

2558

[name]):

2559

client[name] = value

2560

except KeyError:

2561

pass

2562

2563

# Clients who has passed its expire date can still be

2564

# enabled if its last checker was successful. Clients

2565

# whose checker succeeded before we stored its state is

2566

# assumed to have successfully run all checkers during

2567

# downtime.

2568

if client["enabled"]:

2569

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

2570

if not client["last_checked_ok"]:

2571

logger.warning(

2572

"disabling client {0} - Client never "

2573

"performed a successful checker"

2574

.format(client_name))

2575

client["enabled"] = False

2576

elif client["last_checker_status"] != 0:

2577

logger.warning(

2578

"disabling client {0} - Client "

2579

"last checker failed with error code {1}"

2580

.format(client_name,

2581

client["last_checker_status"]))

2582

client["enabled"] = False

2583

else:

2584

client["expires"] = (datetime.datetime

2585

.utcnow()

2586

+ client["timeout"])

2587

logger.debug("Last checker succeeded,"

2588

" keeping {0} enabled"

2589

.format(client_name))

2039

client_class = functools.partial(ClientDBusTransitional,

2040

bus = bus)

2041

def client_config_items(config, section):

2042

special_settings = {

2043

"approved_by_default":

2044

lambda: config.getboolean(section,

2045

"approved_by_default"),

2046

}

2047

for name, value in config.items(section):

2590

2048

try:

2591

client["secret"] = (

2592

pgp.decrypt(client["encrypted_secret"],

2593

client_settings[client_name]

2594

["secret"]))

2595

except PGPError:

2596

# If decryption fails, we use secret from new settings

2597

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

2598

.format(client_name))

2599

client["secret"] = (

2600

client_settings[client_name]["secret"])

2601

2602

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

2603

for client_name in (set(old_client_settings)

2604

- set(client_settings)):

2605

del clients_data[client_name]

2606

for client_name in (set(client_settings)

2607

- set(old_client_settings)):

2608

clients_data[client_name] = client_settings[client_name]

2609

2610

# Create all client objects

2611

for client_name, client in clients_data.iteritems():

2612

tcp_server.clients[client_name] = client_class(

2613

name = client_name, settings = client)

2614

2049

yield (name, special_settings[name]())

2050

except KeyError:

2051

yield (name, value)

2052

2053

tcp_server.clients.update(set(

2054

client_class(name = section,

2055

config= dict(client_config_items(

2056

client_config, section)))

2057

for section in client_config.sections()))

2615

2058

if not tcp_server.clients:

2616

2059

logger.warning("No clients defined")

2617

2618

if not foreground:

2619

if pidfile is not None:

2620

try:

2621

with pidfile:

2622

pid = os.getpid()

2623

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

2624

except IOError:

2625

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

2626

pidfilename, pid)

2627

del pidfile

2060

2061

if not debug:

2062

try:

2063

with pidfile:

2064

pid = os.getpid()

2065

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

2066

del pidfile

2067

except IOError:

2068

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

2069

pidfilename, pid)

2070

except NameError:

2071

# "pidfile" was never created

2072

pass

2628

2073

del pidfilename

2074

2075

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

2629

2076

2630

2077

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

2631

2078

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

2632

2079

2633

2080

if use_dbus:

2634

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

2635

"se.bsnet.fukt.Mandos"})

2636

class MandosDBusService(DBusObjectWithProperties):

2081

class MandosDBusService(dbus.service.Object):

2637

2082

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

2638

2083

def __init__(self):

2639

2084

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

2640

2085

_interface = "se.recompile.Mandos"

2641

2086

2642

@dbus_interface_annotations(_interface)

2643

def _foo(self):

2644

return { "org.freedesktop.DBus.Property"

2645

".EmitsChangedSignal":

2646

"false"}

2647

2648

2087

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

2649

2088

def ClientAdded(self, objpath):

2650

2089

"D-Bus signal"

2664

2103

def GetAllClients(self):

2665

2104

"D-Bus method"

2666

2105

return dbus.Array(c.dbus_object_path

2667

for c in

2668

tcp_server.clients.itervalues())

2106

for c in tcp_server.clients)

2669

2107

2670

2108

@dbus.service.method(_interface,

2671

2109

out_signature="a{oa{sv}}")

2673

2111

"D-Bus method"

2674

2112

return dbus.Dictionary(

2675

2113

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

2676

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

2114

for c in tcp_server.clients),

2677

2115

signature="oa{sv}")

2678

2116

2679

2117

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

2680

2118

def RemoveClient(self, object_path):

2681

2119

"D-Bus method"

2682

for c in tcp_server.clients.itervalues():

2120

for c in tcp_server.clients:

2683

2121

if c.dbus_object_path == object_path:

2684

del tcp_server.clients[c.name]

2122

tcp_server.clients.remove(c)

2685

2123

c.remove_from_connection()

2686

2124

# Don't signal anything except ClientRemoved

2687

2125

c.disable(quiet=True)

2692

2130

2693

2131

del _interface

2694

2132

2695

mandos_dbus_service = MandosDBusService()

2133

class MandosDBusServiceTransitional(MandosDBusService):

2134

__metaclass__ = AlternateDBusNamesMetaclass

2135

mandos_dbus_service = MandosDBusServiceTransitional()

2696

2136

2697

2137

def cleanup():

2698

2138

"Cleanup function; run on exit"

2699

2139

service.cleanup()

2700

2140

2701

2141

multiprocessing.active_children()

2702

if not (tcp_server.clients or client_settings):

2703

return

2704

2705

# Store client before exiting. Secrets are encrypted with key

2706

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

2707

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

2708

clients = {}

2709

with PGPEngine() as pgp:

2710

for client in tcp_server.clients.itervalues():

2711

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

2712

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

2713

key)

2714

client_dict = {}

2715

2716

# A list of attributes that can not be pickled

2717

# + secret.

2718

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

2719

"checker"))

2720

for name, typ in (inspect.getmembers

2721

(dbus.service.Object)):

2722

exclude.add(name)

2723

2724

client_dict["encrypted_secret"] = (client

2725

.encrypted_secret)

2726

for attr in client.client_structure:

2727

if attr not in exclude:

2728

client_dict[attr] = getattr(client, attr)

2729

2730

clients[client.name] = client_dict

2731

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

2732

2733

try:

2734

with (tempfile.NamedTemporaryFile

2735

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

2736

dir=os.path.dirname(stored_state_path),

2737

delete=False)) as stored_state:

2738

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

2739

tempname=stored_state.name

2740

os.rename(tempname, stored_state_path)

2741

except (IOError, OSError) as e:

2742

if not debug:

2743

try:

2744

os.remove(tempname)

2745

except NameError:

2746

pass

2747

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

2748

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

2749

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

2750

else:

2751

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

2752

exc_info=e)

2753

raise e

2754

2755

# Delete all clients, and settings from config

2756

2142

while tcp_server.clients:

2757

name, client = tcp_server.clients.popitem()

2143

client = tcp_server.clients.pop()

2758

2144

if use_dbus:

2759

2145

client.remove_from_connection()

2146

client.disable_hook = None

2760

2147

# Don't signal anything except ClientRemoved

2761

2148

client.disable(quiet=True)

2762

2149

if use_dbus:

2764

2151

mandos_dbus_service.ClientRemoved(client

2765

2152

.dbus_object_path,

2766

2153

client.name)

2767

client_settings.clear()

2768

2154

2769

2155

atexit.register(cleanup)

2770

2156

2771

for client in tcp_server.clients.itervalues():

2157

for client in tcp_server.clients:

2772

2158

if use_dbus:

2773

2159

# Emit D-Bus signal

2774

2160

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2775

# Need to initiate checking of clients

2776

if client.enabled:

2777

client.init_checker()

2161

client.enable()

2778

2162

2779

2163

tcp_server.enable()

2780

2164

tcp_server.server_activate()

2783

2167

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

2784

2168

if use_ipv6:

2785

2169

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

2786

" flowinfo %d, scope_id %d",

2787

*tcp_server.socket.getsockname())

2170

" flowinfo %d, scope_id %d"

2171

% tcp_server.socket.getsockname())

2788

2172

else: # IPv4

2789

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

2790

*tcp_server.socket.getsockname())

2173

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

2174

% tcp_server.socket.getsockname())

2791

2175

2792

2176

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

2793

2177

2796

2180

try:

2797

2181

service.activate()

2798

2182

except dbus.exceptions.DBusException as error:

2799

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

2183

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

2800

2184

cleanup()

2801

2185

sys.exit(1)

2802

2186

# End of Avahi example code

2809

2193

logger.debug("Starting main loop")

2810

2194

main_loop.run()

2811

2195

except AvahiError as error:

2812

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

2196

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

2813

2197

cleanup()

2814

2198

sys.exit(1)

2815

2199

except KeyboardInterrupt:

2820

2204

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

2821

2205

cleanup()

2822

2206

2207

2823

2208

if __name__ == '__main__':

2824

2209

main()