/mandos/trunk : revision 482

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

28

# along with this program. If not, see

29

# <http://www.gnu.org/licenses/>.

30

#

31

# Contact the authors at <mandos@recompile.se>.

31

# Contact the authors at <mandos@fukt.bsnet.se>.

32

#

33

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

64

62

import functools

65

63

import cPickle as pickle

66

64

import multiprocessing

67

import types

68

import binascii

69

import tempfile

70

import itertools

71

import collections

72

65

73

66

import dbus

74

67

import dbus.service

88

81

except ImportError:

89

82

SO_BINDTODEVICE = None

90

83

91

version = "1.6.8"

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

95

syslogger = None

96

97

try:

98

if_nametoindex = (ctypes.cdll.LoadLibrary

99

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

100

.if_nametoindex)

101

except (OSError, AttributeError):

102

def if_nametoindex(interface):

103

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

104

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

105

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

106

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

107

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

108

interface))

109

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

110

ifreq[16:20])[0]

111

return interface_index

112

113

114

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

115

"""init logger and add loglevel"""

116

117

global syslogger

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

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

122

syslogger.setFormatter(logging.Formatter

123

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

124

' %(message)s'))

125

logger.addHandler(syslogger)

126

127

if debug:

128

console = logging.StreamHandler()

129

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

130

' [%(process)d]:'

131

' %(levelname)s:'

132

' %(message)s'))

133

logger.addHandler(console)

134

logger.setLevel(level)

135

136

137

class PGPError(Exception):

138

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

139

pass

140

141

142

class PGPEngine(object):

143

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

144

def __init__(self):

145

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

146

self.gnupgargs = ['--batch',

147

'--home', self.tempdir,

148

'--force-mdc',

149

'--quiet',

150

'--no-use-agent']

151

152

def __enter__(self):

153

return self

154

155

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

156

self._cleanup()

157

return False

158

159

def __del__(self):

160

self._cleanup()

161

162

def _cleanup(self):

163

if self.tempdir is not None:

164

# Delete contents of tempdir

165

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

166

topdown = False):

167

for filename in files:

168

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

169

for dirname in dirs:

170

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

171

# Remove tempdir

172

os.rmdir(self.tempdir)

173

self.tempdir = None

174

175

def password_encode(self, password):

176

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

177

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

178

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

179

if len(encoded) > 2048:

180

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

181

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

182

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

183

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

184

return encoded

185

186

def encrypt(self, data, password):

187

passphrase = self.password_encode(password)

188

with tempfile.NamedTemporaryFile(dir=self.tempdir

189

) as passfile:

190

passfile.write(passphrase)

191

passfile.flush()

192

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

193

'--passphrase-file',

194

passfile.name]

195

+ self.gnupgargs,

196

stdin = subprocess.PIPE,

197

stdout = subprocess.PIPE,

198

stderr = subprocess.PIPE)

199

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

200

if proc.returncode != 0:

201

raise PGPError(err)

202

return ciphertext

203

204

def decrypt(self, data, password):

205

passphrase = self.password_encode(password)

206

with tempfile.NamedTemporaryFile(dir = self.tempdir

207

) as passfile:

208

passfile.write(passphrase)

209

passfile.flush()

210

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

211

'--passphrase-file',

212

passfile.name]

213

+ self.gnupgargs,

214

stdin = subprocess.PIPE,

215

stdout = subprocess.PIPE,

216

stderr = subprocess.PIPE)

217

decrypted_plaintext, err = proc.communicate(input

218

= data)

219

if proc.returncode != 0:

220

raise PGPError(err)

221

return decrypted_plaintext

222

84

85

version = "1.3.0"

86

87

#logger = logging.getLogger('mandos')

88

logger = logging.Logger('mandos')

89

syslogger = (logging.handlers.SysLogHandler

90

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

91

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

92

syslogger.setFormatter(logging.Formatter

93

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

94

' %(message)s'))

95

logger.addHandler(syslogger)

96

97

console = logging.StreamHandler()

98

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

99

' %(levelname)s:'

100

' %(message)s'))

101

logger.addHandler(console)

223

102

224

103

class AvahiError(Exception):

225

104

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

243

122

Used to optionally bind to the specified interface.

244

123

name: string; Example: 'Mandos'

245

124

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

246

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

125

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

247

126

port: integer; what port to announce

248

127

TXT: list of strings; TXT record for the service

249

128

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

255

134

server: D-Bus Server

256

135

bus: dbus.SystemBus()

257

136

"""

258

259

137

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

260

138

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

261

139

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

274

152

self.server = None

275

153

self.bus = bus

276

154

self.entry_group_state_changed_match = None

277

278

155

def rename(self):

279

156

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

280

157

if self.rename_count >= self.max_renames:

282

159

" after %i retries, exiting.",

283

160

self.rename_count)

284

161

raise AvahiServiceError("Too many renames")

285

self.name = unicode(self.server

286

.GetAlternativeServiceName(self.name))

162

self.name = unicode(self.server.GetAlternativeServiceName(self.name))

287

163

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

288

164

self.name)

165

syslogger.setFormatter(logging.Formatter

166

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

167

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

168

% self.name))

289

169

self.remove()

290

170

try:

291

171

self.add()

292

172

except dbus.exceptions.DBusException as error:

293

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

173

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

294

174

self.cleanup()

295

175

os._exit(1)

296

176

self.rename_count += 1

297

298

177

def remove(self):

299

178

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

179

if self.group is not None:

180

try:

181

self.group.Free()

182

except (dbus.exceptions.UnknownMethodException,

183

dbus.exceptions.DBusException) as e:

184

pass

185

self.group = None

300

186

if self.entry_group_state_changed_match is not None:

301

187

self.entry_group_state_changed_match.remove()

302

188

self.entry_group_state_changed_match = None

303

if self.group is not None:

304

self.group.Reset()

305

306

189

def add(self):

307

190

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

308

191

self.remove()

309

if self.group is None:

310

self.group = dbus.Interface(

311

self.bus.get_object(avahi.DBUS_NAME,

312

self.server.EntryGroupNew()),

313

avahi.DBUS_INTERFACE_ENTRY_GROUP)

192

self.group = dbus.Interface(

193

self.bus.get_object(avahi.DBUS_NAME,

194

self.server.EntryGroupNew(),

195

follow_name_owner_changes=True),

196

avahi.DBUS_INTERFACE_ENTRY_GROUP)

314

197

self.entry_group_state_changed_match = (

315

198

self.group.connect_to_signal(

316

'StateChanged', self.entry_group_state_changed))

199

'StateChanged', self .entry_group_state_changed))

317

200

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

318

201

self.name, self.type)

319

202

self.group.AddService(

325

208

dbus.UInt16(self.port),

326

209

avahi.string_array_to_txt_array(self.TXT))

327

210

self.group.Commit()

328

329

211

def entry_group_state_changed(self, state, error):

330

212

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

331

213

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

338

220

elif state == avahi.ENTRY_GROUP_FAILURE:

339

221

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

340

222

unicode(error))

341

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

342

.format(error))

343

223

raise AvahiGroupError("State changed: %s"

224

% unicode(error))

344

225

def cleanup(self):

345

226

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

346

if self.group is not None:

347

try:

348

self.group.Free()

349

except (dbus.exceptions.UnknownMethodException,

350

dbus.exceptions.DBusException):

351

pass

352

self.group = None

353

227

self.remove()

354

355

228

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

356

229

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

357

230

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

363

236

avahi.SERVER_FAILURE:

364

237

"Zeroconf server failure" }

365

238

if state in bad_states:

366

if bad_states[state] is not None:

367

if error is None:

368

logger.error(bad_states[state])

369

else:

370

logger.error(bad_states[state] + ": %r", error)

371

self.cleanup()

239

if bad_states[state]:

240

logger.error(bad_states[state])

241

self.remove()

372

242

elif state == avahi.SERVER_RUNNING:

373

243

self.add()

374

244

else:

375

if error is None:

376

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

377

else:

378

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

379

245

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

380

246

def activate(self):

381

247

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

382

248

if self.server is None:

390

256

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

391

257

392

258

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

404

259

class Client(object):

405

260

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

406

261

407

262

Attributes:

408

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

263

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

409

264

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

410

265

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

411

266

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

418

273

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

419

274

checker_initiator_tag: a gobject event source tag, or None

420

275

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

276

current_checker_command: string; current running checker_command

277

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

424

278

disable_initiator_tag: a gobject event source tag, or None

425

279

enabled: bool()

426

280

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

429

283

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

430

284

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

431

285

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

286

last_enabled: datetime.datetime(); (UTC)

436

287

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

437

288

D-Bus identifiers

438

289

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

439

290

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

440

291

until this client is disabled

441

extended_timeout: extra long timeout when secret has been sent

442

292

runtime_expansions: Allowed attributes for runtime expansion.

443

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

444

disabled, or None

445

server_settings: The server_settings dict from main()

446

293

"""

447

294

448

295

runtime_expansions = ("approval_delay", "approval_duration",

449

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

450

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

451

"last_approval_request", "last_checked_ok",

296

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

297

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

452

298

"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

299

464

300

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

301

def _timedelta_to_milliseconds(td):

302

"Convert a datetime.timedelta() to milliseconds"

303

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

304

+ (td.seconds * 1000)

305

+ (td.microseconds // 1000))

306

307

def timeout_milliseconds(self):

308

"Return the 'timeout' attribute in milliseconds"

309

return self._timedelta_to_milliseconds(self.timeout)

310

311

def interval_milliseconds(self):

312

"Return the 'interval' attribute in milliseconds"

313

return self._timedelta_to_milliseconds(self.interval)

314

315

def approval_delay_milliseconds(self):

316

return self._timedelta_to_milliseconds(self.approval_delay)

317

318

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

319

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

320

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

321

attribute."""

512

322

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

323

if config is None:

324

config = {}

530

325

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

531

326

# Uppercase and remove spaces from fingerprint for later

532

327

# comparison purposes with return value from the fingerprint()

533

328

# function

329

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

330

.replace(" ", ""))

534

331

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

535

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

536

datetime.datetime.utcnow())

537

538

# attributes specific for this server instance

332

if "secret" in config:

333

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

334

elif "secfile" in config:

335

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

336

(config["secfile"])),

337

"rb") as secfile:

338

self.secret = secfile.read()

339

else:

340

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

341

% self.name)

342

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

343

self.created = datetime.datetime.utcnow()

344

self.enabled = False

345

self.last_approval_request = None

346

self.last_enabled = None

347

self.last_checked_ok = None

348

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

349

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

350

self.disable_hook = disable_hook

539

351

self.checker = None

540

352

self.checker_initiator_tag = None

541

353

self.disable_initiator_tag = None

542

354

self.checker_callback_tag = None

355

self.checker_command = config["checker"]

543

356

self.current_checker_command = None

544

self.approved = None

357

self.last_connect = None

358

self._approved = None

359

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

360

True)

545

361

self.approvals_pending = 0

546

self.changedstate = (multiprocessing_manager

547

.Condition(multiprocessing_manager

548

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

362

self.approval_delay = string_to_delta(

363

config["approval_delay"])

364

self.approval_duration = string_to_delta(

365

config["approval_duration"])

366

self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())

560

367

561

# Send notice to process children that client state has changed

562

368

def send_changedstate(self):

563

with self.changedstate:

564

self.changedstate.notify_all()

565

369

self.changedstate.acquire()

370

self.changedstate.notify_all()

371

self.changedstate.release()

372

566

373

def enable(self):

567

374

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

568

375

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

569

376

# Already enabled

570

377

return

571

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

572

self.enabled = True

378

self.send_changedstate()

573

379

self.last_enabled = datetime.datetime.utcnow()

574

self.init_checker()

575

self.send_changedstate()

380

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

381

# and every interval from then on.

382

self.checker_initiator_tag = (gobject.timeout_add

383

(self.interval_milliseconds(),

384

self.start_checker))

385

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

386

self.disable_initiator_tag = (gobject.timeout_add

387

(self.timeout_milliseconds(),

388

self.disable))

389

self.enabled = True

390

# Also start a new checker *right now*.

391

self.start_checker()

576

392

577

393

def disable(self, quiet=True):

578

394

"""Disable this client."""

579

395

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

580

396

return False

581

397

if not quiet:

398

self.send_changedstate()

399

if not quiet:

582

400

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

583

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

401

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

584

402

gobject.source_remove(self.disable_initiator_tag)

585

403

self.disable_initiator_tag = None

586

self.expires = None

587

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

404

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

588

405

gobject.source_remove(self.checker_initiator_tag)

589

406

self.checker_initiator_tag = None

590

407

self.stop_checker()

408

if self.disable_hook:

409

self.disable_hook(self)

591

410

self.enabled = False

592

if not quiet:

593

self.send_changedstate()

594

411

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

595

412

return False

596

413

597

414

def __del__(self):

415

self.disable_hook = None

598

416

self.disable()

599

417

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

418

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

620

419

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

621

420

self.checker_callback_tag = None

622

421

self.checker = None

623

422

if os.WIFEXITED(condition):

624

self.last_checker_status = os.WEXITSTATUS(condition)

625

if self.last_checker_status == 0:

423

exitstatus = os.WEXITSTATUS(condition)

424

if exitstatus == 0:

626

425

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

627

426

vars(self))

628

427

self.checked_ok()

630

429

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

631

430

vars(self))

632

431

else:

633

self.last_checker_status = -1

634

432

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

635

433

vars(self))

636

434

637

435

def checked_ok(self):

638

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

436

"""Bump up the timeout for this client.

437

438

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

439

alive and well.

440

"""

639

441

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

645

if timeout is None:

646

timeout = self.timeout

647

if self.disable_initiator_tag is not None:

648

gobject.source_remove(self.disable_initiator_tag)

649

self.disable_initiator_tag = None

650

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

651

self.disable_initiator_tag = (gobject.timeout_add

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

654

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

442

gobject.source_remove(self.disable_initiator_tag)

443

self.disable_initiator_tag = (gobject.timeout_add

444

(self.timeout_milliseconds(),

445

self.disable))

655

446

656

447

def need_approval(self):

657

448

self.last_approval_request = datetime.datetime.utcnow()

662

453

If a checker already exists, leave it running and do

663

454

nothing."""

664

455

# 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

456

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

457

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

458

# client would inevitably timeout, since no checker would get

459

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

669

460

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

670

461

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

671

462

# should be.

673

464

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

674

465

try:

675

466

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

467

except (AttributeError, OSError) as error:

468

if (isinstance(error, OSError)

469

and error.errno != errno.ECHILD):

470

raise error

681

471

else:

682

472

if pid:

683

473

logger.warning("Checker was a zombie")

686

476

self.current_checker_command)

687

477

# Start a new checker if needed

688

478

if self.checker is None:

689

# Escape attributes for the shell

690

escaped_attrs = { attr:

691

re.escape(unicode(getattr(self,

692

attr)))

693

for attr in self.runtime_expansions }

694

479

try:

695

command = self.checker_command % escaped_attrs

696

except TypeError as error:

697

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

698

self.checker_command, exc_info=error)

699

return True # Try again later

480

# In case checker_command has exactly one % operator

481

command = self.checker_command % self.host

482

except TypeError:

483

# Escape attributes for the shell

484

escaped_attrs = dict(

485

(attr,

486

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

487

errors=

488

'replace')))

489

for attr in

490

self.runtime_expansions)

491

492

try:

493

command = self.checker_command % escaped_attrs

494

except TypeError as error:

495

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

496

' %s', self.checker_command, error)

497

return True # Try again later

700

498

self.current_checker_command = command

701

499

try:

702

500

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

705

503

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

706

504

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

707

505

# always replaced by /dev/null.)

708

# The exception is when not debugging but nevertheless

709

# running in the foreground; use the previously

710

# created wnull.

711

popen_args = {}

712

if (not self.server_settings["debug"]

713

and self.server_settings["foreground"]):

714

popen_args.update({"stdout": wnull,

715

"stderr": wnull })

716

506

self.checker = subprocess.Popen(command,

717

507

close_fds=True,

718

shell=True, cwd="/",

719

**popen_args)

720

except OSError as error:

721

logger.error("Failed to start subprocess",

722

exc_info=error)

723

return True

724

self.checker_callback_tag = (gobject.child_watch_add

725

(self.checker.pid,

726

self.checker_callback,

727

data=command))

728

# The checker may have completed before the gobject

729

# watch was added. Check for this.

730

try:

508

shell=True, cwd="/")

509

self.checker_callback_tag = (gobject.child_watch_add

510

(self.checker.pid,

511

self.checker_callback,

512

data=command))

513

# The checker may have completed before the gobject

514

# watch was added. Check for this.

731

515

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

516

if pid:

517

gobject.source_remove(self.checker_callback_tag)

518

self.checker_callback(pid, status, command)

732

519

except OSError as error:

733

if error.errno == errno.ECHILD:

734

# This should never happen

735

logger.error("Child process vanished",

736

exc_info=error)

737

return True

738

raise

739

if pid:

740

gobject.source_remove(self.checker_callback_tag)

741

self.checker_callback(pid, status, command)

520

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

521

error)

742

522

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

743

523

return True

744

524

751

531

return

752

532

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

753

533

try:

754

self.checker.terminate()

534

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

755

535

#time.sleep(0.5)

756

536

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

757

# self.checker.kill()

537

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

758

538

except OSError as error:

759

539

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

760

540

raise

761

541

self.checker = None

762

542

763

764

543

def dbus_service_property(dbus_interface, signature="v",

765

544

access="readwrite", byte_arrays=False):

766

545

"""Decorators for marking methods of a DBusObjectWithProperties to

777

556

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

778

557

if byte_arrays and signature != "ay":

779

558

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

780

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

559

" signature %r" % signature)

781

560

def decorator(func):

782

561

func._dbus_is_property = True

783

562

func._dbus_interface = dbus_interface

791

570

return decorator

792

571

793

572

794

def dbus_interface_annotations(dbus_interface):

795

"""Decorator for marking functions returning interface annotations

796

797

Usage:

798

799

@dbus_interface_annotations("org.example.Interface")

800

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

801

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

802

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

803

"false"}

804

"""

805

def decorator(func):

806

func._dbus_is_interface = True

807

func._dbus_interface = dbus_interface

808

func._dbus_name = dbus_interface

809

return func

810

return decorator

811

812

813

def dbus_annotations(annotations):

814

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

815

Usage:

816

817

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

818

access="r")

819

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

820

"org.freedesktop.DBus.Property."

821

"EmitsChangedSignal": "false"})

822

def Property_dbus_property(self):

823

return dbus.Boolean(False)

824

"""

825

def decorator(func):

826

func._dbus_annotations = annotations

827

return func

828

return decorator

829

830

831

573

class DBusPropertyException(dbus.exceptions.DBusException):

832

574

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

833

575

"""

849

591

850

592

class DBusObjectWithProperties(dbus.service.Object):

851

593

"""A D-Bus object with properties.

852

594

853

595

Classes inheriting from this can use the dbus_service_property

854

596

decorator to expose methods as D-Bus properties. It exposes the

855

597

standard Get(), Set(), and GetAll() methods on the D-Bus.

856

598

"""

857

599

858

600

@staticmethod

859

def _is_dbus_thing(thing):

860

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

861

862

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

863

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

864

"""

865

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

866

False)

601

def _is_dbus_property(obj):

602

return getattr(obj, "_dbus_is_property", False)

867

603

868

def _get_all_dbus_things(self, thing):

604

def _get_all_dbus_properties(self):

869

605

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

870

606

"""

871

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

872

name),

873

athing.__get__(self))

874

for cls in self.__class__.__mro__

875

for name, athing in

876

inspect.getmembers(cls,

877

self._is_dbus_thing(thing)))

607

return ((prop._dbus_name, prop)

608

for name, prop in

609

inspect.getmembers(self, self._is_dbus_property))

878

610

879

611

def _get_dbus_property(self, interface_name, property_name):

880

612

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

881

613

property with the specified name and interface.

882

614

"""

883

for cls in self.__class__.__mro__:

884

for name, value in (inspect.getmembers

885

(cls,

886

self._is_dbus_thing("property"))):

887

if (value._dbus_name == property_name

888

and value._dbus_interface == interface_name):

889

return value.__get__(self)

890

615

for name in (property_name,

616

property_name + "_dbus_property"):

617

prop = getattr(self, name, None)

618

if (prop is None

619

or not self._is_dbus_property(prop)

620

or prop._dbus_name != property_name

621

or (interface_name and prop._dbus_interface

622

and interface_name != prop._dbus_interface)):

623

continue

624

return prop

891

625

# No such property

892

626

raise DBusPropertyNotFound(self.dbus_object_path + ":"

893

627

+ interface_name + "."

917

651

# The byte_arrays option is not supported yet on

918

652

# signatures other than "ay".

919

653

if prop._dbus_signature != "ay":

920

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

921

"'ay' signature {!r}"

922

.format(prop._dbus_signature))

923

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

924

for byte in value))

654

raise ValueError

655

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

656

for byte in value))

925

657

prop(value)

926

658

927

659

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

929

661

def GetAll(self, interface_name):

930

662

"""Standard D-Bus property GetAll() method, see D-Bus

931

663

standard.

932

664

933

665

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

934

666

"""

935

properties = {}

936

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

667

all = {}

668

for name, prop in self._get_all_dbus_properties():

937

669

if (interface_name

938

670

and interface_name != prop._dbus_interface):

939

671

# Interface non-empty but did not match

943

675

continue

944

676

value = prop()

945

677

if not hasattr(value, "variant_level"):

946

properties[name] = value

678

all[name] = value

947

679

continue

948

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

949

value.variant_level+1)

950

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

680

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

681

value.variant_level+1)

682

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

951

683

952

684

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

953

685

out_signature="s",

954

686

path_keyword='object_path',

955

687

connection_keyword='connection')

956

688

def Introspect(self, object_path, connection):

957

"""Overloading of standard D-Bus method.

958

959

Inserts property tags and interface annotation tags.

689

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

960

690

"""

961

691

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

962

692

connection)

969

699

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

970

700

return e

971

701

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

972

# Add property tags

973

702

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

974

703

for name, prop

975

in self._get_all_dbus_things("property")

704

in self._get_all_dbus_properties()

976

705

if prop._dbus_interface

977

706

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

978

707

if_tag.appendChild(tag)

979

# Add annotation tags

980

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

981

for tag in if_tag.getElementsByTagName(typ):

982

annots = dict()

983

for name, prop in (self.

984

_get_all_dbus_things(typ)):

985

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

986

and prop._dbus_interface

987

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

988

annots.update(getattr

989

(prop,

990

"_dbus_annotations",

991

{}))

992

for name, value in annots.items():

993

ann_tag = document.createElement(

994

"annotation")

995

ann_tag.setAttribute("name", name)

996

ann_tag.setAttribute("value", value)

997

tag.appendChild(ann_tag)

998

# Add interface annotation tags

999

for annotation, value in dict(

1000

itertools.chain.from_iterable(

1001

annotations().items()

1002

for name, annotations in

1003

self._get_all_dbus_things("interface")

1004

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

1005

)).items():

1006

ann_tag = document.createElement("annotation")

1007

ann_tag.setAttribute("name", annotation)

1008

ann_tag.setAttribute("value", value)

1009

if_tag.appendChild(ann_tag)

1010

708

# Add the names to the return values for the

1011

709

# "org.freedesktop.DBus.Properties" methods

1012

710

if (if_tag.getAttribute("name")

1027

725

except (AttributeError, xml.dom.DOMException,

1028

726

xml.parsers.expat.ExpatError) as error:

1029

727

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

1030

exc_info=error)

728

error)

1031

729

return xmlstring

1032

730

1033

731

1034

def datetime_to_dbus(dt, variant_level=0):

1035

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

1036

if dt is None:

1037

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

1038

return dbus.String(dt.isoformat(),

1039

variant_level=variant_level)

1040

1041

1042

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1043

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

1044

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

1045

interface names according to the "alt_interface_names" mapping.

1046

Usage:

1047

1048

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

1049

"net.example.AlternateInterface"})

1050

class SampleDBusObject(dbus.service.Object):

1051

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

1052

def SampleDBusMethod():

1053

pass

1054

1055

The above "SampleDBusMethod" on "SampleDBusObject" will be

1056

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

1057

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

1058

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

1059

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

1060

1061

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

1062

(from DBusObjectWithProperties) and interfaces (from the

1063

dbus_interface_annotations decorator).

1064

"""

1065

def wrapper(cls):

1066

for orig_interface_name, alt_interface_name in (

1067

alt_interface_names.items()):

1068

attr = {}

1069

interface_names = set()

1070

# Go though all attributes of the class

1071

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

1072

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

1073

# with the wrong interface name

1074

if (not hasattr(attribute, "_dbus_interface")

1075

or not attribute._dbus_interface

1076

.startswith(orig_interface_name)):

1077

continue

1078

# Create an alternate D-Bus interface name based on

1079

# the current name

1080

alt_interface = (attribute._dbus_interface

1081

.replace(orig_interface_name,

1082

alt_interface_name))

1083

interface_names.add(alt_interface)

1084

# Is this a D-Bus signal?

1085

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

1086

# Extract the original non-method undecorated

1087

# function by black magic

1088

nonmethod_func = (dict(

1089

zip(attribute.func_code.co_freevars,

1090

attribute.__closure__))["func"]

1091

.cell_contents)

1092

# Create a new, but exactly alike, function

1093

# object, and decorate it to be a new D-Bus signal

1094

# with the alternate D-Bus interface name

1095

new_function = (dbus.service.signal

1096

(alt_interface,

1097

attribute._dbus_signature)

1098

(types.FunctionType(

1099

nonmethod_func.func_code,

1100

nonmethod_func.func_globals,

1101

nonmethod_func.func_name,

1102

nonmethod_func.func_defaults,

1103

nonmethod_func.func_closure)))

1104

# Copy annotations, if any

1105

try:

1106

new_function._dbus_annotations = (

1107

dict(attribute._dbus_annotations))

1108

except AttributeError:

1109

pass

1110

# Define a creator of a function to call both the

1111

# original and alternate functions, so both the

1112

# original and alternate signals gets sent when

1113

# the function is called

1114

def fixscope(func1, func2):

1115

"""This function is a scope container to pass

1116

func1 and func2 to the "call_both" function

1117

outside of its arguments"""

1118

def call_both(*args, **kwargs):

1119

"""This function will emit two D-Bus

1120

signals by calling func1 and func2"""

1121

func1(*args, **kwargs)

1122

func2(*args, **kwargs)

1123

return call_both

1124

# Create the "call_both" function and add it to

1125

# the class

1126

attr[attrname] = fixscope(attribute, new_function)

1127

# Is this a D-Bus method?

1128

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

1129

# Create a new, but exactly alike, function

1130

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

1131

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

1132

# to the class.

1133

attr[attrname] = (dbus.service.method

1134

(alt_interface,

1135

attribute._dbus_in_signature,

1136

attribute._dbus_out_signature)

1137

(types.FunctionType

1138

(attribute.func_code,

1139

attribute.func_globals,

1140

attribute.func_name,

1141

attribute.func_defaults,

1142

attribute.func_closure)))

1143

# Copy annotations, if any

1144

try:

1145

attr[attrname]._dbus_annotations = (

1146

dict(attribute._dbus_annotations))

1147

except AttributeError:

1148

pass

1149

# Is this a D-Bus property?

1150

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

1151

# Create a new, but exactly alike, function

1152

# object, and decorate it to be a new D-Bus

1153

# property with the alternate D-Bus interface

1154

# name. Add it to the class.

1155

attr[attrname] = (dbus_service_property

1156

(alt_interface,

1157

attribute._dbus_signature,

1158

attribute._dbus_access,

1159

attribute

1160

._dbus_get_args_options

1161

["byte_arrays"])

1162

(types.FunctionType

1163

(attribute.func_code,

1164

attribute.func_globals,

1165

attribute.func_name,

1166

attribute.func_defaults,

1167

attribute.func_closure)))

1168

# Copy annotations, if any

1169

try:

1170

attr[attrname]._dbus_annotations = (

1171

dict(attribute._dbus_annotations))

1172

except AttributeError:

1173

pass

1174

# Is this a D-Bus interface?

1175

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

1176

# Create a new, but exactly alike, function

1177

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

1178

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

1179

# to the class.

1180

attr[attrname] = (dbus_interface_annotations

1181

(alt_interface)

1182

(types.FunctionType

1183

(attribute.func_code,

1184

attribute.func_globals,

1185

attribute.func_name,

1186

attribute.func_defaults,

1187

attribute.func_closure)))

1188

if deprecate:

1189

# Deprecate all alternate interfaces

1190

iname="_AlternateDBusNames_interface_annotation{}"

1191

for interface_name in interface_names:

1192

@dbus_interface_annotations(interface_name)

1193

def func(self):

1194

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

1195

"true" }

1196

# Find an unused name

1197

for aname in (iname.format(i)

1198

for i in itertools.count()):

1199

if aname not in attr:

1200

attr[aname] = func

1201

break

1202

if interface_names:

1203

# Replace the class with a new subclass of it with

1204

# methods, signals, etc. as created above.

1205

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

1206

(cls,), attr)

1207

return cls

1208

return wrapper

1209

1210

1211

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

1212

"se.bsnet.fukt.Mandos"})

1213

732

class ClientDBus(Client, DBusObjectWithProperties):

1214

733

"""A Client class using D-Bus

1215

734

1224

743

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

1225

744

1226

745

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

746

self._approvals_pending = 0

1227

747

self.bus = bus

1228

748

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

1229

749

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

1235

755

("/clients/" + client_object_name))

1236

756

DBusObjectWithProperties.__init__(self, self.bus,

1237

757

self.dbus_object_path)

1238

1239

def notifychangeproperty(transform_func,

1240

dbus_name, type_func=lambda x: x,

1241

variant_level=1):

1242

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

1243

its changes to DBus.

1244

1245

transform_fun: Function that takes a value and a variant_level

1246

and transforms it to a D-Bus type.

1247

dbus_name: D-Bus name of the variable

1248

type_func: Function that transform the value before sending it

1249

to the D-Bus. Default: no transform

1250

variant_level: D-Bus variant level. Default: 1

1251

"""

1252

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

1253

def setter(self, value):

1254

if hasattr(self, "dbus_object_path"):

1255

if (not hasattr(self, attrname) or

1256

type_func(getattr(self, attrname, None))

1257

!= type_func(value)):

1258

dbus_value = transform_func(type_func(value),

1259

variant_level

1260

=variant_level)

1261

self.PropertyChanged(dbus.String(dbus_name),

1262

dbus_value)

1263

setattr(self, attrname, value)

1264

1265

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

1266

1267

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1268

approvals_pending = notifychangeproperty(dbus.Boolean,

1269

"ApprovalPending",

1270

type_func = bool)

1271

enabled = notifychangeproperty(dbus.Boolean, "Enabled")

1272

last_enabled = notifychangeproperty(datetime_to_dbus,

1273

"LastEnabled")

1274

checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",

1275

type_func = lambda checker:

1276

checker is not None)

1277

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1278

"LastCheckedOK")

1279

last_checker_status = notifychangeproperty(dbus.Int16,

1280

"LastCheckerStatus")

1281

last_approval_request = notifychangeproperty(

1282

datetime_to_dbus, "LastApprovalRequest")

1283

approved_by_default = notifychangeproperty(dbus.Boolean,

1284

"ApprovedByDefault")

1285

approval_delay = notifychangeproperty(dbus.UInt64,

1286

"ApprovalDelay",

1287

type_func =

1288

lambda td: td.total_seconds()

1289

* 1000)

1290

approval_duration = notifychangeproperty(

1291

dbus.UInt64, "ApprovalDuration",

1292

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

1293

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

1294

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

1295

type_func = lambda td:

1296

td.total_seconds() * 1000)

1297

extended_timeout = notifychangeproperty(

1298

dbus.UInt64, "ExtendedTimeout",

1299

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

1300

interval = notifychangeproperty(dbus.UInt64,

1301

"Interval",

1302

type_func =

1303

lambda td: td.total_seconds()

1304

* 1000)

1305

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

1306

1307

del notifychangeproperty

758

759

def _get_approvals_pending(self):

760

return self._approvals_pending

761

def _set_approvals_pending(self, value):

762

old_value = self._approvals_pending

763

self._approvals_pending = value

764

bval = bool(value)

765

if (hasattr(self, "dbus_object_path")

766

and bval is not bool(old_value)):

767

dbus_bool = dbus.Boolean(bval, variant_level=1)

768

self.PropertyChanged(dbus.String("ApprovalPending"),

769

dbus_bool)

770

771

approvals_pending = property(_get_approvals_pending,

772

_set_approvals_pending)

773

del _get_approvals_pending, _set_approvals_pending

774

775

@staticmethod

776

def _datetime_to_dbus(dt, variant_level=0):

777

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

778

return dbus.String(dt.isoformat(),

779

variant_level=variant_level)

780

781

def enable(self):

782

oldstate = getattr(self, "enabled", False)

783

r = Client.enable(self)

784

if oldstate != self.enabled:

785

# Emit D-Bus signals

786

self.PropertyChanged(dbus.String("Enabled"),

787

dbus.Boolean(True, variant_level=1))

788

self.PropertyChanged(

789

dbus.String("LastEnabled"),

790

self._datetime_to_dbus(self.last_enabled,

791

variant_level=1))

792

return r

793

794

def disable(self, quiet = False):

795

oldstate = getattr(self, "enabled", False)

796

r = Client.disable(self, quiet=quiet)

797

if not quiet and oldstate != self.enabled:

798

# Emit D-Bus signal

799

self.PropertyChanged(dbus.String("Enabled"),

800

dbus.Boolean(False, variant_level=1))

801

return r

1308

802

1309

803

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

1310

804

try:

1319

813

*args, **kwargs):

1320

814

self.checker_callback_tag = None

1321

815

self.checker = None

816

# Emit D-Bus signal

817

self.PropertyChanged(dbus.String("CheckerRunning"),

818

dbus.Boolean(False, variant_level=1))

1322

819

if os.WIFEXITED(condition):

1323

820

exitstatus = os.WEXITSTATUS(condition)

1324

821

# Emit D-Bus signal

1334

831

return Client.checker_callback(self, pid, condition, command,

1335

832

*args, **kwargs)

1336

833

834

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

835

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

836

# Emit D-Bus signal

837

self.PropertyChanged(

838

dbus.String("LastCheckedOK"),

839

(self._datetime_to_dbus(self.last_checked_ok,

840

variant_level=1)))

841

842

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

843

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

844

# Emit D-Bus signal

845

self.PropertyChanged(

846

dbus.String("LastApprovalRequest"),

847

(self._datetime_to_dbus(self.last_approval_request,

848

variant_level=1)))

849

return r

850

1337

851

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

1338

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

852

old_checker = self.checker

853

if self.checker is not None:

854

old_checker_pid = self.checker.pid

855

else:

856

old_checker_pid = None

1339

857

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

1340

858

# Only if new checker process was started

1341

859

if (self.checker is not None

1342

860

and old_checker_pid != self.checker.pid):

1343

861

# Emit D-Bus signal

1344

862

self.CheckerStarted(self.current_checker_command)

863

self.PropertyChanged(

864

dbus.String("CheckerRunning"),

865

dbus.Boolean(True, variant_level=1))

1345

866

return r

1346

867

868

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

869

old_checker = getattr(self, "checker", None)

870

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

871

if (old_checker is not None

872

and getattr(self, "checker", None) is None):

873

self.PropertyChanged(dbus.String("CheckerRunning"),

874

dbus.Boolean(False, variant_level=1))

875

return r

876

1347

877

def _reset_approved(self):

1348

self.approved = None

878

self._approved = None

1349

879

return False

1350

880

1351

881

def approve(self, value=True):

1352

self.approved = value

1353

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

1354

* 1000), self._reset_approved)

1355

882

self.send_changedstate()

883

self._approved = value

884

gobject.timeout_add(self._timedelta_to_milliseconds

885

(self.approval_duration),

886

self._reset_approved)

887

1356

888

1357

889

## D-Bus methods, signals & properties

1358

_interface = "se.recompile.Mandos.Client"

1359

1360

## Interfaces

1361

1362

@dbus_interface_annotations(_interface)

1363

def _foo(self):

1364

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

1365

"false"}

890

_interface = "se.bsnet.fukt.Mandos.Client"

1366

891

1367

892

## Signals

1368

893

1454

979

if value is None: # get

1455

980

return dbus.Boolean(self.approved_by_default)

1456

981

self.approved_by_default = bool(value)

982

# Emit D-Bus signal

983

self.PropertyChanged(dbus.String("ApprovedByDefault"),

984

dbus.Boolean(value, variant_level=1))

1457

985

1458

986

# ApprovalDelay - property

1459

987

@dbus_service_property(_interface, signature="t",

1460

988

access="readwrite")

1461

989

def ApprovalDelay_dbus_property(self, value=None):

1462

990

if value is None: # get

1463

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

1464

* 1000)

991

return dbus.UInt64(self.approval_delay_milliseconds())

1465

992

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

993

# Emit D-Bus signal

994

self.PropertyChanged(dbus.String("ApprovalDelay"),

995

dbus.UInt64(value, variant_level=1))

1466

996

1467

997

# ApprovalDuration - property

1468

998

@dbus_service_property(_interface, signature="t",

1469

999

access="readwrite")

1470

1000

def ApprovalDuration_dbus_property(self, value=None):

1471

1001

if value is None: # get

1472

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

1473

* 1000)

1002

return dbus.UInt64(self._timedelta_to_milliseconds(

1003

self.approval_duration))

1474

1004

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

1005

# Emit D-Bus signal

1006

self.PropertyChanged(dbus.String("ApprovalDuration"),

1007

dbus.UInt64(value, variant_level=1))

1475

1008

1476

1009

# Name - property

1477

1010

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

1489

1022

def Host_dbus_property(self, value=None):

1490

1023

if value is None: # get

1491

1024

return dbus.String(self.host)

1492

self.host = unicode(value)

1025

self.host = value

1026

# Emit D-Bus signal

1027

self.PropertyChanged(dbus.String("Host"),

1028

dbus.String(value, variant_level=1))

1493

1029

1494

1030

# Created - property

1495

1031

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

1496

1032

def Created_dbus_property(self):

1497

return datetime_to_dbus(self.created)

1033

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

1498

1034

1499

1035

# LastEnabled - property

1500

1036

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

1501

1037

def LastEnabled_dbus_property(self):

1502

return datetime_to_dbus(self.last_enabled)

1038

if self.last_enabled is None:

1039

return dbus.String("")

1040

return dbus.String(self._datetime_to_dbus(self.last_enabled))

1503

1041

1504

1042

# Enabled - property

1505

1043

@dbus_service_property(_interface, signature="b",

1519

1057

if value is not None:

1520

1058

self.checked_ok()

1521

1059

return

1522

return datetime_to_dbus(self.last_checked_ok)

1523

1524

# LastCheckerStatus - property

1525

@dbus_service_property(_interface, signature="n",

1526

access="read")

1527

def LastCheckerStatus_dbus_property(self):

1528

return dbus.Int16(self.last_checker_status)

1529

1530

# Expires - property

1531

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

1532

def Expires_dbus_property(self):

1533

return datetime_to_dbus(self.expires)

1060

if self.last_checked_ok is None:

1061

return dbus.String("")

1062

return dbus.String(self._datetime_to_dbus(self

1063

.last_checked_ok))

1534

1064

1535

1065

# LastApprovalRequest - property

1536

1066

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

1537

1067

def LastApprovalRequest_dbus_property(self):

1538

return datetime_to_dbus(self.last_approval_request)

1068

if self.last_approval_request is None:

1069

return dbus.String("")

1070

return dbus.String(self.

1071

_datetime_to_dbus(self

1072

.last_approval_request))

1539

1073

1540

1074

# Timeout - property

1541

1075

@dbus_service_property(_interface, signature="t",

1542

1076

access="readwrite")

1543

1077

def Timeout_dbus_property(self, value=None):

1544

1078

if value is None: # get

1545

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

1546

old_timeout = self.timeout

1079

return dbus.UInt64(self.timeout_milliseconds())

1547

1080

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

1548

# Reschedule disabling

1549

if self.enabled:

1550

now = datetime.datetime.utcnow()

1551

self.expires += self.timeout - old_timeout

1552

if self.expires <= now:

1553

# The timeout has passed

1554

self.disable()

1555

else:

1556

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

1557

is None):

1558

return

1559

gobject.source_remove(self.disable_initiator_tag)

1560

self.disable_initiator_tag = (

1561

gobject.timeout_add(

1562

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

1563

* 1000), self.disable))

1564

1565

# ExtendedTimeout - property

1566

@dbus_service_property(_interface, signature="t",

1567

access="readwrite")

1568

def ExtendedTimeout_dbus_property(self, value=None):

1569

if value is None: # get

1570

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

1571

* 1000)

1572

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

1081

# Emit D-Bus signal

1082

self.PropertyChanged(dbus.String("Timeout"),

1083

dbus.UInt64(value, variant_level=1))

1084

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

1085

return

1086

# Reschedule timeout

1087

gobject.source_remove(self.disable_initiator_tag)

1088

self.disable_initiator_tag = None

1089

time_to_die = (self.

1090

_timedelta_to_milliseconds((self

1091

.last_checked_ok

1092

+ self.timeout)

1093

- datetime.datetime

1094

.utcnow()))

1095

if time_to_die <= 0:

1096

# The timeout has passed

1097

self.disable()

1098

else:

1099

self.disable_initiator_tag = (gobject.timeout_add

1100

(time_to_die, self.disable))

1573

1101

1574

1102

# Interval - property

1575

1103

@dbus_service_property(_interface, signature="t",

1576

1104

access="readwrite")

1577

1105

def Interval_dbus_property(self, value=None):

1578

1106

if value is None: # get

1579

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

1107

return dbus.UInt64(self.interval_milliseconds())

1580

1108

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

1109

# Emit D-Bus signal

1110

self.PropertyChanged(dbus.String("Interval"),

1111

dbus.UInt64(value, variant_level=1))

1581

1112

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

1582

1113

return

1583

if self.enabled:

1584

# Reschedule checker run

1585

gobject.source_remove(self.checker_initiator_tag)

1586

self.checker_initiator_tag = (gobject.timeout_add

1587

(value, self.start_checker))

1588

self.start_checker() # Start one now, too

1589

1114

# Reschedule checker run

1115

gobject.source_remove(self.checker_initiator_tag)

1116

self.checker_initiator_tag = (gobject.timeout_add

1117

(value, self.start_checker))

1118

self.start_checker() # Start one now, too

1119

1590

1120

# Checker - property

1591

1121

@dbus_service_property(_interface, signature="s",

1592

1122

access="readwrite")

1593

1123

def Checker_dbus_property(self, value=None):

1594

1124

if value is None: # get

1595

1125

return dbus.String(self.checker_command)

1596

self.checker_command = unicode(value)

1126

self.checker_command = value

1127

# Emit D-Bus signal

1128

self.PropertyChanged(dbus.String("Checker"),

1129

dbus.String(self.checker_command,

1130

variant_level=1))

1597

1131

1598

1132

# CheckerRunning - property

1599

1133

@dbus_service_property(_interface, signature="b",

1626

1160

self._pipe.send(('init', fpr, address))

1627

1161

if not self._pipe.recv():

1628

1162

raise KeyError()

1629

1163

1630

1164

def __getattribute__(self, name):

1631

if name == '_pipe':

1165

if(name == '_pipe'):

1632

1166

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

1633

1167

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

1634

1168

data = self._pipe.recv()

1639

1173

self._pipe.send(('funcall', name, args, kwargs))

1640

1174

return self._pipe.recv()[1]

1641

1175

return func

1642

1176

1643

1177

def __setattr__(self, name, value):

1644

if name == '_pipe':

1178

if(name == '_pipe'):

1645

1179

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

1646

1180

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

1647

1181

1658

1192

unicode(self.client_address))

1659

1193

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

1660

1194

self.server.child_pipe.fileno())

1661

1195

1662

1196

session = (gnutls.connection

1663

1197

.ClientSession(self.request,

1664

1198

gnutls.connection

1665

1199

.X509Credentials()))

1666

1200

1667

1201

# Note: gnutls.connection.X509Credentials is really a

1668

1202

# generic GnuTLS certificate credentials object so long as

1669

1203

# no X.509 keys are added to it. Therefore, we can use it

1670

1204

# here despite using OpenPGP certificates.

1671

1205

1672

1206

#priority = ':'.join(("NONE", "+VERS-TLS1.1",

1673

1207

# "+AES-256-CBC", "+SHA1",

1674

1208

# "+COMP-NULL", "+CTYPE-OPENPGP",

1680

1214

(gnutls.library.functions

1681

1215

.gnutls_priority_set_direct(session._c_object,

1682

1216

priority, None))

1683

1217

1684

1218

# Start communication using the Mandos protocol

1685

1219

# Get protocol number

1686

1220

line = self.request.makefile().readline()

1687

1221

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

1688

1222

try:

1689

1223

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

1690

raise RuntimeError(line)

1224

raise RuntimeError

1691

1225

except (ValueError, IndexError, RuntimeError) as error:

1692

1226

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

1693

1227

return

1694

1228

1695

1229

# Start GnuTLS connection

1696

1230

try:

1697

1231

session.handshake()

1701

1235

# established. Just abandon the request.

1702

1236

return

1703

1237

logger.debug("Handshake succeeded")

1704

1238

1705

1239

approval_required = False

1706

1240

try:

1707

1241

try:

1712

1246

logger.warning("Bad certificate: %s", error)

1713

1247

return

1714

1248

logger.debug("Fingerprint: %s", fpr)

1715

1249

1716

1250

try:

1717

1251

client = ProxyClient(child_pipe, fpr,

1718

1252

self.client_address)

1726

1260

1727

1261

while True:

1728

1262

if not client.enabled:

1729

logger.info("Client %s is disabled",

1263

logger.warning("Client %s is disabled",

1730

1264

client.name)

1731

1265

if self.server.use_dbus:

1732

1266

# Emit D-Bus signal

1733

client.Rejected("Disabled")

1267

client.Rejected("Disabled")

1734

1268

return

1735

1269

1736

if client.approved or not client.approval_delay:

1270

if client._approved or not client.approval_delay:

1737

1271

#We are approved or approval is disabled

1738

1272

break

1739

elif client.approved is None:

1273

elif client._approved is None:

1740

1274

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

1741

1275

client.name)

1742

1276

if self.server.use_dbus:

1743

1277

# Emit D-Bus signal

1744

1278

client.NeedApproval(

1745

client.approval_delay.total_seconds()

1746

* 1000, client.approved_by_default)

1279

client.approval_delay_milliseconds(),

1280

client.approved_by_default)

1747

1281

else:

1748

1282

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

1749

1283

client.name)

1753

1287

return

1754

1288

1755

1289

#wait until timeout or approved

1290

#x = float(client._timedelta_to_milliseconds(delay))

1756

1291

time = datetime.datetime.now()

1757

1292

client.changedstate.acquire()

1758

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

1293

client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))

1759

1294

client.changedstate.release()

1760

1295

time2 = datetime.datetime.now()

1761

1296

if (time2 - time) >= delay:

1777

1312

try:

1778

1313

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

1779

1314

except gnutls.errors.GNUTLSError as error:

1780

logger.warning("gnutls send failed",

1781

exc_info=error)

1315

logger.warning("gnutls send failed")

1782

1316

return

1783

1317

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

1784

1318

sent, len(client.secret)

1785

1319

- (sent_size + sent))

1786

1320

sent_size += sent

1787

1321

1788

1322

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

1789

# bump the timeout using extended_timeout

1790

client.bump_timeout(client.extended_timeout)

1323

# bump the timeout as if seen

1324

client.checked_ok()

1791

1325

if self.server.use_dbus:

1792

1326

# Emit D-Bus signal

1793

1327

client.GotSecret()

1798

1332

try:

1799

1333

session.bye()

1800

1334

except gnutls.errors.GNUTLSError as error:

1801

logger.warning("GnuTLS bye failed",

1802

exc_info=error)

1335

logger.warning("GnuTLS bye failed")

1803

1336

1804

1337

@staticmethod

1805

1338

def peer_certificate(session):

1861

1394

# Convert the buffer to a Python bytestring

1862

1395

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

1863

1396

# Convert the bytestring to hexadecimal notation

1864

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

1397

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

1865

1398

return hex_fpr

1866

1399

1867

1400

1870

1403

def sub_process_main(self, request, address):

1871

1404

try:

1872

1405

self.finish_request(request, address)

1873

except Exception:

1406

except:

1874

1407

self.handle_error(request, address)

1875

1408

self.close_request(request)

1876

1409

1877

1410

def process_request(self, request, address):

1878

1411

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

1879

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

1880

args = (request, address))

1881

proc.start()

1882

return proc

1883

1412

multiprocessing.Process(target = self.sub_process_main,

1413

args = (request, address)).start()

1884

1414

1885

1415

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1886

1416

""" adds a pipe to the MixIn """

1890

1420

This function creates a new pipe in self.pipe

1891

1421

"""

1892

1422

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1893

1894

proc = MultiprocessingMixIn.process_request(self, request,

1895

client_address)

1423

1424

super(MultiprocessingMixInWithPipe,

1425

self).process_request(request, client_address)

1896

1426

self.child_pipe.close()

1897

self.add_pipe(parent_pipe, proc)

1898

1899

def add_pipe(self, parent_pipe, proc):

1427

self.add_pipe(parent_pipe)

1428

1429

def add_pipe(self, parent_pipe):

1900

1430

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

1901

raise NotImplementedError()

1902

1431

raise NotImplementedError

1903

1432

1904

1433

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1905

1434

socketserver.TCPServer, object):

1911

1440

use_ipv6: Boolean; to use IPv6 or not

1912

1441

"""

1913

1442

def __init__(self, server_address, RequestHandlerClass,

1914

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

1915

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

1916

creating a new one with socket.socket().

1917

"""

1443

interface=None, use_ipv6=True):

1918

1444

self.interface = interface

1919

1445

if use_ipv6:

1920

1446

self.address_family = socket.AF_INET6

1921

if socketfd is not None:

1922

# Save the file descriptor

1923

self.socketfd = socketfd

1924

# Save the original socket.socket() function

1925

self.socket_socket = socket.socket

1926

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

1927

#

1928

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

1929

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

1930

# patching socket.socket.)

1931

#

1932

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

1933

@functools.wraps(socket.socket)

1934

def socket_wrapper(*args, **kwargs):

1935

# Restore original function so subsequent calls are

1936

# not affected.

1937

socket.socket = self.socket_socket

1938

del self.socket_socket

1939

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

1940

# saved file descriptor.

1941

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

1942

# Replace socket.socket() function with wrapper

1943

socket.socket = socket_wrapper

1944

# The socketserver.TCPServer.__init__ will call

1945

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

1946

# socket_wrapper(), if socketfd was set.

1947

1447

socketserver.TCPServer.__init__(self, server_address,

1948

1448

RequestHandlerClass)

1949

1950

1449

def server_bind(self):

1951

1450

"""This overrides the normal server_bind() function

1952

1451

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

1960

1459

try:

1961

1460

self.socket.setsockopt(socket.SOL_SOCKET,

1962

1461

SO_BINDTODEVICE,

1963

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

1462

str(self.interface

1463

+ '\0'))

1964

1464

except socket.error as error:

1965

if error.errno == errno.EPERM:

1966

logger.error("No permission to bind to"

1967

" interface %s", self.interface)

1968

elif error.errno == errno.ENOPROTOOPT:

1465

if error[0] == errno.EPERM:

1466

logger.error("No permission to"

1467

" bind to interface %s",

1468

self.interface)

1469

elif error[0] == errno.ENOPROTOOPT:

1969

1470

logger.error("SO_BINDTODEVICE not available;"

1970

1471

" cannot bind to interface %s",

1971

1472

self.interface)

1972

elif error.errno == errno.ENODEV:

1973

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

1974

" cannot bind", self.interface)

1975

1473

else:

1976

1474

raise

1977

1475

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

1980

1478

if self.address_family == socket.AF_INET6:

1981

1479

any_address = "::" # in6addr_any

1982

1480

else:

1983

any_address = "0.0.0.0" # INADDR_ANY

1481

any_address = socket.INADDR_ANY

1984

1482

self.server_address = (any_address,

1985

1483

self.server_address[1])

1986

1484

elif not self.server_address[1]:

2007

1505

"""

2008

1506

def __init__(self, server_address, RequestHandlerClass,

2009

1507

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

2010

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

1508

gnutls_priority=None, use_dbus=True):

2011

1509

self.enabled = False

2012

1510

self.clients = clients

2013

1511

if self.clients is None:

2014

self.clients = {}

1512

self.clients = set()

2015

1513

self.use_dbus = use_dbus

2016

1514

self.gnutls_priority = gnutls_priority

2017

1515

IPv6_TCPServer.__init__(self, server_address,

2018

1516

RequestHandlerClass,

2019

1517

interface = interface,

2020

use_ipv6 = use_ipv6,

2021

socketfd = socketfd)

1518

use_ipv6 = use_ipv6)

2022

1519

def server_activate(self):

2023

1520

if self.enabled:

2024

1521

return socketserver.TCPServer.server_activate(self)

2025

2026

1522

def enable(self):

2027

1523

self.enabled = True

2028

2029

def add_pipe(self, parent_pipe, proc):

1524

def add_pipe(self, parent_pipe):

2030

1525

# Call "handle_ipc" for both data and EOF events

2031

1526

gobject.io_add_watch(parent_pipe.fileno(),

2032

1527

gobject.IO_IN | gobject.IO_HUP,

2033

1528

functools.partial(self.handle_ipc,

2034

parent_pipe =

2035

parent_pipe,

2036

proc = proc))

2037

1529

parent_pipe = parent_pipe))

1530

2038

1531

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

2039

proc = None, client_object=None):

2040

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

2041

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

2042

# Wait for other process to exit

2043

proc.join()

1532

client_object=None):

1533

condition_names = {

1534

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

1535

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

1536

# blocking).

1537

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

1538

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

1539

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

1540

# broken, usually for pipes and

1541

# sockets).

1542

}

1543

conditions_string = ' | '.join(name

1544

for cond, name in

1545

condition_names.iteritems()

1546

if cond & condition)

1547

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

1548

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

2044

1549

return False

2045

1550

2046

1551

# Read a request from the child

2051

1556

fpr = request[1]

2052

1557

address = request[2]

2053

1558

2054

for c in self.clients.itervalues():

1559

for c in self.clients:

2055

1560

if c.fingerprint == fpr:

2056

1561

client = c

2057

1562

break

2058

1563

else:

2059

logger.info("Client not found for fingerprint: %s, ad"

2060

"dress: %s", fpr, address)

1564

logger.warning("Client not found for fingerprint: %s, ad"

1565

"dress: %s", fpr, address)

2061

1566

if self.use_dbus:

2062

1567

# Emit D-Bus signal

2063

mandos_dbus_service.ClientNotFound(fpr,

2064

address[0])

1568

mandos_dbus_service.ClientNotFound(fpr, address[0])

2065

1569

parent_pipe.send(False)

2066

1570

return False

2067

1571

2068

1572

gobject.io_add_watch(parent_pipe.fileno(),

2069

1573

gobject.IO_IN | gobject.IO_HUP,

2070

1574

functools.partial(self.handle_ipc,

2071

parent_pipe =

2072

parent_pipe,

2073

proc = proc,

2074

client_object =

2075

client))

1575

parent_pipe = parent_pipe,

1576

client_object = client))

2076

1577

parent_pipe.send(True)

2077

# remove the old hook in favor of the new above hook on

2078

# same fileno

1578

# remove the old hook in favor of the new above hook on same fileno

2079

1579

return False

2080

1580

if command == 'funcall':

2081

1581

funcname = request[1]

2082

1582

args = request[2]

2083

1583

kwargs = request[3]

2084

1584

2085

parent_pipe.send(('data', getattr(client_object,

2086

funcname)(*args,

2087

**kwargs)))

2088

1585

parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))

1586

2089

1587

if command == 'getattr':

2090

1588

attrname = request[1]

2091

1589

if callable(client_object.__getattribute__(attrname)):

2092

1590

parent_pipe.send(('function',))

2093

1591

else:

2094

parent_pipe.send(('data', client_object

2095

.__getattribute__(attrname)))

1592

parent_pipe.send(('data', client_object.__getattribute__(attrname)))

2096

1593

2097

1594

if command == 'setattr':

2098

1595

attrname = request[1]

2099

1596

value = request[2]

2100

1597

setattr(client_object, attrname, value)

2101

1598

2102

1599

return True

2103

1600

2104

1601

2105

def rfc3339_duration_to_delta(duration):

2106

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

2107

2108

>>> rfc3339_duration_to_delta("P7D")

2109

datetime.timedelta(7)

2110

>>> rfc3339_duration_to_delta("PT60S")

2111

datetime.timedelta(0, 60)

2112

>>> rfc3339_duration_to_delta("PT60M")

2113

datetime.timedelta(0, 3600)

2114

>>> rfc3339_duration_to_delta("PT24H")

2115

datetime.timedelta(1)

2116

>>> rfc3339_duration_to_delta("P1W")

2117

datetime.timedelta(7)

2118

>>> rfc3339_duration_to_delta("PT5M30S")

2119

datetime.timedelta(0, 330)

2120

>>> rfc3339_duration_to_delta("P1DT3M20S")

2121

datetime.timedelta(1, 200)

2122

"""

2123

2124

# Parsing an RFC 3339 duration with regular expressions is not

2125

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

2126

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

2127

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

2128

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

2129

# avoid excessive use of external libraries.

2130

2131

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

2132

Token = collections.namedtuple("Token",

2133

("regexp", # To match token; if

2134

# "value" is not None,

2135

# must have a "group"

2136

# containing digits

2137

"value", # datetime.timedelta or

2138

# None

2139

"followers")) # Tokens valid after

2140

# this token

2141

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

2142

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

2143

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

2144

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

2145

datetime.timedelta(seconds=1),

2146

frozenset((token_end,)))

2147

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

2148

datetime.timedelta(minutes=1),

2149

frozenset((token_second, token_end)))

2150

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

2151

datetime.timedelta(hours=1),

2152

frozenset((token_minute, token_end)))

2153

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

2154

None,

2155

frozenset((token_hour, token_minute,

2156

token_second)))

2157

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

2158

datetime.timedelta(days=1),

2159

frozenset((token_time, token_end)))

2160

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

2161

datetime.timedelta(weeks=4),

2162

frozenset((token_day, token_end)))

2163

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

2164

datetime.timedelta(weeks=52),

2165

frozenset((token_month, token_end)))

2166

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

2167

datetime.timedelta(weeks=1),

2168

frozenset((token_end,)))

2169

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

2170

frozenset((token_year, token_month,

2171

token_day, token_time,

2172

token_week)))

2173

# Define starting values

2174

value = datetime.timedelta() # Value so far

2175

found_token = None

2176

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

2177

s = duration # String left to parse

2178

# Loop until end token is found

2179

while found_token is not token_end:

2180

# Search for any currently valid tokens

2181

for token in followers:

2182

match = token.regexp.match(s)

2183

if match is not None:

2184

# Token found

2185

if token.value is not None:

2186

# Value found, parse digits

2187

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

2188

# Add to value so far

2189

value += factor * token.value

2190

# Strip token from string

2191

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

2192

# Go to found token

2193

found_token = token

2194

# Set valid next tokens

2195

followers = found_token.followers

2196

break

2197

else:

2198

# No currently valid tokens were found

2199

raise ValueError("Invalid RFC 3339 duration")

2200

# End token found

2201

return value

2202

2203

2204

1602

def string_to_delta(interval):

2205

1603

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

2206

1604

2217

1615

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

2218

1616

datetime.timedelta(0, 330)

2219

1617

"""

2220

2221

try:

2222

return rfc3339_duration_to_delta(interval)

2223

except ValueError:

2224

pass

2225

2226

1618

timevalue = datetime.timedelta(0)

2227

1619

for s in interval.split():

2228

1620

try:

2239

1631

elif suffix == "w":

2240

1632

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

2241

1633

else:

2242

raise ValueError("Unknown suffix {!r}"

2243

.format(suffix))

2244

except IndexError as e:

1634

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

1635

except (ValueError, IndexError) as e:

2245

1636

raise ValueError(*(e.args))

2246

1637

timevalue += delta

2247

1638

return timevalue

2248

1639

2249

1640

1641

def if_nametoindex(interface):

1642

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

1643

1644

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

1645

global if_nametoindex

1646

try:

1647

if_nametoindex = (ctypes.cdll.LoadLibrary

1648

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

1649

.if_nametoindex)

1650

except (OSError, AttributeError):

1651

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

1652

def if_nametoindex(interface):

1653

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

1654

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

1655

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

1656

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1657

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

1658

interface))

1659

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

1660

ifreq[16:20])[0]

1661

return interface_index

1662

return if_nametoindex(interface)

1663

1664

2250

1665

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

2251

1666

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

2252

1667

2260

1675

sys.exit()

2261

1676

if not noclose:

2262

1677

# Close all standard open file descriptors

2263

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

1678

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

2264

1679

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

2265

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

2266

.format(os.devnull))

1680

raise OSError(errno.ENODEV,

1681

"%s not a character device"

1682

% os.path.devnull)

2267

1683

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

2268

1684

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

2269

1685

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

2278

1694

2279

1695

parser = argparse.ArgumentParser()

2280

1696

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

2281

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

1697

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

2282

1698

help="show version number and exit")

2283

1699

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

2284

1700

help="Bind to interface IF")

2290

1706

help="Run self-test")

2291

1707

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

2292

1708

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

2293

" to terminal", default=None)

1709

" to terminal")

2294

1710

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

2295

1711

help="Debug level for stdout output")

2296

1712

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

2303

1719

" files")

2304

1720

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

2305

1721

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

2306

" system bus interface", default=None)

1722

" system bus interface")

2307

1723

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

2308

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

2309

default=None)

2310

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

2311

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

2312

" state", default=None)

2313

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

2314

help="Specify a file descriptor to a network"

2315

" socket to use instead of creating one")

2316

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

2317

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

2318

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

2319

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

2320

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

2321

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

2322

default=None)

2323

1724

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

2324

1725

options = parser.parse_args()

2325

1726

2326

1727

if options.check:

2327

1728

import doctest

2328

fail_count, test_count = doctest.testmod()

2329

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

1729

doctest.testmod()

1730

sys.exit()

2330

1731

2331

1732

# Default values for config file for server-global settings

2332

1733

server_defaults = { "interface": "",

2334

1735

"port": "",

2335

1736

"debug": "False",

2336

1737

"priority":

2337

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

1738

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

2338

1739

"servicename": "Mandos",

2339

1740

"use_dbus": "True",

2340

1741

"use_ipv6": "True",

2341

1742

"debuglevel": "",

2342

"restore": "True",

2343

"socket": "",

2344

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

2345

"foreground": "False",

2346

"zeroconf": "True",

2347

1743

}

2348

1744

2349

1745

# Parse config file for server-global settings

2354

1750

# Convert the SafeConfigParser object to a dict

2355

1751

server_settings = server_config.defaults()

2356

1752

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

2357

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

1753

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

2358

1754

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

2359

1755

option)

2360

1756

if server_settings["port"]:

2361

1757

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

2362

1758

"port")

2363

if server_settings["socket"]:

2364

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

2365

"socket")

2366

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

2367

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

2368

# happen with a supplied network socket.

2369

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

2370

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

2371

["socket"])

2372

1759

del server_config

2373

1760

2374

1761

# Override the settings from the config file with command line

2375

1762

# options, if set.

2376

1763

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

2377

1764

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

2378

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

2379

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

1765

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

2380

1766

value = getattr(options, option)

2381

1767

if value is not None:

2382

1768

server_settings[option] = value

2385

1771

for option in server_settings.keys():

2386

1772

if type(server_settings[option]) is str:

2387

1773

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

2388

# Force all boolean options to be boolean

2389

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

2390

"foreground", "zeroconf"):

2391

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

2392

# Debug implies foreground

2393

if server_settings["debug"]:

2394

server_settings["foreground"] = True

2395

1774

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

2396

1775

2397

1776

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

2398

1777

2399

if (not server_settings["zeroconf"] and

2400

not (server_settings["port"]

2401

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

2402

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

2403

" Zeroconf")

2404

2405

1778

# For convenience

2406

1779

debug = server_settings["debug"]

2407

1780

debuglevel = server_settings["debuglevel"]

2408

1781

use_dbus = server_settings["use_dbus"]

2409

1782

use_ipv6 = server_settings["use_ipv6"]

2410

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

2411

stored_state_file)

2412

foreground = server_settings["foreground"]

2413

zeroconf = server_settings["zeroconf"]

2414

2415

if debug:

2416

initlogger(debug, logging.DEBUG)

2417

else:

2418

if not debuglevel:

2419

initlogger(debug)

2420

else:

2421

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

2422

initlogger(debug, level)

2423

1783

2424

1784

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

2425

1785

syslogger.setFormatter(logging.Formatter

2426

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

2427

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

2428

.format(server_settings

2429

["servicename"])))

1786

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

1787

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

1788

% server_settings["servicename"]))

2430

1789

2431

1790

# Parse config file with clients

2432

client_config = configparser.SafeConfigParser(Client

2433

.client_defaults)

1791

client_defaults = { "timeout": "1h",

1792

"interval": "5m",

1793

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

1794

"host": "",

1795

"approval_delay": "0s",

1796

"approval_duration": "1s",

1797

}

1798

client_config = configparser.SafeConfigParser(client_defaults)

2434

1799

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

2435

1800

"clients.conf"))

2436

1801

2437

1802

global mandos_dbus_service

2438

1803

mandos_dbus_service = None

2439

1804

2440

socketfd = None

2441

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

2442

socketfd = server_settings["socket"]

2443

1805

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

2444

1806

server_settings["port"]),

2445

1807

ClientHandler,

2448

1810

use_ipv6=use_ipv6,

2449

1811

gnutls_priority=

2450

1812

server_settings["priority"],

2451

use_dbus=use_dbus,

2452

socketfd=socketfd)

2453

if not foreground:

2454

pidfilename = "/run/mandos.pid"

2455

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

2456

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

2457

pidfile = None

1813

use_dbus=use_dbus)

1814

if not debug:

1815

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

2458

1816

try:

2459

1817

pidfile = open(pidfilename, "w")

2460

except IOError as e:

2461

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

2462

exc_info=e)

1818

except IOError:

1819

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

2463

1820

2464

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

1821

try:

1822

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

1823

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

1824

except KeyError:

2465

1825

try:

2466

uid = pwd.getpwnam(name).pw_uid

2467

gid = pwd.getpwnam(name).pw_gid

2468

break

1826

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

1827

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

2469

1828

except KeyError:

2470

continue

2471

else:

2472

uid = 65534

2473

gid = 65534

1829

try:

1830

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

1831

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

1832

except KeyError:

1833

uid = 65534

1834

gid = 65534

2474

1835

try:

2475

1836

os.setgid(gid)

2476

1837

os.setuid(uid)

2477

1838

except OSError as error:

2478

if error.errno != errno.EPERM:

2479

raise

1839

if error[0] != errno.EPERM:

1840

raise error

2480

1841

1842

if not debug and not debuglevel:

1843

syslogger.setLevel(logging.WARNING)

1844

console.setLevel(logging.WARNING)

1845

if debuglevel:

1846

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

1847

syslogger.setLevel(level)

1848

console.setLevel(level)

1849

2481

1850

if debug:

2482

1851

# Enable all possible GnuTLS debugging

2483

1852

2493

1862

.gnutls_global_set_log_function(debug_gnutls))

2494

1863

2495

1864

# Redirect stdin so all checkers get /dev/null

2496

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

1865

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

2497

1866

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

2498

1867

if null > 2:

2499

1868

os.close(null)

1869

else:

1870

# No console logging

1871

logger.removeHandler(console)

2500

1872

2501

1873

# Need to fork before connecting to D-Bus

2502

if not foreground:

1874

if not debug:

2503

1875

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

2504

1876

daemon()

2505

1877

2506

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

2507

# need to inform gobject that threads will be used.

2508

gobject.threads_init()

2509

2510

1878

global main_loop

2511

1879

# From the Avahi example code

2512

DBusGMainLoop(set_as_default=True)

1880

DBusGMainLoop(set_as_default=True )

2513

1881

main_loop = gobject.MainLoop()

2514

1882

bus = dbus.SystemBus()

2515

1883

# End of Avahi example code

2516

1884

if use_dbus:

2517

1885

try:

2518

bus_name = dbus.service.BusName("se.recompile.Mandos",

1886

bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",

2519

1887

bus, do_not_queue=True)

2520

old_bus_name = (dbus.service.BusName

2521

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

2522

do_not_queue=True))

2523

1888

except dbus.exceptions.NameExistsException as e:

2524

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

1889

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

2525

1890

use_dbus = False

2526

1891

server_settings["use_dbus"] = False

2527

1892

tcp_server.use_dbus = False

2528

if zeroconf:

2529

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2530

service = AvahiServiceToSyslog(name =

2531

server_settings["servicename"],

2532

servicetype = "_mandos._tcp",

2533

protocol = protocol, bus = bus)

2534

if server_settings["interface"]:

2535

service.interface = (if_nametoindex

2536

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

1893

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1894

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

1895

servicetype = "_mandos._tcp",

1896

protocol = protocol, bus = bus)

1897

if server_settings["interface"]:

1898

service.interface = (if_nametoindex

1899

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

2537

1900

2538

1901

global multiprocessing_manager

2539

1902

multiprocessing_manager = multiprocessing.Manager()

2541

1904

client_class = Client

2542

1905

if use_dbus:

2543

1906

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

2544

2545

client_settings = Client.config_parser(client_config)

2546

old_client_settings = {}

2547

clients_data = {}

2548

2549

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

2550

global wnull

2551

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

2552

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

2553

# mode

2554

if debug or not foreground:

2555

wnull.close()

2556

2557

# Get client data and settings from last running state.

2558

if server_settings["restore"]:

2559

try:

2560

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

2561

clients_data, old_client_settings = (pickle.load

2562

(stored_state))

2563

os.remove(stored_state_path)

2564

except IOError as e:

2565

if e.errno == errno.ENOENT:

2566

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

2567

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

2568

else:

2569

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

2570

exc_info=e)

2571

raise

2572

except EOFError as e:

2573

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

2574

"EOFError:", exc_info=e)

2575

2576

with PGPEngine() as pgp:

2577

for client_name, client in clients_data.items():

2578

# Skip removed clients

2579

if client_name not in client_settings:

2580

continue

2581

2582

# Decide which value to use after restoring saved state.

2583

# We have three different values: Old config file,

2584

# new config file, and saved state.

2585

# New config value takes precedence if it differs from old

2586

# config value, otherwise use saved state.

2587

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

2588

try:

2589

# For each value in new config, check if it

2590

# differs from the old config value (Except for

2591

# the "secret" attribute)

2592

if (name != "secret" and

2593

value != old_client_settings[client_name]

2594

[name]):

2595

client[name] = value

2596

except KeyError:

2597

pass

2598

2599

# Clients who has passed its expire date can still be

2600

# enabled if its last checker was successful. Clients

2601

# whose checker succeeded before we stored its state is

2602

# assumed to have successfully run all checkers during

2603

# downtime.

2604

if client["enabled"]:

2605

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

2606

if not client["last_checked_ok"]:

2607

logger.warning(

2608

"disabling client {} - Client never "

2609

"performed a successful checker"

2610

.format(client_name))

2611

client["enabled"] = False

2612

elif client["last_checker_status"] != 0:

2613

logger.warning(

2614

"disabling client {} - Client last"

2615

" checker failed with error code {}"

2616

.format(client_name,

2617

client["last_checker_status"]))

2618

client["enabled"] = False

2619

else:

2620

client["expires"] = (datetime.datetime

2621

.utcnow()

2622

+ client["timeout"])

2623

logger.debug("Last checker succeeded,"

2624

" keeping {} enabled"

2625

.format(client_name))

1907

def client_config_items(config, section):

1908

special_settings = {

1909

"approved_by_default":

1910

lambda: config.getboolean(section,

1911

"approved_by_default"),

1912

}

1913

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

2626

1914

try:

2627

client["secret"] = (

2628

pgp.decrypt(client["encrypted_secret"],

2629

client_settings[client_name]

2630

["secret"]))

2631

except PGPError:

2632

# If decryption fails, we use secret from new settings

2633

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

2634

.format(client_name))

2635

client["secret"] = (

2636

client_settings[client_name]["secret"])

2637

2638

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

2639

for client_name in (set(old_client_settings)

2640

- set(client_settings)):

2641

del clients_data[client_name]

2642

for client_name in (set(client_settings)

2643

- set(old_client_settings)):

2644

clients_data[client_name] = client_settings[client_name]

2645

2646

# Create all client objects

2647

for client_name, client in clients_data.items():

2648

tcp_server.clients[client_name] = client_class(

2649

name = client_name, settings = client,

2650

server_settings = server_settings)

2651

1915

yield (name, special_settings[name]())

1916

except KeyError:

1917

yield (name, value)

1918

1919

tcp_server.clients.update(set(

1920

client_class(name = section,

1921

config= dict(client_config_items(

1922

client_config, section)))

1923

for section in client_config.sections()))

2652

1924

if not tcp_server.clients:

2653

1925

logger.warning("No clients defined")

2654

2655

if not foreground:

2656

if pidfile is not None:

2657

try:

2658

with pidfile:

2659

pid = os.getpid()

2660

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

2661

except IOError:

2662

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

2663

pidfilename, pid)

2664

del pidfile

1926

1927

if not debug:

1928

try:

1929

with pidfile:

1930

pid = os.getpid()

1931

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

1932

del pidfile

1933

except IOError:

1934

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

1935

pidfilename, pid)

1936

except NameError:

1937

# "pidfile" was never created

1938

pass

2665

1939

del pidfilename

2666

1940

1941

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

1942

2667

1943

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

2668

1944

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

2669

1945

2670

1946

if use_dbus:

2671

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

2672

"se.bsnet.fukt.Mandos"})

2673

class MandosDBusService(DBusObjectWithProperties):

1947

class MandosDBusService(dbus.service.Object):

2674

1948

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

2675

1949

def __init__(self):

2676

1950

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

2677

_interface = "se.recompile.Mandos"

2678

2679

@dbus_interface_annotations(_interface)

2680

def _foo(self):

2681

return { "org.freedesktop.DBus.Property"

2682

".EmitsChangedSignal":

2683

"false"}

1951

_interface = "se.bsnet.fukt.Mandos"

2684

1952

2685

1953

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

2686

1954

def ClientAdded(self, objpath):

2701

1969

def GetAllClients(self):

2702

1970

"D-Bus method"

2703

1971

return dbus.Array(c.dbus_object_path

2704

for c in

2705

tcp_server.clients.itervalues())

1972

for c in tcp_server.clients)

2706

1973

2707

1974

@dbus.service.method(_interface,

2708

1975

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

2710

1977

"D-Bus method"

2711

1978

return dbus.Dictionary(

2712

1979

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

2713

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

1980

for c in tcp_server.clients),

2714

1981

signature="oa{sv}")

2715

1982

2716

1983

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

2717

1984

def RemoveClient(self, object_path):

2718

1985

"D-Bus method"

2719

for c in tcp_server.clients.itervalues():

1986

for c in tcp_server.clients:

2720

1987

if c.dbus_object_path == object_path:

2721

del tcp_server.clients[c.name]

1988

tcp_server.clients.remove(c)

2722

1989

c.remove_from_connection()

2723

1990

# Don't signal anything except ClientRemoved

2724

1991

c.disable(quiet=True)

2733

2000

2734

2001

def cleanup():

2735

2002

"Cleanup function; run on exit"

2736

if zeroconf:

2737

service.cleanup()

2738

2739

multiprocessing.active_children()

2740

wnull.close()

2741

if not (tcp_server.clients or client_settings):

2742

return

2743

2744

# Store client before exiting. Secrets are encrypted with key

2745

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

2746

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

2747

clients = {}

2748

with PGPEngine() as pgp:

2749

for client in tcp_server.clients.itervalues():

2750

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

2751

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

2752

key)

2753

client_dict = {}

2754

2755

# A list of attributes that can not be pickled

2756

# + secret.

2757

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

2758

"checker", "server_settings" }

2759

for name, typ in (inspect.getmembers

2760

(dbus.service.Object)):

2761

exclude.add(name)

2762

2763

client_dict["encrypted_secret"] = (client

2764

.encrypted_secret)

2765

for attr in client.client_structure:

2766

if attr not in exclude:

2767

client_dict[attr] = getattr(client, attr)

2768

2769

clients[client.name] = client_dict

2770

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

2771

2772

try:

2773

with (tempfile.NamedTemporaryFile

2774

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

2775

dir=os.path.dirname(stored_state_path),

2776

delete=False)) as stored_state:

2777

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

2778

tempname=stored_state.name

2779

os.rename(tempname, stored_state_path)

2780

except (IOError, OSError) as e:

2781

if not debug:

2782

try:

2783

os.remove(tempname)

2784

except NameError:

2785

pass

2786

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

2787

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

2788

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

2789

else:

2790

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

2791

exc_info=e)

2792

raise

2793

2794

# Delete all clients, and settings from config

2003

service.cleanup()

2004

2795

2005

while tcp_server.clients:

2796

name, client = tcp_server.clients.popitem()

2006

client = tcp_server.clients.pop()

2797

2007

if use_dbus:

2798

2008

client.remove_from_connection()

2009

client.disable_hook = None

2799

2010

# Don't signal anything except ClientRemoved

2800

2011

client.disable(quiet=True)

2801

2012

if use_dbus:

2802

2013

# Emit D-Bus signal

2803

mandos_dbus_service.ClientRemoved(client

2804

.dbus_object_path,

2014

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2805

2015

client.name)

2806

client_settings.clear()

2807

2016

2808

2017

atexit.register(cleanup)

2809

2018

2810

for client in tcp_server.clients.itervalues():

2019

for client in tcp_server.clients:

2811

2020

if use_dbus:

2812

2021

# Emit D-Bus signal

2813

2022

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2814

# Need to initiate checking of clients

2815

if client.enabled:

2816

client.init_checker()

2023

client.enable()

2817

2024

2818

2025

tcp_server.enable()

2819

2026

tcp_server.server_activate()

2820

2027

2821

2028

# Find out what port we got

2822

if zeroconf:

2823

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

2029

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

2824

2030

if use_ipv6:

2825

2031

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

2826

" flowinfo %d, scope_id %d",

2827

*tcp_server.socket.getsockname())

2032

" flowinfo %d, scope_id %d"

2033

% tcp_server.socket.getsockname())

2828

2034

else: # IPv4

2829

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

2830

*tcp_server.socket.getsockname())

2035

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

2036

% tcp_server.socket.getsockname())

2831

2037

2832

2038

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

2833

2039

2834

2040

try:

2835

if zeroconf:

2836

# From the Avahi example code

2837

try:

2838

service.activate()

2839

except dbus.exceptions.DBusException as error:

2840

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

2841

cleanup()

2842

sys.exit(1)

2843

# End of Avahi example code

2041

# From the Avahi example code

2042

try:

2043

service.activate()

2044

except dbus.exceptions.DBusException as error:

2045

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

2046

cleanup()

2047

sys.exit(1)

2048

# End of Avahi example code

2844

2049

2845

2050

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

2846

2051

lambda *args, **kwargs:

2850

2055

logger.debug("Starting main loop")

2851

2056

main_loop.run()

2852

2057

except AvahiError as error:

2853

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

2058

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

2854

2059

cleanup()

2855

2060

sys.exit(1)

2856

2061

except KeyboardInterrupt: