/mandos/trunk : revision 505.3.13

1

#!/usr/bin/python2.7

1

#!/usr/bin/python

2

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

3

#

4

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

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

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

88

82

except ImportError:

89

83

SO_BINDTODEVICE = None

90

84

91

if sys.version_info.major == 2:

92

str = unicode

93

94

version = "1.6.8"

95

stored_state_file = "clients.pickle"

96

97

logger = logging.getLogger()

98

syslogger = None

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(b"16s16x", interface))

111

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

112

return interface_index

113

114

115

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

116

"""init logger and add loglevel"""

117

118

global syslogger

119

syslogger = (logging.handlers.SysLogHandler

120

(facility =

121

logging.handlers.SysLogHandler.LOG_DAEMON,

122

address = "/dev/log"))

123

syslogger.setFormatter(logging.Formatter

124

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

125

' %(message)s'))

126

logger.addHandler(syslogger)

127

128

if debug:

129

console = logging.StreamHandler()

130

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

131

' [%(process)d]:'

132

' %(levelname)s:'

133

' %(message)s'))

134

logger.addHandler(console)

135

logger.setLevel(level)

136

137

138

class PGPError(Exception):

139

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

140

pass

141

142

143

class PGPEngine(object):

144

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

145

def __init__(self):

146

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

147

self.gnupgargs = ['--batch',

148

'--home', self.tempdir,

149

'--force-mdc',

150

'--quiet',

151

'--no-use-agent']

152

153

def __enter__(self):

154

return self

155

156

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

157

self._cleanup()

158

return False

159

160

def __del__(self):

161

self._cleanup()

162

163

def _cleanup(self):

164

if self.tempdir is not None:

165

# Delete contents of tempdir

166

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

167

topdown = False):

168

for filename in files:

169

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

170

for dirname in dirs:

171

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

172

# Remove tempdir

173

os.rmdir(self.tempdir)

174

self.tempdir = None

175

176

def password_encode(self, password):

177

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

178

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

179

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

180

if len(encoded) > 2048:

181

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

182

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

183

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

184

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

185

return encoded

186

187

def encrypt(self, data, password):

188

passphrase = self.password_encode(password)

189

with tempfile.NamedTemporaryFile(dir=self.tempdir

190

) as passfile:

191

passfile.write(passphrase)

192

passfile.flush()

193

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

194

'--passphrase-file',

195

passfile.name]

196

+ self.gnupgargs,

197

stdin = subprocess.PIPE,

198

stdout = subprocess.PIPE,

199

stderr = subprocess.PIPE)

200

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

201

if proc.returncode != 0:

202

raise PGPError(err)

203

return ciphertext

204

205

def decrypt(self, data, password):

206

passphrase = self.password_encode(password)

207

with tempfile.NamedTemporaryFile(dir = self.tempdir

208

) as passfile:

209

passfile.write(passphrase)

210

passfile.flush()

211

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

212

'--passphrase-file',

213

passfile.name]

214

+ self.gnupgargs,

215

stdin = subprocess.PIPE,

216

stdout = subprocess.PIPE,

217

stderr = subprocess.PIPE)

218

decrypted_plaintext, err = proc.communicate(input

219

= data)

220

if proc.returncode != 0:

221

raise PGPError(err)

222

return decrypted_plaintext

223

85

86

version = "1.4.1"

87

88

#logger = logging.getLogger('mandos')

89

logger = logging.Logger('mandos')

90

syslogger = (logging.handlers.SysLogHandler

91

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

92

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

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)

224

103

225

104

class AvahiError(Exception):

226

105

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

227

106

self.value = value

228

return super(AvahiError, self).__init__(value, *args,

229

**kwargs)

107

super(AvahiError, self).__init__(value, *args, **kwargs)

108

def __unicode__(self):

109

return unicode(repr(self.value))

230

110

231

111

class AvahiServiceError(AvahiError):

232

112

pass

243

123

Used to optionally bind to the specified interface.

244

124

name: string; Example: 'Mandos'

245

125

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

246

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

126

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

247

127

port: integer; what port to announce

248

128

TXT: list of strings; TXT record for the service

249

129

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

255

135

server: D-Bus Server

256

136

bus: dbus.SystemBus()

257

137

"""

258

259

138

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

260

139

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

261

140

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

274

153

self.server = None

275

154

self.bus = bus

276

155

self.entry_group_state_changed_match = None

277

278

156

def rename(self):

279

157

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

280

158

if self.rename_count >= self.max_renames:

282

160

" after %i retries, exiting.",

283

161

self.rename_count)

284

162

raise AvahiServiceError("Too many renames")

285

self.name = str(self.server

286

.GetAlternativeServiceName(self.name))

163

self.name = unicode(self.server

164

.GetAlternativeServiceName(self.name))

287

165

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

288

166

self.name)

167

syslogger.setFormatter(logging.Formatter

168

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

169

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

170

% self.name))

289

171

self.remove()

290

172

try:

291

173

self.add()

292

174

except dbus.exceptions.DBusException as error:

293

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

175

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

294

176

self.cleanup()

295

177

os._exit(1)

296

178

self.rename_count += 1

297

298

179

def remove(self):

299

180

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

300

181

if self.entry_group_state_changed_match is not None:

302

183

self.entry_group_state_changed_match = None

303

184

if self.group is not None:

304

185

self.group.Reset()

305

306

186

def add(self):

307

187

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

308

188

self.remove()

313

193

avahi.DBUS_INTERFACE_ENTRY_GROUP)

314

194

self.entry_group_state_changed_match = (

315

195

self.group.connect_to_signal(

316

'StateChanged', self.entry_group_state_changed))

196

'StateChanged', self .entry_group_state_changed))

317

197

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

318

198

self.name, self.type)

319

199

self.group.AddService(

325

205

dbus.UInt16(self.port),

326

206

avahi.string_array_to_txt_array(self.TXT))

327

207

self.group.Commit()

328

329

208

def entry_group_state_changed(self, state, error):

330

209

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

331

210

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

337

216

self.rename()

338

217

elif state == avahi.ENTRY_GROUP_FAILURE:

339

218

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

340

str(error))

341

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

342

.format(error))

343

219

unicode(error))

220

raise AvahiGroupError("State changed: %s"

221

% unicode(error))

344

222

def cleanup(self):

345

223

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

346

224

if self.group is not None:

347

225

try:

348

226

self.group.Free()

349

227

except (dbus.exceptions.UnknownMethodException,

350

dbus.exceptions.DBusException):

228

dbus.exceptions.DBusException) as e:

351

229

pass

352

230

self.group = None

353

231

self.remove()

354

355

232

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

356

233

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

357

234

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

376

253

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

377

254

else:

378

255

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

379

380

256

def activate(self):

381

257

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

382

258

if self.server is None:

390

266

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

391

267

392

268

393

class AvahiServiceToSyslog(AvahiService):

394

def rename(self):

395

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

396

ret = AvahiService.rename(self)

397

syslogger.setFormatter(logging.Formatter

398

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

399

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

400

.format(self.name)))

401

return ret

402

403

269

def _timedelta_to_milliseconds(td):

270

"Convert a datetime.timedelta() to milliseconds"

271

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

272

+ (td.seconds * 1000)

273

+ (td.microseconds // 1000))

274

404

275

class Client(object):

405

276

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

406

277

407

278

Attributes:

408

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

279

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

409

280

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

410

281

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

411

282

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

418

289

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

419

290

checker_initiator_tag: a gobject event source tag, or None

420

291

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

421

client_structure: Object describing what attributes a client has

422

and is used for storing the client at exit

423

292

current_checker_command: string; current running checker_command

293

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

424

294

disable_initiator_tag: a gobject event source tag, or None

425

295

enabled: bool()

426

296

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

429

299

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

430

300

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

431

301

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

432

last_checker_status: integer between 0 and 255 reflecting exit

433

status of last checker. -1 reflects crashed

434

checker, -2 means no checker completed yet.

435

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

302

last_enabled: datetime.datetime(); (UTC)

436

303

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

437

304

D-Bus identifiers

438

305

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

439

306

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

440

307

until this client is disabled

441

extended_timeout: extra long timeout when secret has been sent

308

extended_timeout: extra long timeout when password has been sent

442

309

runtime_expansions: Allowed attributes for runtime expansion.

443

310

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

444

311

disabled, or None

445

server_settings: The server_settings dict from main()

446

312

"""

447

313

448

314

runtime_expansions = ("approval_delay", "approval_duration",

449

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

450

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

451

"last_approval_request", "last_checked_ok",

315

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

316

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

452

317

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

453

client_defaults = { "timeout": "PT5M",

454

"extended_timeout": "PT15M",

455

"interval": "PT2M",

456

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

457

"host": "",

458

"approval_delay": "PT0S",

459

"approval_duration": "PT1S",

460

"approved_by_default": "True",

461

"enabled": "True",

462

}

463

464

@staticmethod

465

def config_parser(config):

466

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

467

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

468

with exceptions for any special settings as defined above.

469

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

470

value given the same arguments.

471

"""

472

settings = {}

473

for client_name in config.sections():

474

section = dict(config.items(client_name))

475

client = settings[client_name] = {}

476

477

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

478

# Reformat values from string types to Python types

479

client["approved_by_default"] = config.getboolean(

480

client_name, "approved_by_default")

481

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

482

"enabled")

483

484

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

485

.replace(" ", ""))

486

if "secret" in section:

487

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

488

elif "secfile" in section:

489

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

490

(section["secfile"])),

491

"rb") as secfile:

492

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

493

else:

494

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

495

.format(section))

496

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

497

client["extended_timeout"] = string_to_delta(

498

section["extended_timeout"])

499

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

500

client["approval_delay"] = string_to_delta(

501

section["approval_delay"])

502

client["approval_duration"] = string_to_delta(

503

section["approval_duration"])

504

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

505

client["last_approval_request"] = None

506

client["last_checked_ok"] = None

507

client["last_checker_status"] = -2

508

509

return settings

510

511

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

318

319

def timeout_milliseconds(self):

320

"Return the 'timeout' attribute in milliseconds"

321

return _timedelta_to_milliseconds(self.timeout)

322

323

def extended_timeout_milliseconds(self):

324

"Return the 'extended_timeout' attribute in milliseconds"

325

return _timedelta_to_milliseconds(self.extended_timeout)

326

327

def interval_milliseconds(self):

328

"Return the 'interval' attribute in milliseconds"

329

return _timedelta_to_milliseconds(self.interval)

330

331

def approval_delay_milliseconds(self):

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

512

338

self.name = name

513

if server_settings is None:

514

server_settings = {}

515

self.server_settings = server_settings

516

# adding all client settings

517

for setting, value in settings.items():

518

setattr(self, setting, value)

519

520

if self.enabled:

521

if not hasattr(self, "last_enabled"):

522

self.last_enabled = datetime.datetime.utcnow()

523

if not hasattr(self, "expires"):

524

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

525

+ self.timeout)

526

else:

527

self.last_enabled = None

528

self.expires = None

529

339

if config is None:

340

config = {}

530

341

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

531

342

# Uppercase and remove spaces from fingerprint for later

532

343

# comparison purposes with return value from the fingerprint()

533

344

# function

345

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

346

.replace(" ", ""))

534

347

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

535

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

536

datetime.datetime.utcnow())

537

538

# 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

539

369

self.checker = None

540

370

self.checker_initiator_tag = None

541

371

self.disable_initiator_tag = None

372

self.expires = None

542

373

self.checker_callback_tag = None

374

self.checker_command = config["checker"]

543

375

self.current_checker_command = None

544

self.approved = None

376

self.last_connect = None

377

self._approved = None

378

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

379

True)

545

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

546

385

self.changedstate = (multiprocessing_manager

547

386

.Condition(multiprocessing_manager

548

387

.Lock()))

549

self.client_structure = [attr for attr in

550

self.__dict__.iterkeys()

551

if not attr.startswith("_")]

552

self.client_structure.append("client_structure")

553

554

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

555

lambda obj:

556

isinstance(obj,

557

property)):

558

if not name.startswith("_"):

559

self.client_structure.append(name)

560

388

561

# Send notice to process children that client state has changed

562

389

def send_changedstate(self):

563

with self.changedstate:

564

self.changedstate.notify_all()

390

self.changedstate.acquire()

391

self.changedstate.notify_all()

392

self.changedstate.release()

565

393

566

394

def enable(self):

567

395

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

568

396

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

569

397

# Already enabled

570

398

return

399

self.send_changedstate()

400

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

401

# and every interval from then on.

402

self.checker_initiator_tag = (gobject.timeout_add

403

(self.interval_milliseconds(),

404

self.start_checker))

405

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

571

406

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

407

self.disable_initiator_tag = (gobject.timeout_add

408

(self.timeout_milliseconds(),

409

self.disable))

572

410

self.enabled = True

573

411

self.last_enabled = datetime.datetime.utcnow()

574

self.init_checker()

575

self.send_changedstate()

412

# Also start a new checker *right now*.

413

self.start_checker()

576

414

577

415

def disable(self, quiet=True):

578

416

"""Disable this client."""

579

417

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

580

418

return False

581

419

if not quiet:

420

self.send_changedstate()

421

if not quiet:

582

422

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

583

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

423

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

584

424

gobject.source_remove(self.disable_initiator_tag)

585

425

self.disable_initiator_tag = None

586

426

self.expires = None

587

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

427

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

588

428

gobject.source_remove(self.checker_initiator_tag)

589

429

self.checker_initiator_tag = None

590

430

self.stop_checker()

431

if self.disable_hook:

432

self.disable_hook(self)

591

433

self.enabled = False

592

if not quiet:

593

self.send_changedstate()

594

434

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

595

435

return False

596

436

597

437

def __del__(self):

438

self.disable_hook = None

598

439

self.disable()

599

440

600

def init_checker(self):

601

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

602

# and every interval from then on.

603

if self.checker_initiator_tag is not None:

604

gobject.source_remove(self.checker_initiator_tag)

605

self.checker_initiator_tag = (gobject.timeout_add

606

(int(self.interval

607

.total_seconds() * 1000),

608

self.start_checker))

609

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

610

if self.disable_initiator_tag is not None:

611

gobject.source_remove(self.disable_initiator_tag)

612

self.disable_initiator_tag = (gobject.timeout_add

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

616

# Also start a new checker *right now*.

617

self.start_checker()

618

619

441

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

620

442

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

621

443

self.checker_callback_tag = None

622

444

self.checker = None

623

445

if os.WIFEXITED(condition):

624

self.last_checker_status = os.WEXITSTATUS(condition)

625

if self.last_checker_status == 0:

446

exitstatus = os.WEXITSTATUS(condition)

447

if exitstatus == 0:

626

448

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

627

449

vars(self))

628

450

self.checked_ok()

630

452

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

631

453

vars(self))

632

454

else:

633

self.last_checker_status = -1

634

455

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

635

456

vars(self))

636

457

637

def checked_ok(self):

638

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

639

self.last_checked_ok = datetime.datetime.utcnow()

640

self.last_checker_status = 0

641

self.bump_timeout()

642

643

def bump_timeout(self, timeout=None):

644

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

"""

645

464

if timeout is None:

646

465

timeout = self.timeout

466

self.last_checked_ok = datetime.datetime.utcnow()

647

467

if self.disable_initiator_tag is not None:

648

468

gobject.source_remove(self.disable_initiator_tag)

649

self.disable_initiator_tag = None

650

469

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

651

470

self.disable_initiator_tag = (gobject.timeout_add

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

471

(_timedelta_to_milliseconds

472

(timeout), self.disable))

654

473

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

655

474

656

475

def need_approval(self):

662

481

If a checker already exists, leave it running and do

663

482

nothing."""

664

483

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

665

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

666

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

667

# would inevitably timeout, since no checker would get a

668

# 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

669

488

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

670

489

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

671

490

# should be.

673

492

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

674

493

try:

675

494

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

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

495

except (AttributeError, OSError) as error:

496

if (isinstance(error, OSError)

497

and error.errno != errno.ECHILD):

498

raise error

681

499

else:

682

500

if pid:

683

501

logger.warning("Checker was a zombie")

686

504

self.current_checker_command)

687

505

# Start a new checker if needed

688

506

if self.checker is None:

689

# Escape attributes for the shell

690

escaped_attrs = { attr:

691

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

692

for attr in self.runtime_expansions }

693

507

try:

694

command = self.checker_command % escaped_attrs

695

except TypeError as error:

696

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

697

self.checker_command, exc_info=error)

698

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

699

526

self.current_checker_command = command

700

527

try:

701

528

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

704

531

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

705

532

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

706

533

# always replaced by /dev/null.)

707

# The exception is when not debugging but nevertheless

708

# running in the foreground; use the previously

709

# created wnull.

710

popen_args = {}

711

if (not self.server_settings["debug"]

712

and self.server_settings["foreground"]):

713

popen_args.update({"stdout": wnull,

714

"stderr": wnull })

715

534

self.checker = subprocess.Popen(command,

716

535

close_fds=True,

717

shell=True, cwd="/",

718

**popen_args)

719

except OSError as error:

720

logger.error("Failed to start subprocess",

721

exc_info=error)

722

return True

723

self.checker_callback_tag = (gobject.child_watch_add

724

(self.checker.pid,

725

self.checker_callback,

726

data=command))

727

# The checker may have completed before the gobject

728

# watch was added. Check for this.

729

try:

536

shell=True, cwd="/")

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.

730

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)

731

547

except OSError as error:

732

if error.errno == errno.ECHILD:

733

# This should never happen

734

logger.error("Child process vanished",

735

exc_info=error)

736

return True

737

raise

738

if pid:

739

gobject.source_remove(self.checker_callback_tag)

740

self.checker_callback(pid, status, command)

548

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

549

error)

741

550

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

742

551

return True

743

552

750

559

return

751

560

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

752

561

try:

753

self.checker.terminate()

562

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

754

563

#time.sleep(0.5)

755

564

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

756

# self.checker.kill()

565

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

757

566

except OSError as error:

758

567

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

759

568

raise

776

585

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

777

586

if byte_arrays and signature != "ay":

778

587

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

779

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

588

" signature %r" % signature)

780

589

def decorator(func):

781

590

func._dbus_is_property = True

782

591

func._dbus_interface = dbus_interface

790

599

return decorator

791

600

792

601

793

def dbus_interface_annotations(dbus_interface):

794

"""Decorator for marking functions returning interface annotations

795

796

Usage:

797

798

@dbus_interface_annotations("org.example.Interface")

799

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

800

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

801

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

802

"false"}

803

"""

804

def decorator(func):

805

func._dbus_is_interface = True

806

func._dbus_interface = dbus_interface

807

func._dbus_name = dbus_interface

808

return func

809

return decorator

810

811

812

def dbus_annotations(annotations):

813

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

814

Usage:

815

816

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

817

"org.freedesktop.DBus.Property."

818

"EmitsChangedSignal": "false"})

819

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

820

access="r")

821

def Property_dbus_property(self):

822

return dbus.Boolean(False)

823

"""

824

def decorator(func):

825

func._dbus_annotations = annotations

826

return func

827

return decorator

828

829

830

602

class DBusPropertyException(dbus.exceptions.DBusException):

831

603

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

832

604

"""

833

pass

605

def __unicode__(self):

606

return unicode(str(self))

607

834

608

835

609

class DBusPropertyAccessException(DBusPropertyException):

836

610

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

853

627

"""

854

628

855

629

@staticmethod

856

def _is_dbus_thing(thing):

857

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

858

859

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

860

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

861

"""

862

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

863

False)

630

def _is_dbus_property(obj):

631

return getattr(obj, "_dbus_is_property", False)

864

632

865

def _get_all_dbus_things(self, thing):

633

def _get_all_dbus_properties(self):

866

634

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

867

635

"""

868

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

869

name),

870

athing.__get__(self))

636

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

871

637

for cls in self.__class__.__mro__

872

for name, athing in

873

inspect.getmembers(cls,

874

self._is_dbus_thing(thing)))

638

for name, prop in

639

inspect.getmembers(cls, self._is_dbus_property))

875

640

876

641

def _get_dbus_property(self, interface_name, property_name):

877

642

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

879

644

"""

880

645

for cls in self.__class__.__mro__:

881

646

for name, value in (inspect.getmembers

882

(cls,

883

self._is_dbus_thing("property"))):

647

(cls, self._is_dbus_property)):

884

648

if (value._dbus_name == property_name

885

649

and value._dbus_interface == interface_name):

886

650

return value.__get__(self)

914

678

# The byte_arrays option is not supported yet on

915

679

# signatures other than "ay".

916

680

if prop._dbus_signature != "ay":

917

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

918

"'ay' signature {!r}"

919

.format(prop._dbus_signature))

920

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

921

for byte in value))

681

raise ValueError

682

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

683

for byte in value))

922

684

prop(value)

923

685

924

686

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

929

691

930

692

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

931

693

"""

932

properties = {}

933

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

694

all = {}

695

for name, prop in self._get_all_dbus_properties():

934

696

if (interface_name

935

697

and interface_name != prop._dbus_interface):

936

698

# Interface non-empty but did not match

940

702

continue

941

703

value = prop()

942

704

if not hasattr(value, "variant_level"):

943

properties[name] = value

705

all[name] = value

944

706

continue

945

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

946

value.variant_level+1)

947

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

948

949

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

950

def PropertiesChanged(self, interface_name, changed_properties,

951

invalidated_properties):

952

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

953

standard.

954

"""

955

pass

707

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

708

value.variant_level+1)

709

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

956

710

957

711

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

958

712

out_signature="s",

959

713

path_keyword='object_path',

960

714

connection_keyword='connection')

961

715

def Introspect(self, object_path, connection):

962

"""Overloading of standard D-Bus method.

963

964

Inserts property tags and interface annotation tags.

716

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

965

717

"""

966

718

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

967

719

connection)

974

726

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

975

727

return e

976

728

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

977

# Add property tags

978

729

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

979

730

for name, prop

980

in self._get_all_dbus_things("property")

731

in self._get_all_dbus_properties()

981

732

if prop._dbus_interface

982

733

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

983

734

if_tag.appendChild(tag)

984

# Add annotation tags

985

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

986

for tag in if_tag.getElementsByTagName(typ):

987

annots = dict()

988

for name, prop in (self.

989

_get_all_dbus_things(typ)):

990

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

991

and prop._dbus_interface

992

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

993

annots.update(getattr

994

(prop,

995

"_dbus_annotations",

996

{}))

997

for name, value in annots.items():

998

ann_tag = document.createElement(

999

"annotation")

1000

ann_tag.setAttribute("name", name)

1001

ann_tag.setAttribute("value", value)

1002

tag.appendChild(ann_tag)

1003

# Add interface annotation tags

1004

for annotation, value in dict(

1005

itertools.chain.from_iterable(

1006

annotations().items()

1007

for name, annotations in

1008

self._get_all_dbus_things("interface")

1009

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

1010

)).items():

1011

ann_tag = document.createElement("annotation")

1012

ann_tag.setAttribute("name", annotation)

1013

ann_tag.setAttribute("value", value)

1014

if_tag.appendChild(ann_tag)

1015

735

# Add the names to the return values for the

1016

736

# "org.freedesktop.DBus.Properties" methods

1017

737

if (if_tag.getAttribute("name")

1032

752

except (AttributeError, xml.dom.DOMException,

1033

753

xml.parsers.expat.ExpatError) as error:

1034

754

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

1035

exc_info=error)

755

error)

1036

756

return xmlstring

1037

757

1038

758

1039

def datetime_to_dbus(dt, variant_level=0):

759

def datetime_to_dbus (dt, variant_level=0):

1040

760

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

1041

761

if dt is None:

1042

762

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

1043

763

return dbus.String(dt.isoformat(),

1044

764

variant_level=variant_level)

1045

765

1046

1047

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1048

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

1049

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

1050

interface names according to the "alt_interface_names" mapping.

1051

Usage:

1052

1053

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

1054

"net.example.AlternateInterface"})

1055

class SampleDBusObject(dbus.service.Object):

1056

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

1057

def SampleDBusMethod():

1058

pass

1059

1060

The above "SampleDBusMethod" on "SampleDBusObject" will be

1061

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

1062

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

1063

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

1064

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

1065

1066

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

1067

(from DBusObjectWithProperties) and interfaces (from the

1068

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.

1069

770

"""

1070

def wrapper(cls):

1071

for orig_interface_name, alt_interface_name in (

1072

alt_interface_names.items()):

1073

attr = {}

1074

interface_names = set()

1075

# Go though all attributes of the class

1076

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

1077

778

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

1078

779

# with the wrong interface name

1079

780

if (not hasattr(attribute, "_dbus_interface")

1080

781

or not attribute._dbus_interface

1081

.startswith(orig_interface_name)):

782

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

1082

783

continue

1083

784

# Create an alternate D-Bus interface name based on

1084

785

# the current name

1085

786

alt_interface = (attribute._dbus_interface

1086

.replace(orig_interface_name,

1087

alt_interface_name))

1088

interface_names.add(alt_interface)

787

.replace("se.recompile.Mandos",

788

"se.bsnet.fukt.Mandos"))

1089

789

# Is this a D-Bus signal?

1090

790

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

1091

# Extract the original non-method undecorated

1092

# function by black magic

791

# Extract the original non-method function by

792

# black magic

1093

793

nonmethod_func = (dict(

1094

794

zip(attribute.func_code.co_freevars,

1095

795

attribute.__closure__))["func"]

1106

806

nonmethod_func.func_name,

1107

807

nonmethod_func.func_defaults,

1108

808

nonmethod_func.func_closure)))

1109

# Copy annotations, if any

1110

try:

1111

new_function._dbus_annotations = (

1112

dict(attribute._dbus_annotations))

1113

except AttributeError:

1114

pass

1115

809

# Define a creator of a function to call both the

1116

# original and alternate functions, so both the

1117

# original and alternate signals gets sent when

1118

# the function is called

810

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

811

# signals gets sent when the function is called

1119

812

def fixscope(func1, func2):

1120

813

"""This function is a scope container to pass

1121

814

func1 and func2 to the "call_both" function

1128

821

return call_both

1129

822

# Create the "call_both" function and add it to

1130

823

# the class

1131

attr[attrname] = fixscope(attribute, new_function)

824

attr[attrname] = fixscope(attribute,

825

new_function)

1132

826

# Is this a D-Bus method?

1133

827

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

1134

828

# Create a new, but exactly alike, function

1145

839

attribute.func_name,

1146

840

attribute.func_defaults,

1147

841

attribute.func_closure)))

1148

# Copy annotations, if any

1149

try:

1150

attr[attrname]._dbus_annotations = (

1151

dict(attribute._dbus_annotations))

1152

except AttributeError:

1153

pass

1154

842

# Is this a D-Bus property?

1155

843

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

1156

844

# Create a new, but exactly alike, function

1170

858

attribute.func_name,

1171

859

attribute.func_defaults,

1172

860

attribute.func_closure)))

1173

# Copy annotations, if any

1174

try:

1175

attr[attrname]._dbus_annotations = (

1176

dict(attribute._dbus_annotations))

1177

except AttributeError:

1178

pass

1179

# Is this a D-Bus interface?

1180

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

1181

# Create a new, but exactly alike, function

1182

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

1183

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

1184

# to the class.

1185

attr[attrname] = (dbus_interface_annotations

1186

(alt_interface)

1187

(types.FunctionType

1188

(attribute.func_code,

1189

attribute.func_globals,

1190

attribute.func_name,

1191

attribute.func_defaults,

1192

attribute.func_closure)))

1193

if deprecate:

1194

# Deprecate all alternate interfaces

1195

iname="_AlternateDBusNames_interface_annotation{}"

1196

for interface_name in interface_names:

1197

@dbus_interface_annotations(interface_name)

1198

def func(self):

1199

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

1200

"true" }

1201

# Find an unused name

1202

for aname in (iname.format(i)

1203

for i in itertools.count()):

1204

if aname not in attr:

1205

attr[aname] = func

1206

break

1207

if interface_names:

1208

# Replace the class with a new subclass of it with

1209

# methods, signals, etc. as created above.

1210

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

1211

(cls,), attr)

1212

return cls

1213

return wrapper

1214

1215

1216

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

1217

"se.bsnet.fukt.Mandos"})

861

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

862

1218

863

class ClientDBus(Client, DBusObjectWithProperties):

1219

864

"""A Client class using D-Bus

1220

865

1226

871

runtime_expansions = (Client.runtime_expansions

1227

872

+ ("dbus_object_path",))

1228

873

1229

_interface = "se.recompile.Mandos.Client"

1230

1231

874

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

1232

875

1233

876

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

877

self._approvals_pending = 0

1234

878

self.bus = bus

1235

879

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

1236

880

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

1237

881

# the D-Bus

1238

client_object_name = str(self.name).translate(

882

client_object_name = unicode(self.name).translate(

1239

883

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

1240

884

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

1241

885

self.dbus_object_path = (dbus.ObjectPath

1242

886

("/clients/" + client_object_name))

1243

887

DBusObjectWithProperties.__init__(self, self.bus,

1244

888

self.dbus_object_path)

1245

889

1246

890

def notifychangeproperty(transform_func,

1247

891

dbus_name, type_func=lambda x: x,

1248

variant_level=1, invalidate_only=False,

1249

_interface=_interface):

892

variant_level=1):

1250

893

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

1251

894

its changes to DBus.

1252

895

1253

896

transform_fun: Function that takes a value and a variant_level

1254

897

and transforms it to a D-Bus type.

1255

898

dbus_name: D-Bus name of the variable

1257

900

to the D-Bus. Default: no transform

1258

901

variant_level: D-Bus variant level. Default: 1

1259

902

"""

1260

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

903

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

1261

904

def setter(self, value):

1262

905

if hasattr(self, "dbus_object_path"):

1263

906

if (not hasattr(self, attrname) or

1264

907

type_func(getattr(self, attrname, None))

1265

908

!= type_func(value)):

1266

if invalidate_only:

1267

self.PropertiesChanged(_interface,

1268

dbus.Dictionary(),

1269

dbus.Array

1270

((dbus_name,)))

1271

else:

1272

dbus_value = transform_func(type_func(value),

1273

variant_level

1274

=variant_level)

1275

self.PropertyChanged(dbus.String(dbus_name),

1276

dbus_value)

1277

self.PropertiesChanged(_interface,

1278

dbus.Dictionary({

1279

dbus.String(dbus_name):

1280

dbus_value }), dbus.Array())

909

dbus_value = transform_func(type_func(value),

910

variant_level

911

=variant_level)

912

self.PropertyChanged(dbus.String(dbus_name),

913

dbus_value)

1281

914

setattr(self, attrname, value)

1282

915

1283

916

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

1284

917

918

1285

919

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1286

920

approvals_pending = notifychangeproperty(dbus.Boolean,

1287

921

"ApprovalPending",

1294

928

checker is not None)

1295

929

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1296

930

"LastCheckedOK")

1297

last_checker_status = notifychangeproperty(dbus.Int16,

1298

"LastCheckerStatus")

1299

931

last_approval_request = notifychangeproperty(

1300

932

datetime_to_dbus, "LastApprovalRequest")

1301

933

approved_by_default = notifychangeproperty(dbus.Boolean,

1302

934

"ApprovedByDefault")

1303

approval_delay = notifychangeproperty(dbus.UInt64,

935

approval_delay = notifychangeproperty(dbus.UInt16,

1304

936

"ApprovalDelay",

1305

937

type_func =

1306

lambda td: td.total_seconds()

1307

* 1000)

938

_timedelta_to_milliseconds)

1308

939

approval_duration = notifychangeproperty(

1309

dbus.UInt64, "ApprovalDuration",

1310

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

940

dbus.UInt16, "ApprovalDuration",

941

type_func = _timedelta_to_milliseconds)

1311

942

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

1312

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

1313

type_func = lambda td:

1314

td.total_seconds() * 1000)

943

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

944

type_func =

945

_timedelta_to_milliseconds)

1315

946

extended_timeout = notifychangeproperty(

1316

dbus.UInt64, "ExtendedTimeout",

1317

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

1318

interval = notifychangeproperty(dbus.UInt64,

947

dbus.UInt16, "ExtendedTimeout",

948

type_func = _timedelta_to_milliseconds)

949

interval = notifychangeproperty(dbus.UInt16,

1319

950

"Interval",

1320

951

type_func =

1321

lambda td: td.total_seconds()

1322

* 1000)

952

_timedelta_to_milliseconds)

1323

953

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

1324

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

1325

invalidate_only=True)

1326

954

1327

955

del notifychangeproperty

1328

956

1355

983

*args, **kwargs)

1356

984

1357

985

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

1358

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

986

old_checker = self.checker

987

if self.checker is not None:

988

old_checker_pid = self.checker.pid

989

else:

990

old_checker_pid = None

1359

991

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

1360

992

# Only if new checker process was started

1361

993

if (self.checker is not None

1365

997

return r

1366

998

1367

999

def _reset_approved(self):

1368

self.approved = None

1000

self._approved = None

1369

1001

return False

1370

1002

1371

1003

def approve(self, value=True):

1372

self.approved = value

1373

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

1374

* 1000), self._reset_approved)

1375

1004

self.send_changedstate()

1005

self._approved = value

1006

gobject.timeout_add(_timedelta_to_milliseconds

1007

(self.approval_duration),

1008

self._reset_approved)

1009

1376

1010

1377

1011

## D-Bus methods, signals & properties

1378

1379

## Interfaces

1012

_interface = "se.recompile.Mandos.Client"

1380

1013

1381

1014

## Signals

1382

1015

1393

1026

pass

1394

1027

1395

1028

# PropertyChanged - signal

1396

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

1397

1029

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

1398

1030

def PropertyChanged(self, property, value):

1399

1031

"D-Bus signal"

1475

1107

access="readwrite")

1476

1108

def ApprovalDelay_dbus_property(self, value=None):

1477

1109

if value is None: # get

1478

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

1479

* 1000)

1110

return dbus.UInt64(self.approval_delay_milliseconds())

1480

1111

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

1481

1112

1482

1113

# ApprovalDuration - property

1484

1115

access="readwrite")

1485

1116

def ApprovalDuration_dbus_property(self, value=None):

1486

1117

if value is None: # get

1487

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

1488

* 1000)

1118

return dbus.UInt64(_timedelta_to_milliseconds(

1119

self.approval_duration))

1489

1120

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

1490

1121

1491

1122

# Name - property

1504

1135

def Host_dbus_property(self, value=None):

1505

1136

if value is None: # get

1506

1137

return dbus.String(self.host)

1507

self.host = str(value)

1138

self.host = value

1508

1139

1509

1140

# Created - property

1510

1141

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

1511

1142

def Created_dbus_property(self):

1512

return datetime_to_dbus(self.created)

1143

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

1513

1144

1514

1145

# LastEnabled - property

1515

1146

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

1536

1167

return

1537

1168

return datetime_to_dbus(self.last_checked_ok)

1538

1169

1539

# LastCheckerStatus - property

1540

@dbus_service_property(_interface, signature="n",

1541

access="read")

1542

def LastCheckerStatus_dbus_property(self):

1543

return dbus.Int16(self.last_checker_status)

1544

1545

1170

# Expires - property

1546

1171

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

1547

1172

def Expires_dbus_property(self):

1557

1182

access="readwrite")

1558

1183

def Timeout_dbus_property(self, value=None):

1559

1184

if value is None: # get

1560

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

1561

old_timeout = self.timeout

1185

return dbus.UInt64(self.timeout_milliseconds())

1562

1186

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

1563

# Reschedule disabling

1564

if self.enabled:

1565

now = datetime.datetime.utcnow()

1566

self.expires += self.timeout - old_timeout

1567

if self.expires <= now:

1568

# The timeout has passed

1569

self.disable()

1570

else:

1571

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

1572

is None):

1573

return

1574

gobject.source_remove(self.disable_initiator_tag)

1575

self.disable_initiator_tag = (

1576

gobject.timeout_add(

1577

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

1578

* 1000), 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))

1579

1207

1580

1208

# ExtendedTimeout - property

1581

1209

@dbus_service_property(_interface, signature="t",

1582

1210

access="readwrite")

1583

1211

def ExtendedTimeout_dbus_property(self, value=None):

1584

1212

if value is None: # get

1585

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

1586

* 1000)

1213

return dbus.UInt64(self.extended_timeout_milliseconds())

1587

1214

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

1588

1215

1589

1216

# Interval - property

1591

1218

access="readwrite")

1592

1219

def Interval_dbus_property(self, value=None):

1593

1220

if value is None: # get

1594

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

1221

return dbus.UInt64(self.interval_milliseconds())

1595

1222

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

1596

1223

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

1597

1224

return

1598

if self.enabled:

1599

# Reschedule checker run

1600

gobject.source_remove(self.checker_initiator_tag)

1601

self.checker_initiator_tag = (gobject.timeout_add

1602

(value, self.start_checker))

1603

self.start_checker() # Start one now, too

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

1604

1230

1605

1231

# Checker - property

1606

1232

@dbus_service_property(_interface, signature="s",

1608

1234

def Checker_dbus_property(self, value=None):

1609

1235

if value is None: # get

1610

1236

return dbus.String(self.checker_command)

1611

self.checker_command = str(value)

1237

self.checker_command = value

1612

1238

1613

1239

# CheckerRunning - property

1614

1240

@dbus_service_property(_interface, signature="b",

1630

1256

@dbus_service_property(_interface, signature="ay",

1631

1257

access="write", byte_arrays=True)

1632

1258

def Secret_dbus_property(self, value):

1633

self.secret = bytes(value)

1259

self.secret = str(value)

1634

1260

1635

1261

del _interface

1636

1262

1643

1269

raise KeyError()

1644

1270

1645

1271

def __getattribute__(self, name):

1646

if name == '_pipe':

1272

if(name == '_pipe'):

1647

1273

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

1648

1274

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

1649

1275

data = self._pipe.recv()

1656

1282

return func

1657

1283

1658

1284

def __setattr__(self, name, value):

1659

if name == '_pipe':

1285

if(name == '_pipe'):

1660

1286

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

1661

1287

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

1662

1288

1289

class ClientDBusTransitional(ClientDBus):

1290

__metaclass__ = AlternateDBusNamesMetaclass

1663

1291

1664

1292

class ClientHandler(socketserver.BaseRequestHandler, object):

1665

1293

"""A class to handle client connections.

1670

1298

def handle(self):

1671

1299

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

1672

1300

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

1673

str(self.client_address))

1301

unicode(self.client_address))

1674

1302

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

1675

1303

self.server.child_pipe.fileno())

1676

1304

1702

1330

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

1703

1331

try:

1704

1332

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

1705

raise RuntimeError(line)

1333

raise RuntimeError

1706

1334

except (ValueError, IndexError, RuntimeError) as error:

1707

1335

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

1708

1336

return

1748

1376

client.Rejected("Disabled")

1749

1377

return

1750

1378

1751

if client.approved or not client.approval_delay:

1379

if client._approved or not client.approval_delay:

1752

1380

#We are approved or approval is disabled

1753

1381

break

1754

elif client.approved is None:

1382

elif client._approved is None:

1755

1383

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

1756

1384

client.name)

1757

1385

if self.server.use_dbus:

1758

1386

# Emit D-Bus signal

1759

1387

client.NeedApproval(

1760

client.approval_delay.total_seconds()

1761

* 1000, client.approved_by_default)

1388

client.approval_delay_milliseconds(),

1389

client.approved_by_default)

1762

1390

else:

1763

1391

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

1764

1392

client.name)

1770

1398

#wait until timeout or approved

1771

1399

time = datetime.datetime.now()

1772

1400

client.changedstate.acquire()

1773

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

1401

(client.changedstate.wait

1402

(float(client._timedelta_to_milliseconds(delay)

1403

/ 1000)))

1774

1404

client.changedstate.release()

1775

1405

time2 = datetime.datetime.now()

1776

1406

if (time2 - time) >= delay:

1792

1422

try:

1793

1423

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

1794

1424

except gnutls.errors.GNUTLSError as error:

1795

logger.warning("gnutls send failed",

1796

exc_info=error)

1425

logger.warning("gnutls send failed")

1797

1426

return

1798

1427

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

1799

1428

sent, len(client.secret)

1802

1431

1803

1432

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

1804

1433

# bump the timeout using extended_timeout

1805

client.bump_timeout(client.extended_timeout)

1434

client.checked_ok(client.extended_timeout)

1806

1435

if self.server.use_dbus:

1807

1436

# Emit D-Bus signal

1808

1437

client.GotSecret()

1813

1442

try:

1814

1443

session.bye()

1815

1444

except gnutls.errors.GNUTLSError as error:

1816

logger.warning("GnuTLS bye failed",

1817

exc_info=error)

1445

logger.warning("GnuTLS bye failed")

1818

1446

1819

1447

@staticmethod

1820

1448

def peer_certificate(session):

1876

1504

# Convert the buffer to a Python bytestring

1877

1505

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

1878

1506

# Convert the bytestring to hexadecimal notation

1879

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

1507

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

1880

1508

return hex_fpr

1881

1509

1882

1510

1885

1513

def sub_process_main(self, request, address):

1886

1514

try:

1887

1515

self.finish_request(request, address)

1888

except Exception:

1516

except:

1889

1517

self.handle_error(request, address)

1890

1518

self.close_request(request)

1891

1519

1892

1520

def process_request(self, request, address):

1893

1521

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

1894

1522

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

1895

args = (request, address))

1523

args = (request,

1524

address))

1896

1525

proc.start()

1897

1526

return proc

1898

1527

1913

1542

1914

1543

def add_pipe(self, parent_pipe, proc):

1915

1544

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

1916

raise NotImplementedError()

1545

raise NotImplementedError

1917

1546

1918

1547

1919

1548

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1926

1555

use_ipv6: Boolean; to use IPv6 or not

1927

1556

"""

1928

1557

def __init__(self, server_address, RequestHandlerClass,

1929

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

1930

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

1931

creating a new one with socket.socket().

1932

"""

1558

interface=None, use_ipv6=True):

1933

1559

self.interface = interface

1934

1560

if use_ipv6:

1935

1561

self.address_family = socket.AF_INET6

1936

if socketfd is not None:

1937

# Save the file descriptor

1938

self.socketfd = socketfd

1939

# Save the original socket.socket() function

1940

self.socket_socket = socket.socket

1941

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

1942

#

1943

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

1944

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

1945

# patching socket.socket.)

1946

#

1947

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

1948

@functools.wraps(socket.socket)

1949

def socket_wrapper(*args, **kwargs):

1950

# Restore original function so subsequent calls are

1951

# not affected.

1952

socket.socket = self.socket_socket

1953

del self.socket_socket

1954

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

1955

# saved file descriptor.

1956

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

1957

# Replace socket.socket() function with wrapper

1958

socket.socket = socket_wrapper

1959

# The socketserver.TCPServer.__init__ will call

1960

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

1961

# socket_wrapper(), if socketfd was set.

1962

1562

socketserver.TCPServer.__init__(self, server_address,

1963

1563

RequestHandlerClass)

1964

1965

1564

def server_bind(self):

1966

1565

"""This overrides the normal server_bind() function

1967

1566

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

1975

1574

try:

1976

1575

self.socket.setsockopt(socket.SOL_SOCKET,

1977

1576

SO_BINDTODEVICE,

1978

(self.interface + "\0")

1979

.encode("utf-8"))

1577

str(self.interface

1578

+ '\0'))

1980

1579

except socket.error as error:

1981

if error.errno == errno.EPERM:

1982

logger.error("No permission to bind to"

1983

" interface %s", self.interface)

1984

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:

1985

1585

logger.error("SO_BINDTODEVICE not available;"

1986

1586

" cannot bind to interface %s",

1987

1587

self.interface)

1988

elif error.errno == errno.ENODEV:

1989

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

1990

" cannot bind", self.interface)

1991

1588

else:

1992

1589

raise

1993

1590

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

1996

1593

if self.address_family == socket.AF_INET6:

1997

1594

any_address = "::" # in6addr_any

1998

1595

else:

1999

any_address = "0.0.0.0" # INADDR_ANY

1596

any_address = socket.INADDR_ANY

2000

1597

self.server_address = (any_address,

2001

1598

self.server_address[1])

2002

1599

elif not self.server_address[1]:

2023

1620

"""

2024

1621

def __init__(self, server_address, RequestHandlerClass,

2025

1622

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

2026

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

1623

gnutls_priority=None, use_dbus=True):

2027

1624

self.enabled = False

2028

1625

self.clients = clients

2029

1626

if self.clients is None:

2030

self.clients = {}

1627

self.clients = set()

2031

1628

self.use_dbus = use_dbus

2032

1629

self.gnutls_priority = gnutls_priority

2033

1630

IPv6_TCPServer.__init__(self, server_address,

2034

1631

RequestHandlerClass,

2035

1632

interface = interface,

2036

use_ipv6 = use_ipv6,

2037

socketfd = socketfd)

1633

use_ipv6 = use_ipv6)

2038

1634

def server_activate(self):

2039

1635

if self.enabled:

2040

1636

return socketserver.TCPServer.server_activate(self)

2053

1649

2054

1650

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

2055

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)

2056

1666

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

2057

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

1667

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

2058

1668

# Wait for other process to exit

2059

1669

proc.join()

2060

1670

return False

2067

1677

fpr = request[1]

2068

1678

address = request[2]

2069

1679

2070

for c in self.clients.itervalues():

1680

for c in self.clients:

2071

1681

if c.fingerprint == fpr:

2072

1682

client = c

2073

1683

break

2118

1728

return True

2119

1729

2120

1730

2121

def rfc3339_duration_to_delta(duration):

2122

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

2123

2124

>>> rfc3339_duration_to_delta("P7D")

2125

datetime.timedelta(7)

2126

>>> rfc3339_duration_to_delta("PT60S")

2127

datetime.timedelta(0, 60)

2128

>>> rfc3339_duration_to_delta("PT60M")

2129

datetime.timedelta(0, 3600)

2130

>>> rfc3339_duration_to_delta("PT24H")

2131

datetime.timedelta(1)

2132

>>> rfc3339_duration_to_delta("P1W")

2133

datetime.timedelta(7)

2134

>>> rfc3339_duration_to_delta("PT5M30S")

2135

datetime.timedelta(0, 330)

2136

>>> rfc3339_duration_to_delta("P1DT3M20S")

2137

datetime.timedelta(1, 200)

2138

"""

2139

2140

# Parsing an RFC 3339 duration with regular expressions is not

2141

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

2142

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

2143

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

2144

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

2145

# avoid excessive use of external libraries.

2146

2147

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

2148

Token = collections.namedtuple("Token",

2149

("regexp", # To match token; if

2150

# "value" is not None,

2151

# must have a "group"

2152

# containing digits

2153

"value", # datetime.timedelta or

2154

# None

2155

"followers")) # Tokens valid after

2156

# this token

2157

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

2158

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

2159

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

2160

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

2161

datetime.timedelta(seconds=1),

2162

frozenset((token_end,)))

2163

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

2164

datetime.timedelta(minutes=1),

2165

frozenset((token_second, token_end)))

2166

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

2167

datetime.timedelta(hours=1),

2168

frozenset((token_minute, token_end)))

2169

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

2170

None,

2171

frozenset((token_hour, token_minute,

2172

token_second)))

2173

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

2174

datetime.timedelta(days=1),

2175

frozenset((token_time, token_end)))

2176

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

2177

datetime.timedelta(weeks=4),

2178

frozenset((token_day, token_end)))

2179

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

2180

datetime.timedelta(weeks=52),

2181

frozenset((token_month, token_end)))

2182

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

2183

datetime.timedelta(weeks=1),

2184

frozenset((token_end,)))

2185

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

2186

frozenset((token_year, token_month,

2187

token_day, token_time,

2188

token_week)))

2189

# Define starting values

2190

value = datetime.timedelta() # Value so far

2191

found_token = None

2192

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

2193

s = duration # String left to parse

2194

# Loop until end token is found

2195

while found_token is not token_end:

2196

# Search for any currently valid tokens

2197

for token in followers:

2198

match = token.regexp.match(s)

2199

if match is not None:

2200

# Token found

2201

if token.value is not None:

2202

# Value found, parse digits

2203

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

2204

# Add to value so far

2205

value += factor * token.value

2206

# Strip token from string

2207

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

2208

# Go to found token

2209

found_token = token

2210

# Set valid next tokens

2211

followers = found_token.followers

2212

break

2213

else:

2214

# No currently valid tokens were found

2215

raise ValueError("Invalid RFC 3339 duration")

2216

# End token found

2217

return value

2218

2219

2220

1731

def string_to_delta(interval):

2221

1732

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

2222

1733

2233

1744

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

2234

1745

datetime.timedelta(0, 330)

2235

1746

"""

2236

2237

try:

2238

return rfc3339_duration_to_delta(interval)

2239

except ValueError:

2240

pass

2241

2242

1747

timevalue = datetime.timedelta(0)

2243

1748

for s in interval.split():

2244

1749

try:

2245

suffix = s[-1]

1750

suffix = unicode(s[-1])

2246

1751

value = int(s[:-1])

2247

1752

if suffix == "d":

2248

1753

delta = datetime.timedelta(value)

2255

1760

elif suffix == "w":

2256

1761

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

2257

1762

else:

2258

raise ValueError("Unknown suffix {!r}"

2259

.format(suffix))

2260

except IndexError as e:

1763

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

1764

except (ValueError, IndexError) as e:

2261

1765

raise ValueError(*(e.args))

2262

1766

timevalue += delta

2263

1767

return timevalue

2264

1768

2265

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

2266

1794

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

2267

1795

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

2268

1796

2276

1804

sys.exit()

2277

1805

if not noclose:

2278

1806

# Close all standard open file descriptors

2279

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

1807

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

2280

1808

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

2281

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

2282

.format(os.devnull))

1809

raise OSError(errno.ENODEV,

1810

"%s not a character device"

1811

% os.path.devnull)

2283

1812

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

2284

1813

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

2285

1814

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

2294

1823

2295

1824

parser = argparse.ArgumentParser()

2296

1825

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

2297

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

1826

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

2298

1827

help="show version number and exit")

2299

1828

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

2300

1829

help="Bind to interface IF")

2306

1835

help="Run self-test")

2307

1836

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

2308

1837

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

2309

" to terminal", default=None)

1838

" to terminal")

2310

1839

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

2311

1840

help="Debug level for stdout output")

2312

1841

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

2319

1848

" files")

2320

1849

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

2321

1850

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

2322

" system bus interface", default=None)

1851

" system bus interface")

2323

1852

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

2324

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

2325

default=None)

2326

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

2327

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

2328

" state", default=None)

2329

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

2330

help="Specify a file descriptor to a network"

2331

" socket to use instead of creating one")

2332

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

2333

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

2334

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

2335

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

2336

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

2337

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

2338

default=None)

2339

1853

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

2340

1854

options = parser.parse_args()

2341

1855

2342

1856

if options.check:

2343

1857

import doctest

2344

fail_count, test_count = doctest.testmod()

2345

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

1858

doctest.testmod()

1859

sys.exit()

2346

1860

2347

1861

# Default values for config file for server-global settings

2348

1862

server_defaults = { "interface": "",

2350

1864

"port": "",

2351

1865

"debug": "False",

2352

1866

"priority":

2353

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

1867

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

2354

1868

"servicename": "Mandos",

2355

1869

"use_dbus": "True",

2356

1870

"use_ipv6": "True",

2357

1871

"debuglevel": "",

2358

"restore": "True",

2359

"socket": "",

2360

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

2361

"foreground": "False",

2362

"zeroconf": "True",

2363

1872

}

2364

1873

2365

1874

# Parse config file for server-global settings

2370

1879

# Convert the SafeConfigParser object to a dict

2371

1880

server_settings = server_config.defaults()

2372

1881

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

2373

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

1882

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

2374

1883

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

2375

1884

option)

2376

1885

if server_settings["port"]:

2377

1886

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

2378

1887

"port")

2379

if server_settings["socket"]:

2380

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

2381

"socket")

2382

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

2383

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

2384

# happen with a supplied network socket.

2385

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

2386

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

2387

["socket"])

2388

1888

del server_config

2389

1889

2390

1890

# Override the settings from the config file with command line

2391

1891

# options, if set.

2392

1892

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

2393

1893

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

2394

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

2395

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

1894

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

2396

1895

value = getattr(options, option)

2397

1896

if value is not None:

2398

1897

server_settings[option] = value

2399

1898

del options

2400

1899

# Force all strings to be unicode

2401

1900

for option in server_settings.keys():

2402

if isinstance(server_settings[option], bytes):

2403

server_settings[option] = (server_settings[option]

2404

.decode("utf-8"))

2405

# Force all boolean options to be boolean

2406

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

2407

"foreground", "zeroconf"):

2408

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

2409

# Debug implies foreground

2410

if server_settings["debug"]:

2411

server_settings["foreground"] = True

1901

if type(server_settings[option]) is str:

1902

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

2412

1903

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

2413

1904

2414

1905

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

2415

1906

2416

if (not server_settings["zeroconf"] and

2417

not (server_settings["port"]

2418

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

2419

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

2420

" Zeroconf")

2421

2422

1907

# For convenience

2423

1908

debug = server_settings["debug"]

2424

1909

debuglevel = server_settings["debuglevel"]

2425

1910

use_dbus = server_settings["use_dbus"]

2426

1911

use_ipv6 = server_settings["use_ipv6"]

2427

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

2428

stored_state_file)

2429

foreground = server_settings["foreground"]

2430

zeroconf = server_settings["zeroconf"]

2431

2432

if debug:

2433

initlogger(debug, logging.DEBUG)

2434

else:

2435

if not debuglevel:

2436

initlogger(debug)

2437

else:

2438

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

2439

initlogger(debug, level)

2440

1912

2441

1913

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

2442

1914

syslogger.setFormatter(logging.Formatter

2443

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

2444

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

2445

.format(server_settings

2446

["servicename"])))

1915

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

1916

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

1917

% server_settings["servicename"]))

2447

1918

2448

1919

# Parse config file with clients

2449

client_config = configparser.SafeConfigParser(Client

2450

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

2451

1929

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

2452

1930

"clients.conf"))

2453

1931

2454

1932

global mandos_dbus_service

2455

1933

mandos_dbus_service = None

2456

1934

2457

socketfd = None

2458

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

2459

socketfd = server_settings["socket"]

2460

1935

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

2461

1936

server_settings["port"]),

2462

1937

ClientHandler,

2465

1940

use_ipv6=use_ipv6,

2466

1941

gnutls_priority=

2467

1942

server_settings["priority"],

2468

use_dbus=use_dbus,

2469

socketfd=socketfd)

2470

if not foreground:

2471

pidfilename = "/run/mandos.pid"

2472

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

2473

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

2474

pidfile = None

1943

use_dbus=use_dbus)

1944

if not debug:

1945

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

2475

1946

try:

2476

1947

pidfile = open(pidfilename, "w")

2477

except IOError as e:

2478

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

2479

exc_info=e)

1948

except IOError:

1949

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

2480

1950

2481

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:

2482

1955

try:

2483

uid = pwd.getpwnam(name).pw_uid

2484

gid = pwd.getpwnam(name).pw_gid

2485

break

1956

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

1957

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

2486

1958

except KeyError:

2487

continue

2488

else:

2489

uid = 65534

2490

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

2491

1965

try:

2492

1966

os.setgid(gid)

2493

1967

os.setuid(uid)

2494

1968

except OSError as error:

2495

if error.errno != errno.EPERM:

2496

raise

1969

if error[0] != errno.EPERM:

1970

raise error

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)

2497

1979

2498

1980

if debug:

2499

1981

# Enable all possible GnuTLS debugging

2510

1992

.gnutls_global_set_log_function(debug_gnutls))

2511

1993

2512

1994

# Redirect stdin so all checkers get /dev/null

2513

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

1995

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

2514

1996

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

2515

1997

if null > 2:

2516

1998

os.close(null)

1999

else:

2000

# No console logging

2001

logger.removeHandler(console)

2517

2002

2518

2003

# Need to fork before connecting to D-Bus

2519

if not foreground:

2004

if not debug:

2520

2005

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

2521

2006

daemon()

2522

2007

2523

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

2524

# need to inform gobject that threads will be used.

2525

gobject.threads_init()

2526

2527

2008

global main_loop

2528

2009

# From the Avahi example code

2529

DBusGMainLoop(set_as_default=True)

2010

DBusGMainLoop(set_as_default=True )

2530

2011

main_loop = gobject.MainLoop()

2531

2012

bus = dbus.SystemBus()

2532

2013

# End of Avahi example code

2538

2019

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

2539

2020

do_not_queue=True))

2540

2021

except dbus.exceptions.NameExistsException as e:

2541

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

2022

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

2542

2023

use_dbus = False

2543

2024

server_settings["use_dbus"] = False

2544

2025

tcp_server.use_dbus = False

2545

if zeroconf:

2546

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2547

service = AvahiServiceToSyslog(name =

2548

server_settings["servicename"],

2549

servicetype = "_mandos._tcp",

2550

protocol = protocol, bus = bus)

2551

if server_settings["interface"]:

2552

service.interface = (if_nametoindex

2553

(server_settings["interface"]

2554

.encode("utf-8")))

2026

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2027

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

2028

servicetype = "_mandos._tcp",

2029

protocol = protocol, bus = bus)

2030

if server_settings["interface"]:

2031

service.interface = (if_nametoindex

2032

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

2555

2033

2556

2034

global multiprocessing_manager

2557

2035

multiprocessing_manager = multiprocessing.Manager()

2558

2036

2559

2037

client_class = Client

2560

2038

if use_dbus:

2561

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

2562

2563

client_settings = Client.config_parser(client_config)

2564

old_client_settings = {}

2565

clients_data = {}

2566

2567

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

2568

global wnull

2569

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

2570

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

2571

# mode

2572

if debug or not foreground:

2573

wnull.close()

2574

2575

# Get client data and settings from last running state.

2576

if server_settings["restore"]:

2577

try:

2578

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

2579

clients_data, old_client_settings = (pickle.load

2580

(stored_state))

2581

os.remove(stored_state_path)

2582

except IOError as e:

2583

if e.errno == errno.ENOENT:

2584

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

2585

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

2586

else:

2587

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

2588

exc_info=e)

2589

raise

2590

except EOFError as e:

2591

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

2592

"EOFError:", exc_info=e)

2593

2594

with PGPEngine() as pgp:

2595

for client_name, client in clients_data.items():

2596

# Skip removed clients

2597

if client_name not in client_settings:

2598

continue

2599

2600

# Decide which value to use after restoring saved state.

2601

# We have three different values: Old config file,

2602

# new config file, and saved state.

2603

# New config value takes precedence if it differs from old

2604

# config value, otherwise use saved state.

2605

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

2606

try:

2607

# For each value in new config, check if it

2608

# differs from the old config value (Except for

2609

# the "secret" attribute)

2610

if (name != "secret" and

2611

value != old_client_settings[client_name]

2612

[name]):

2613

client[name] = value

2614

except KeyError:

2615

pass

2616

2617

# Clients who has passed its expire date can still be

2618

# enabled if its last checker was successful. Clients

2619

# whose checker succeeded before we stored its state is

2620

# assumed to have successfully run all checkers during

2621

# downtime.

2622

if client["enabled"]:

2623

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

2624

if not client["last_checked_ok"]:

2625

logger.warning(

2626

"disabling client {} - Client never "

2627

"performed a successful checker"

2628

.format(client_name))

2629

client["enabled"] = False

2630

elif client["last_checker_status"] != 0:

2631

logger.warning(

2632

"disabling client {} - Client last"

2633

" checker failed with error code {}"

2634

.format(client_name,

2635

client["last_checker_status"]))

2636

client["enabled"] = False

2637

else:

2638

client["expires"] = (datetime.datetime

2639

.utcnow()

2640

+ client["timeout"])

2641

logger.debug("Last checker succeeded,"

2642

" keeping {} enabled"

2643

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

2644

2048

try:

2645

client["secret"] = (

2646

pgp.decrypt(client["encrypted_secret"],

2647

client_settings[client_name]

2648

["secret"]))

2649

except PGPError:

2650

# If decryption fails, we use secret from new settings

2651

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

2652

.format(client_name))

2653

client["secret"] = (

2654

client_settings[client_name]["secret"])

2655

2656

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

2657

for client_name in (set(old_client_settings)

2658

- set(client_settings)):

2659

del clients_data[client_name]

2660

for client_name in (set(client_settings)

2661

- set(old_client_settings)):

2662

clients_data[client_name] = client_settings[client_name]

2663

2664

# Create all client objects

2665

for client_name, client in clients_data.items():

2666

tcp_server.clients[client_name] = client_class(

2667

name = client_name, settings = client,

2668

server_settings = server_settings)

2669

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

2670

2058

if not tcp_server.clients:

2671

2059

logger.warning("No clients defined")

2672

2673

if not foreground:

2674

if pidfile is not None:

2675

try:

2676

with pidfile:

2677

pid = os.getpid()

2678

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

2679

except IOError:

2680

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

2681

pidfilename, pid)

2682

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

2683

2073

del pidfilename

2074

2075

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

2684

2076

2685

2077

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

2686

2078

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

2687

2079

2688

2080

if use_dbus:

2689

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

2690

"se.bsnet.fukt.Mandos"})

2691

class MandosDBusService(DBusObjectWithProperties):

2081

class MandosDBusService(dbus.service.Object):

2692

2082

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

2693

2083

def __init__(self):

2694

2084

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

2695

2085

_interface = "se.recompile.Mandos"

2696

2086

2697

@dbus_interface_annotations(_interface)

2698

def _foo(self):

2699

return { "org.freedesktop.DBus.Property"

2700

".EmitsChangedSignal":

2701

"false"}

2702

2703

2087

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

2704

2088

def ClientAdded(self, objpath):

2705

2089

"D-Bus signal"

2719

2103

def GetAllClients(self):

2720

2104

"D-Bus method"

2721

2105

return dbus.Array(c.dbus_object_path

2722

for c in

2723

tcp_server.clients.itervalues())

2106

for c in tcp_server.clients)

2724

2107

2725

2108

@dbus.service.method(_interface,

2726

2109

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

2727

2110

def GetAllClientsWithProperties(self):

2728

2111

"D-Bus method"

2729

2112

return dbus.Dictionary(

2730

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

2731

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

2113

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

2114

for c in tcp_server.clients),

2732

2115

signature="oa{sv}")

2733

2116

2734

2117

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

2735

2118

def RemoveClient(self, object_path):

2736

2119

"D-Bus method"

2737

for c in tcp_server.clients.itervalues():

2120

for c in tcp_server.clients:

2738

2121

if c.dbus_object_path == object_path:

2739

del tcp_server.clients[c.name]

2122

tcp_server.clients.remove(c)

2740

2123

c.remove_from_connection()

2741

2124

# Don't signal anything except ClientRemoved

2742

2125

c.disable(quiet=True)

2747

2130

2748

2131

del _interface

2749

2132

2750

mandos_dbus_service = MandosDBusService()

2133

class MandosDBusServiceTransitional(MandosDBusService):

2134

__metaclass__ = AlternateDBusNamesMetaclass

2135

mandos_dbus_service = MandosDBusServiceTransitional()

2751

2136

2752

2137

def cleanup():

2753

2138

"Cleanup function; run on exit"

2754

if zeroconf:

2755

service.cleanup()

2139

service.cleanup()

2756

2140

2757

2141

multiprocessing.active_children()

2758

wnull.close()

2759

if not (tcp_server.clients or client_settings):

2760

return

2761

2762

# Store client before exiting. Secrets are encrypted with key

2763

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

2764

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

2765

clients = {}

2766

with PGPEngine() as pgp:

2767

for client in tcp_server.clients.itervalues():

2768

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

2769

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

2770

key)

2771

client_dict = {}

2772

2773

# A list of attributes that can not be pickled

2774

# + secret.

2775

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

2776

"checker", "server_settings" }

2777

for name, typ in (inspect.getmembers

2778

(dbus.service.Object)):

2779

exclude.add(name)

2780

2781

client_dict["encrypted_secret"] = (client

2782

.encrypted_secret)

2783

for attr in client.client_structure:

2784

if attr not in exclude:

2785

client_dict[attr] = getattr(client, attr)

2786

2787

clients[client.name] = client_dict

2788

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

2789

2790

try:

2791

with (tempfile.NamedTemporaryFile

2792

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

2793

dir=os.path.dirname(stored_state_path),

2794

delete=False)) as stored_state:

2795

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

2796

tempname=stored_state.name

2797

os.rename(tempname, stored_state_path)

2798

except (IOError, OSError) as e:

2799

if not debug:

2800

try:

2801

os.remove(tempname)

2802

except NameError:

2803

pass

2804

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

2805

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

2806

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

2807

else:

2808

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

2809

exc_info=e)

2810

raise

2811

2812

# Delete all clients, and settings from config

2813

2142

while tcp_server.clients:

2814

name, client = tcp_server.clients.popitem()

2143

client = tcp_server.clients.pop()

2815

2144

if use_dbus:

2816

2145

client.remove_from_connection()

2146

client.disable_hook = None

2817

2147

# Don't signal anything except ClientRemoved

2818

2148

client.disable(quiet=True)

2819

2149

if use_dbus:

2821

2151

mandos_dbus_service.ClientRemoved(client

2822

2152

.dbus_object_path,

2823

2153

client.name)

2824

client_settings.clear()

2825

2154

2826

2155

atexit.register(cleanup)

2827

2156

2828

for client in tcp_server.clients.itervalues():

2157

for client in tcp_server.clients:

2829

2158

if use_dbus:

2830

2159

# Emit D-Bus signal

2831

2160

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2832

# Need to initiate checking of clients

2833

if client.enabled:

2834

client.init_checker()

2161

client.enable()

2835

2162

2836

2163

tcp_server.enable()

2837

2164

tcp_server.server_activate()

2838

2165

2839

2166

# Find out what port we got

2840

if zeroconf:

2841

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

2167

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

2842

2168

if use_ipv6:

2843

2169

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

2844

" flowinfo %d, scope_id %d",

2845

*tcp_server.socket.getsockname())

2170

" flowinfo %d, scope_id %d"

2171

% tcp_server.socket.getsockname())

2846

2172

else: # IPv4

2847

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

2848

*tcp_server.socket.getsockname())

2173

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

2174

% tcp_server.socket.getsockname())

2849

2175

2850

2176

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

2851

2177

2852

2178

try:

2853

if zeroconf:

2854

# From the Avahi example code

2855

try:

2856

service.activate()

2857

except dbus.exceptions.DBusException as error:

2858

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

2859

cleanup()

2860

sys.exit(1)

2861

# End of Avahi example code

2179

# From the Avahi example code

2180

try:

2181

service.activate()

2182

except dbus.exceptions.DBusException as error:

2183

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

2184

cleanup()

2185

sys.exit(1)

2186

# End of Avahi example code

2862

2187

2863

2188

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

2864

2189

lambda *args, **kwargs:

2868

2193

logger.debug("Starting main loop")

2869

2194

main_loop.run()

2870

2195

except AvahiError as error:

2871

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

2196

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

2872

2197

cleanup()

2873

2198

sys.exit(1)

2874

2199

except KeyboardInterrupt:

2879

2204

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

2880

2205

cleanup()

2881

2206

2207

2882

2208

if __name__ == '__main__':

2883

2209

main()