/mandos/trunk : revision 505.3.8

1

#!/usr/bin/python2.7

1

#!/usr/bin/python

2

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

3

#

4

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

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

65

63

import cPickle as pickle

66

64

import multiprocessing

67

65

import types

68

import binascii

69

import tempfile

70

import itertools

71

import collections

72

66

73

67

import dbus

74

68

import dbus.service

88

82

except ImportError:

89

83

SO_BINDTODEVICE = None

90

84

91

if sys.version_info.major == 2:

92

str = unicode

93

94

version = "1.6.8"

95

stored_state_file = "clients.pickle"

96

97

logger = logging.getLogger()

98

syslogger = None

99

100

try:

101

if_nametoindex = (ctypes.cdll.LoadLibrary

102

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

103

.if_nametoindex)

104

except (OSError, AttributeError):

105

def if_nametoindex(interface):

106

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

107

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

108

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

109

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

110

struct.pack(b"16s16x", interface))

111

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

112

return interface_index

113

114

115

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

116

"""init logger and add loglevel"""

117

118

global syslogger

119

syslogger = (logging.handlers.SysLogHandler

120

(facility =

121

logging.handlers.SysLogHandler.LOG_DAEMON,

122

address = "/dev/log"))

123

syslogger.setFormatter(logging.Formatter

124

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

125

' %(message)s'))

126

logger.addHandler(syslogger)

127

128

if debug:

129

console = logging.StreamHandler()

130

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

131

' [%(process)d]:'

132

' %(levelname)s:'

133

' %(message)s'))

134

logger.addHandler(console)

135

logger.setLevel(level)

136

137

138

class PGPError(Exception):

139

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

140

pass

141

142

143

class PGPEngine(object):

144

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

145

def __init__(self):

146

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

147

self.gnupgargs = ['--batch',

148

'--home', self.tempdir,

149

'--force-mdc',

150

'--quiet',

151

'--no-use-agent']

152

153

def __enter__(self):

154

return self

155

156

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

157

self._cleanup()

158

return False

159

160

def __del__(self):

161

self._cleanup()

162

163

def _cleanup(self):

164

if self.tempdir is not None:

165

# Delete contents of tempdir

166

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

167

topdown = False):

168

for filename in files:

169

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

170

for dirname in dirs:

171

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

172

# Remove tempdir

173

os.rmdir(self.tempdir)

174

self.tempdir = None

175

176

def password_encode(self, password):

177

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

178

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

179

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

180

if len(encoded) > 2048:

181

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

182

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

183

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

184

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

185

return encoded

186

187

def encrypt(self, data, password):

188

passphrase = self.password_encode(password)

189

with tempfile.NamedTemporaryFile(dir=self.tempdir

190

) as passfile:

191

passfile.write(passphrase)

192

passfile.flush()

193

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

194

'--passphrase-file',

195

passfile.name]

196

+ self.gnupgargs,

197

stdin = subprocess.PIPE,

198

stdout = subprocess.PIPE,

199

stderr = subprocess.PIPE)

200

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

201

if proc.returncode != 0:

202

raise PGPError(err)

203

return ciphertext

204

205

def decrypt(self, data, password):

206

passphrase = self.password_encode(password)

207

with tempfile.NamedTemporaryFile(dir = self.tempdir

208

) as passfile:

209

passfile.write(passphrase)

210

passfile.flush()

211

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

212

'--passphrase-file',

213

passfile.name]

214

+ self.gnupgargs,

215

stdin = subprocess.PIPE,

216

stdout = subprocess.PIPE,

217

stderr = subprocess.PIPE)

218

decrypted_plaintext, err = proc.communicate(input

219

= data)

220

if proc.returncode != 0:

221

raise PGPError(err)

222

return decrypted_plaintext

223

85

86

version = "1.4.1"

87

88

#logger = logging.getLogger('mandos')

89

logger = logging.Logger('mandos')

90

syslogger = (logging.handlers.SysLogHandler

91

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

92

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

93

syslogger.setFormatter(logging.Formatter

94

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

95

' %(message)s'))

96

logger.addHandler(syslogger)

97

98

console = logging.StreamHandler()

99

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

100

' %(levelname)s:'

101

' %(message)s'))

102

logger.addHandler(console)

224

103

225

104

class AvahiError(Exception):

226

105

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

227

106

self.value = value

228

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

229

**kwargs)

107

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

108

def __unicode__(self):

109

return unicode(repr(self.value))

230

110

231

111

class AvahiServiceError(AvahiError):

232

112

pass

243

123

Used to optionally bind to the specified interface.

244

124

name: string; Example: 'Mandos'

245

125

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

246

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

126

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

247

127

port: integer; what port to announce

248

128

TXT: list of strings; TXT record for the service

249

129

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

255

135

server: D-Bus Server

256

136

bus: dbus.SystemBus()

257

137

"""

258

259

138

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

260

139

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

261

140

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

274

153

self.server = None

275

154

self.bus = bus

276

155

self.entry_group_state_changed_match = None

277

278

156

def rename(self):

279

157

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

280

158

if self.rename_count >= self.max_renames:

282

160

" after %i retries, exiting.",

283

161

self.rename_count)

284

162

raise AvahiServiceError("Too many renames")

285

self.name = str(self.server

286

.GetAlternativeServiceName(self.name))

163

self.name = unicode(self.server

164

.GetAlternativeServiceName(self.name))

287

165

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

288

166

self.name)

167

syslogger.setFormatter(logging.Formatter

168

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

169

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

170

% self.name))

289

171

self.remove()

290

172

try:

291

173

self.add()

292

174

except dbus.exceptions.DBusException as error:

293

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

175

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

294

176

self.cleanup()

295

177

os._exit(1)

296

178

self.rename_count += 1

297

298

179

def remove(self):

299

180

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

300

181

if self.entry_group_state_changed_match is not None:

302

183

self.entry_group_state_changed_match = None

303

184

if self.group is not None:

304

185

self.group.Reset()

305

306

186

def add(self):

307

187

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

308

188

self.remove()

313

193

avahi.DBUS_INTERFACE_ENTRY_GROUP)

314

194

self.entry_group_state_changed_match = (

315

195

self.group.connect_to_signal(

316

'StateChanged', self.entry_group_state_changed))

196

'StateChanged', self .entry_group_state_changed))

317

197

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

318

198

self.name, self.type)

319

199

self.group.AddService(

325

205

dbus.UInt16(self.port),

326

206

avahi.string_array_to_txt_array(self.TXT))

327

207

self.group.Commit()

328

329

208

def entry_group_state_changed(self, state, error):

330

209

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

331

210

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

337

216

self.rename()

338

217

elif state == avahi.ENTRY_GROUP_FAILURE:

339

218

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

340

str(error))

341

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

342

.format(error))

343

219

unicode(error))

220

raise AvahiGroupError("State changed: %s"

221

% unicode(error))

344

222

def cleanup(self):

345

223

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

346

224

if self.group is not None:

347

225

try:

348

226

self.group.Free()

349

227

except (dbus.exceptions.UnknownMethodException,

350

dbus.exceptions.DBusException):

228

dbus.exceptions.DBusException) as e:

351

229

pass

352

230

self.group = None

353

231

self.remove()

354

355

232

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

356

233

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

357

234

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

376

253

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

377

254

else:

378

255

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

379

380

256

def activate(self):

381

257

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

382

258

if self.server is None:

390

266

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

391

267

392

268

393

class AvahiServiceToSyslog(AvahiService):

394

def rename(self):

395

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

396

ret = AvahiService.rename(self)

397

syslogger.setFormatter(logging.Formatter

398

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

399

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

400

.format(self.name)))

401

return ret

402

403

269

def _timedelta_to_milliseconds(td):

270

"Convert a datetime.timedelta() to milliseconds"

271

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

272

+ (td.seconds * 1000)

273

+ (td.microseconds // 1000))

274

404

275

class Client(object):

405

276

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

406

277

407

278

Attributes:

408

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

279

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

409

280

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

410

281

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

411

282

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

418

289

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

419

290

checker_initiator_tag: a gobject event source tag, or None

420

291

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

421

client_structure: Object describing what attributes a client has

422

and is used for storing the client at exit

423

292

current_checker_command: string; current running checker_command

293

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

424

294

disable_initiator_tag: a gobject event source tag, or None

425

295

enabled: bool()

426

296

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

429

299

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

430

300

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

431

301

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

432

last_checker_status: integer between 0 and 255 reflecting exit

433

status of last checker. -1 reflects crashed

434

checker, -2 means no checker completed yet.

435

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

302

last_enabled: datetime.datetime(); (UTC)

436

303

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

437

304

D-Bus identifiers

438

305

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

439

306

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

440

307

until this client is disabled

441

extended_timeout: extra long timeout when secret has been sent

308

extended_timeout: extra long timeout when password has been sent

442

309

runtime_expansions: Allowed attributes for runtime expansion.

443

310

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

444

311

disabled, or None

445

server_settings: The server_settings dict from main()

446

312

"""

447

313

448

314

runtime_expansions = ("approval_delay", "approval_duration",

449

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

450

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

451

"last_approval_request", "last_checked_ok",

315

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

316

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

452

317

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

453

client_defaults = { "timeout": "PT5M",

454

"extended_timeout": "PT15M",

455

"interval": "PT2M",

456

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

457

"host": "",

458

"approval_delay": "PT0S",

459

"approval_duration": "PT1S",

460

"approved_by_default": "True",

461

"enabled": "True",

462

}

463

464

@staticmethod

465

def config_parser(config):

466

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

467

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

468

with exceptions for any special settings as defined above.

469

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

470

value given the same arguments.

471

"""

472

settings = {}

473

for client_name in config.sections():

474

section = dict(config.items(client_name))

475

client = settings[client_name] = {}

476

477

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

478

# Reformat values from string types to Python types

479

client["approved_by_default"] = config.getboolean(

480

client_name, "approved_by_default")

481

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

482

"enabled")

483

484

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

485

.replace(" ", ""))

486

if "secret" in section:

487

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

488

elif "secfile" in section:

489

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

490

(section["secfile"])),

491

"rb") as secfile:

492

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

493

else:

494

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

495

.format(section))

496

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

497

client["extended_timeout"] = string_to_delta(

498

section["extended_timeout"])

499

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

500

client["approval_delay"] = string_to_delta(

501

section["approval_delay"])

502

client["approval_duration"] = string_to_delta(

503

section["approval_duration"])

504

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

505

client["last_approval_request"] = None

506

client["last_checked_ok"] = None

507

client["last_checker_status"] = -2

508

509

return settings

510

511

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

318

319

def timeout_milliseconds(self):

320

"Return the 'timeout' attribute in milliseconds"

321

return _timedelta_to_milliseconds(self.timeout)

322

323

def extended_timeout_milliseconds(self):

324

"Return the 'extended_timeout' attribute in milliseconds"

325

return _timedelta_to_milliseconds(self.extended_timeout)

326

327

def interval_milliseconds(self):

328

"Return the 'interval' attribute in milliseconds"

329

return _timedelta_to_milliseconds(self.interval)

330

331

def approval_delay_milliseconds(self):

332

return _timedelta_to_milliseconds(self.approval_delay)

333

334

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

335

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

336

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

337

attribute."""

512

338

self.name = name

513

if server_settings is None:

514

server_settings = {}

515

self.server_settings = server_settings

516

# adding all client settings

517

for setting, value in settings.items():

518

setattr(self, setting, value)

519

520

if self.enabled:

521

if not hasattr(self, "last_enabled"):

522

self.last_enabled = datetime.datetime.utcnow()

523

if not hasattr(self, "expires"):

524

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

525

+ self.timeout)

526

else:

527

self.last_enabled = None

528

self.expires = None

529

339

if config is None:

340

config = {}

530

341

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

531

342

# Uppercase and remove spaces from fingerprint for later

532

343

# comparison purposes with return value from the fingerprint()

533

344

# function

345

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

346

.replace(" ", ""))

534

347

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

535

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

536

datetime.datetime.utcnow())

537

538

# attributes specific for this server instance

348

if "secret" in config:

349

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

350

elif "secfile" in config:

351

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

352

(config["secfile"])),

353

"rb") as secfile:

354

self.secret = secfile.read()

355

else:

356

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

357

% self.name)

358

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

359

self.created = datetime.datetime.utcnow()

360

self.enabled = False

361

self.last_approval_request = None

362

self.last_enabled = None

363

self.last_checked_ok = None

364

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

365

self.extended_timeout = string_to_delta(config

366

["extended_timeout"])

367

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

368

self.disable_hook = disable_hook

539

369

self.checker = None

540

370

self.checker_initiator_tag = None

541

371

self.disable_initiator_tag = None

372

self.expires = None

542

373

self.checker_callback_tag = None

374

self.checker_command = config["checker"]

543

375

self.current_checker_command = None

544

self.approved = None

376

self.last_connect = None

377

self._approved = None

378

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

379

True)

545

380

self.approvals_pending = 0

381

self.approval_delay = string_to_delta(

382

config["approval_delay"])

383

self.approval_duration = string_to_delta(

384

config["approval_duration"])

546

385

self.changedstate = (multiprocessing_manager

547

386

.Condition(multiprocessing_manager

548

387

.Lock()))

549

self.client_structure = [attr for attr in

550

self.__dict__.iterkeys()

551

if not attr.startswith("_")]

552

self.client_structure.append("client_structure")

553

554

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

555

lambda obj:

556

isinstance(obj,

557

property)):

558

if not name.startswith("_"):

559

self.client_structure.append(name)

560

388

561

# Send notice to process children that client state has changed

562

389

def send_changedstate(self):

563

with self.changedstate:

564

self.changedstate.notify_all()

390

self.changedstate.acquire()

391

self.changedstate.notify_all()

392

self.changedstate.release()

565

393

566

394

def enable(self):

567

395

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

568

396

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

569

397

# Already enabled

570

398

return

399

self.send_changedstate()

400

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

401

# and every interval from then on.

402

self.checker_initiator_tag = (gobject.timeout_add

403

(self.interval_milliseconds(),

404

self.start_checker))

405

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

571

406

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

407

self.disable_initiator_tag = (gobject.timeout_add

408

(self.timeout_milliseconds(),

409

self.disable))

572

410

self.enabled = True

573

411

self.last_enabled = datetime.datetime.utcnow()

574

self.init_checker()

575

self.send_changedstate()

412

# Also start a new checker *right now*.

413

self.start_checker()

576

414

577

415

def disable(self, quiet=True):

578

416

"""Disable this client."""

579

417

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

580

418

return False

581

419

if not quiet:

420

self.send_changedstate()

421

if not quiet:

582

422

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

583

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

423

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

584

424

gobject.source_remove(self.disable_initiator_tag)

585

425

self.disable_initiator_tag = None

586

426

self.expires = None

587

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

427

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

588

428

gobject.source_remove(self.checker_initiator_tag)

589

429

self.checker_initiator_tag = None

590

430

self.stop_checker()

431

if self.disable_hook:

432

self.disable_hook(self)

591

433

self.enabled = False

592

if not quiet:

593

self.send_changedstate()

594

434

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

595

435

return False

596

436

597

437

def __del__(self):

438

self.disable_hook = None

598

439

self.disable()

599

440

600

def init_checker(self):

601

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

602

# and every interval from then on.

603

if self.checker_initiator_tag is not None:

604

gobject.source_remove(self.checker_initiator_tag)

605

self.checker_initiator_tag = (gobject.timeout_add

606

(int(self.interval

607

.total_seconds() * 1000),

608

self.start_checker))

609

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

610

if self.disable_initiator_tag is not None:

611

gobject.source_remove(self.disable_initiator_tag)

612

self.disable_initiator_tag = (gobject.timeout_add

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

616

# Also start a new checker *right now*.

617

self.start_checker()

618

619

441

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

620

442

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

621

443

self.checker_callback_tag = None

622

444

self.checker = None

623

445

if os.WIFEXITED(condition):

624

self.last_checker_status = os.WEXITSTATUS(condition)

625

if self.last_checker_status == 0:

446

exitstatus = os.WEXITSTATUS(condition)

447

if exitstatus == 0:

626

448

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

627

449

vars(self))

628

450

self.checked_ok()

630

452

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

631

453

vars(self))

632

454

else:

633

self.last_checker_status = -1

634

455

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

635

456

vars(self))

636

457

637

def checked_ok(self):

638

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

639

self.last_checked_ok = datetime.datetime.utcnow()

640

self.last_checker_status = 0

641

self.bump_timeout()

642

643

def bump_timeout(self, timeout=None):

644

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

458

def checked_ok(self, timeout=None):

459

"""Bump up the timeout for this client.

460

461

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

462

alive and well.

463

"""

645

464

if timeout is None:

646

465

timeout = self.timeout

466

self.last_checked_ok = datetime.datetime.utcnow()

647

467

if self.disable_initiator_tag is not None:

648

468

gobject.source_remove(self.disable_initiator_tag)

649

self.disable_initiator_tag = None

650

469

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

651

470

self.disable_initiator_tag = (gobject.timeout_add

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

471

(_timedelta_to_milliseconds

472

(timeout), self.disable))

654

473

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

655

474

656

475

def need_approval(self):

662

481

If a checker already exists, leave it running and do

663

482

nothing."""

664

483

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

665

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

666

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

667

# would inevitably timeout, since no checker would get a

668

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

484

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

485

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

486

# client would inevitably timeout, since no checker would get

487

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

669

488

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

670

489

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

671

490

# should be.

673

492

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

674

493

try:

675

494

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

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

495

except (AttributeError, OSError) as error:

496

if (isinstance(error, OSError)

497

and error.errno != errno.ECHILD):

498

raise error

681

499

else:

682

500

if pid:

683

501

logger.warning("Checker was a zombie")

686

504

self.current_checker_command)

687

505

# Start a new checker if needed

688

506

if self.checker is None:

689

# Escape attributes for the shell

690

escaped_attrs = { attr:

691

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

692

for attr in self.runtime_expansions }

693

507

try:

694

command = self.checker_command % escaped_attrs

695

except TypeError as error:

696

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

697

self.checker_command, exc_info=error)

698

return True # Try again later

508

# In case checker_command has exactly one % operator

509

command = self.checker_command % self.host

510

except TypeError:

511

# Escape attributes for the shell

512

escaped_attrs = dict(

513

(attr,

514

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

515

errors=

516

'replace')))

517

for attr in

518

self.runtime_expansions)

519

520

try:

521

command = self.checker_command % escaped_attrs

522

except TypeError as error:

523

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

524

' %s', self.checker_command, error)

525

return True # Try again later

699

526

self.current_checker_command = command

700

527

try:

701

528

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

704

531

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

705

532

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

706

533

# always replaced by /dev/null.)

707

# The exception is when not debugging but nevertheless

708

# running in the foreground; use the previously

709

# created wnull.

710

popen_args = {}

711

if (not self.server_settings["debug"]

712

and self.server_settings["foreground"]):

713

popen_args.update({"stdout": wnull,

714

"stderr": wnull })

715

534

self.checker = subprocess.Popen(command,

716

535

close_fds=True,

717

shell=True, cwd="/",

718

**popen_args)

719

except OSError as error:

720

logger.error("Failed to start subprocess",

721

exc_info=error)

722

return True

723

self.checker_callback_tag = (gobject.child_watch_add

724

(self.checker.pid,

725

self.checker_callback,

726

data=command))

727

# The checker may have completed before the gobject

728

# watch was added. Check for this.

729

try:

536

shell=True, cwd="/")

537

self.checker_callback_tag = (gobject.child_watch_add

538

(self.checker.pid,

539

self.checker_callback,

540

data=command))

541

# The checker may have completed before the gobject

542

# watch was added. Check for this.

730

543

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

544

if pid:

545

gobject.source_remove(self.checker_callback_tag)

546

self.checker_callback(pid, status, command)

731

547

except OSError as error:

732

if error.errno == errno.ECHILD:

733

# This should never happen

734

logger.error("Child process vanished",

735

exc_info=error)

736

return True

737

raise

738

if pid:

739

gobject.source_remove(self.checker_callback_tag)

740

self.checker_callback(pid, status, command)

548

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

549

error)

741

550

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

742

551

return True

743

552

750

559

return

751

560

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

752

561

try:

753

self.checker.terminate()

562

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

754

563

#time.sleep(0.5)

755

564

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

756

# self.checker.kill()

565

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

757

566

except OSError as error:

758

567

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

759

568

raise

776

585

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

777

586

if byte_arrays and signature != "ay":

778

587

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

779

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

588

" signature %r" % signature)

780

589

def decorator(func):

781

590

func._dbus_is_property = True

782

591

func._dbus_interface = dbus_interface

790

599

return decorator

791

600

792

601

793

def dbus_interface_annotations(dbus_interface):

794

"""Decorator for marking functions returning interface annotations

795

796

Usage:

797

798

@dbus_interface_annotations("org.example.Interface")

799

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

800

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

801

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

802

"false"}

803

"""

804

def decorator(func):

805

func._dbus_is_interface = True

806

func._dbus_interface = dbus_interface

807

func._dbus_name = dbus_interface

808

return func

809

return decorator

810

811

812

def dbus_annotations(annotations):

813

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

814

Usage:

815

816

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

817

access="r")

818

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

819

"org.freedesktop.DBus.Property."

820

"EmitsChangedSignal": "false"})

821

def Property_dbus_property(self):

822

return dbus.Boolean(False)

823

"""

824

def decorator(func):

825

func._dbus_annotations = annotations

826

return func

827

return decorator

828

829

830

602

class DBusPropertyException(dbus.exceptions.DBusException):

831

603

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

832

604

"""

833

pass

605

def __unicode__(self):

606

return unicode(str(self))

607

834

608

835

609

class DBusPropertyAccessException(DBusPropertyException):

836

610

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

853

627

"""

854

628

855

629

@staticmethod

856

def _is_dbus_thing(thing):

857

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

858

859

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

860

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

861

"""

862

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

863

False)

630

def _is_dbus_property(obj):

631

return getattr(obj, "_dbus_is_property", False)

864

632

865

def _get_all_dbus_things(self, thing):

633

def _get_all_dbus_properties(self):

866

634

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

867

635

"""

868

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

869

name),

870

athing.__get__(self))

636

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

871

637

for cls in self.__class__.__mro__

872

for name, athing in

873

inspect.getmembers(cls,

874

self._is_dbus_thing(thing)))

638

for name, prop in

639

inspect.getmembers(cls, self._is_dbus_property))

875

640

876

641

def _get_dbus_property(self, interface_name, property_name):

877

642

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

879

644

"""

880

645

for cls in self.__class__.__mro__:

881

646

for name, value in (inspect.getmembers

882

(cls,

883

self._is_dbus_thing("property"))):

647

(cls, self._is_dbus_property)):

884

648

if (value._dbus_name == property_name

885

649

and value._dbus_interface == interface_name):

886

650

return value.__get__(self)

914

678

# The byte_arrays option is not supported yet on

915

679

# signatures other than "ay".

916

680

if prop._dbus_signature != "ay":

917

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

918

"'ay' signature {!r}"

919

.format(prop._dbus_signature))

920

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

921

for byte in value))

681

raise ValueError

682

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

683

for byte in value))

922

684

prop(value)

923

685

924

686

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

929

691

930

692

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

931

693

"""

932

properties = {}

933

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

694

all = {}

695

for name, prop in self._get_all_dbus_properties():

934

696

if (interface_name

935

697

and interface_name != prop._dbus_interface):

936

698

# Interface non-empty but did not match

940

702

continue

941

703

value = prop()

942

704

if not hasattr(value, "variant_level"):

943

properties[name] = value

705

all[name] = value

944

706

continue

945

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

946

value.variant_level+1)

947

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

707

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

708

value.variant_level+1)

709

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

948

710

949

711

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

950

712

out_signature="s",

951

713

path_keyword='object_path',

952

714

connection_keyword='connection')

953

715

def Introspect(self, object_path, connection):

954

"""Overloading of standard D-Bus method.

955

956

Inserts property tags and interface annotation tags.

716

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

957

717

"""

958

718

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

959

719

connection)

966

726

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

967

727

return e

968

728

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

969

# Add property tags

970

729

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

971

730

for name, prop

972

in self._get_all_dbus_things("property")

731

in self._get_all_dbus_properties()

973

732

if prop._dbus_interface

974

733

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

975

734

if_tag.appendChild(tag)

976

# Add annotation tags

977

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

978

for tag in if_tag.getElementsByTagName(typ):

979

annots = dict()

980

for name, prop in (self.

981

_get_all_dbus_things(typ)):

982

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

983

and prop._dbus_interface

984

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

985

annots.update(getattr

986

(prop,

987

"_dbus_annotations",

988

{}))

989

for name, value in annots.items():

990

ann_tag = document.createElement(

991

"annotation")

992

ann_tag.setAttribute("name", name)

993

ann_tag.setAttribute("value", value)

994

tag.appendChild(ann_tag)

995

# Add interface annotation tags

996

for annotation, value in dict(

997

itertools.chain.from_iterable(

998

annotations().items()

999

for name, annotations in

1000

self._get_all_dbus_things("interface")

1001

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

1002

)).items():

1003

ann_tag = document.createElement("annotation")

1004

ann_tag.setAttribute("name", annotation)

1005

ann_tag.setAttribute("value", value)

1006

if_tag.appendChild(ann_tag)

1007

735

# Add the names to the return values for the

1008

736

# "org.freedesktop.DBus.Properties" methods

1009

737

if (if_tag.getAttribute("name")

1024

752

except (AttributeError, xml.dom.DOMException,

1025

753

xml.parsers.expat.ExpatError) as error:

1026

754

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

1027

exc_info=error)

755

error)

1028

756

return xmlstring

1029

757

1030

758

1031

def datetime_to_dbus(dt, variant_level=0):

759

def datetime_to_dbus (dt, variant_level=0):

1032

760

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

1033

761

if dt is None:

1034

762

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

1035

763

return dbus.String(dt.isoformat(),

1036

764

variant_level=variant_level)

1037

765

1038

1039

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1040

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

1041

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

1042

interface names according to the "alt_interface_names" mapping.

1043

Usage:

1044

1045

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

1046

"net.example.AlternateInterface"})

1047

class SampleDBusObject(dbus.service.Object):

1048

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

1049

def SampleDBusMethod():

1050

pass

1051

1052

The above "SampleDBusMethod" on "SampleDBusObject" will be

1053

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

1054

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

1055

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

1056

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

1057

1058

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

1059

(from DBusObjectWithProperties) and interfaces (from the

1060

dbus_interface_annotations decorator).

766

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

767

.__metaclass__):

768

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

769

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

1061

770

"""

1062

def wrapper(cls):

1063

for orig_interface_name, alt_interface_name in (

1064

alt_interface_names.items()):

1065

attr = {}

1066

interface_names = set()

1067

# Go though all attributes of the class

1068

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

771

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

772

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

773

# methods, signals, or properties in them

774

for base in (b for b in bases

775

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

776

# Go though all attributes of the base class

777

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

1069

778

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

1070

779

# with the wrong interface name

1071

780

if (not hasattr(attribute, "_dbus_interface")

1072

781

or not attribute._dbus_interface

1073

.startswith(orig_interface_name)):

782

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

1074

783

continue

1075

784

# Create an alternate D-Bus interface name based on

1076

785

# the current name

1077

786

alt_interface = (attribute._dbus_interface

1078

.replace(orig_interface_name,

1079

alt_interface_name))

1080

interface_names.add(alt_interface)

787

.replace("se.recompile.Mandos",

788

"se.bsnet.fukt.Mandos"))

1081

789

# Is this a D-Bus signal?

1082

790

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

1083

# Extract the original non-method undecorated

1084

# function by black magic

791

# Extract the original non-method function by

792

# black magic

1085

793

nonmethod_func = (dict(

1086

794

zip(attribute.func_code.co_freevars,

1087

795

attribute.__closure__))["func"]

1098

806

nonmethod_func.func_name,

1099

807

nonmethod_func.func_defaults,

1100

808

nonmethod_func.func_closure)))

1101

# Copy annotations, if any

1102

try:

1103

new_function._dbus_annotations = (

1104

dict(attribute._dbus_annotations))

1105

except AttributeError:

1106

pass

1107

809

# Define a creator of a function to call both the

1108

# original and alternate functions, so both the

1109

# original and alternate signals gets sent when

1110

# the function is called

810

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

811

# signals gets sent when the function is called

1111

812

def fixscope(func1, func2):

1112

813

"""This function is a scope container to pass

1113

814

func1 and func2 to the "call_both" function

1120

821

return call_both

1121

822

# Create the "call_both" function and add it to

1122

823

# the class

1123

attr[attrname] = fixscope(attribute, new_function)

824

attr[attrname] = fixscope(attribute,

825

new_function)

1124

826

# Is this a D-Bus method?

1125

827

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

1126

828

# Create a new, but exactly alike, function

1137

839

attribute.func_name,

1138

840

attribute.func_defaults,

1139

841

attribute.func_closure)))

1140

# Copy annotations, if any

1141

try:

1142

attr[attrname]._dbus_annotations = (

1143

dict(attribute._dbus_annotations))

1144

except AttributeError:

1145

pass

1146

842

# Is this a D-Bus property?

1147

843

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

1148

844

# Create a new, but exactly alike, function

1162

858

attribute.func_name,

1163

859

attribute.func_defaults,

1164

860

attribute.func_closure)))

1165

# Copy annotations, if any

1166

try:

1167

attr[attrname]._dbus_annotations = (

1168

dict(attribute._dbus_annotations))

1169

except AttributeError:

1170

pass

1171

# Is this a D-Bus interface?

1172

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

1173

# Create a new, but exactly alike, function

1174

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

1175

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

1176

# to the class.

1177

attr[attrname] = (dbus_interface_annotations

1178

(alt_interface)

1179

(types.FunctionType

1180

(attribute.func_code,

1181

attribute.func_globals,

1182

attribute.func_name,

1183

attribute.func_defaults,

1184

attribute.func_closure)))

1185

if deprecate:

1186

# Deprecate all alternate interfaces

1187

iname="_AlternateDBusNames_interface_annotation{}"

1188

for interface_name in interface_names:

1189

@dbus_interface_annotations(interface_name)

1190

def func(self):

1191

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

1192

"true" }

1193

# Find an unused name

1194

for aname in (iname.format(i)

1195

for i in itertools.count()):

1196

if aname not in attr:

1197

attr[aname] = func

1198

break

1199

if interface_names:

1200

# Replace the class with a new subclass of it with

1201

# methods, signals, etc. as created above.

1202

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

1203

(cls,), attr)

1204

return cls

1205

return wrapper

1206

1207

1208

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

1209

"se.bsnet.fukt.Mandos"})

861

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

862

1210

863

class ClientDBus(Client, DBusObjectWithProperties):

1211

864

"""A Client class using D-Bus

1212

865

1221

874

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

1222

875

1223

876

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

877

self._approvals_pending = 0

1224

878

self.bus = bus

1225

879

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

1226

880

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

1227

881

# the D-Bus

1228

client_object_name = str(self.name).translate(

882

client_object_name = unicode(self.name).translate(

1229

883

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

1230

884

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

1231

885

self.dbus_object_path = (dbus.ObjectPath

1232

886

("/clients/" + client_object_name))

1233

887

DBusObjectWithProperties.__init__(self, self.bus,

1234

888

self.dbus_object_path)

1235

889

1236

890

def notifychangeproperty(transform_func,

1237

891

dbus_name, type_func=lambda x: x,

1238

892

variant_level=1):

1239

893

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

1240

894

its changes to DBus.

1241

895

1242

896

transform_fun: Function that takes a value and a variant_level

1243

897

and transforms it to a D-Bus type.

1244

898

dbus_name: D-Bus name of the variable

1246

900

to the D-Bus. Default: no transform

1247

901

variant_level: D-Bus variant level. Default: 1

1248

902

"""

1249

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

903

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

1250

904

def setter(self, value):

1251

905

if hasattr(self, "dbus_object_path"):

1252

906

if (not hasattr(self, attrname) or

1261

915

1262

916

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

1263

917

918

1264

919

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1265

920

approvals_pending = notifychangeproperty(dbus.Boolean,

1266

921

"ApprovalPending",

1273

928

checker is not None)

1274

929

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1275

930

"LastCheckedOK")

1276

last_checker_status = notifychangeproperty(dbus.Int16,

1277

"LastCheckerStatus")

1278

931

last_approval_request = notifychangeproperty(

1279

932

datetime_to_dbus, "LastApprovalRequest")

1280

933

approved_by_default = notifychangeproperty(dbus.Boolean,

1281

934

"ApprovedByDefault")

1282

approval_delay = notifychangeproperty(dbus.UInt64,

935

approval_delay = notifychangeproperty(dbus.UInt16,

1283

936

"ApprovalDelay",

1284

937

type_func =

1285

lambda td: td.total_seconds()

1286

* 1000)

938

_timedelta_to_milliseconds)

1287

939

approval_duration = notifychangeproperty(

1288

dbus.UInt64, "ApprovalDuration",

1289

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

940

dbus.UInt16, "ApprovalDuration",

941

type_func = _timedelta_to_milliseconds)

1290

942

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

1291

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

1292

type_func = lambda td:

1293

td.total_seconds() * 1000)

943

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

944

type_func =

945

_timedelta_to_milliseconds)

1294

946

extended_timeout = notifychangeproperty(

1295

dbus.UInt64, "ExtendedTimeout",

1296

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

1297

interval = notifychangeproperty(dbus.UInt64,

947

dbus.UInt16, "ExtendedTimeout",

948

type_func = _timedelta_to_milliseconds)

949

interval = notifychangeproperty(dbus.UInt16,

1298

950

"Interval",

1299

951

type_func =

1300

lambda td: td.total_seconds()

1301

* 1000)

952

_timedelta_to_milliseconds)

1302

953

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

1303

954

1304

955

del notifychangeproperty

1332

983

*args, **kwargs)

1333

984

1334

985

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

1335

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

986

old_checker = self.checker

987

if self.checker is not None:

988

old_checker_pid = self.checker.pid

989

else:

990

old_checker_pid = None

1336

991

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

1337

992

# Only if new checker process was started

1338

993

if (self.checker is not None

1342

997

return r

1343

998

1344

999

def _reset_approved(self):

1345

self.approved = None

1000

self._approved = None

1346

1001

return False

1347

1002

1348

1003

def approve(self, value=True):

1349

self.approved = value

1350

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

1351

* 1000), self._reset_approved)

1352

1004

self.send_changedstate()

1005

self._approved = value

1006

gobject.timeout_add(_timedelta_to_milliseconds

1007

(self.approval_duration),

1008

self._reset_approved)

1009

1353

1010

1354

1011

## D-Bus methods, signals & properties

1355

1012

_interface = "se.recompile.Mandos.Client"

1356

1013

1357

## Interfaces

1358

1359

@dbus_interface_annotations(_interface)

1360

def _foo(self):

1361

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

1362

"false"}

1363

1364

1014

## Signals

1365

1015

1366

1016

# CheckerCompleted - signal

1457

1107

access="readwrite")

1458

1108

def ApprovalDelay_dbus_property(self, value=None):

1459

1109

if value is None: # get

1460

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

1461

* 1000)

1110

return dbus.UInt64(self.approval_delay_milliseconds())

1462

1111

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

1463

1112

1464

1113

# ApprovalDuration - property

1466

1115

access="readwrite")

1467

1116

def ApprovalDuration_dbus_property(self, value=None):

1468

1117

if value is None: # get

1469

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

1470

* 1000)

1118

return dbus.UInt64(_timedelta_to_milliseconds(

1119

self.approval_duration))

1471

1120

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

1472

1121

1473

1122

# Name - property

1486

1135

def Host_dbus_property(self, value=None):

1487

1136

if value is None: # get

1488

1137

return dbus.String(self.host)

1489

self.host = str(value)

1138

self.host = value

1490

1139

1491

1140

# Created - property

1492

1141

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

1493

1142

def Created_dbus_property(self):

1494

return datetime_to_dbus(self.created)

1143

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

1495

1144

1496

1145

# LastEnabled - property

1497

1146

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

1518

1167

return

1519

1168

return datetime_to_dbus(self.last_checked_ok)

1520

1169

1521

# LastCheckerStatus - property

1522

@dbus_service_property(_interface, signature="n",

1523

access="read")

1524

def LastCheckerStatus_dbus_property(self):

1525

return dbus.Int16(self.last_checker_status)

1526

1527

1170

# Expires - property

1528

1171

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

1529

1172

def Expires_dbus_property(self):

1539

1182

access="readwrite")

1540

1183

def Timeout_dbus_property(self, value=None):

1541

1184

if value is None: # get

1542

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

1543

old_timeout = self.timeout

1185

return dbus.UInt64(self.timeout_milliseconds())

1544

1186

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

1545

# Reschedule disabling

1546

if self.enabled:

1547

now = datetime.datetime.utcnow()

1548

self.expires += self.timeout - old_timeout

1549

if self.expires <= now:

1550

# The timeout has passed

1551

self.disable()

1552

else:

1553

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

1554

is None):

1555

return

1556

gobject.source_remove(self.disable_initiator_tag)

1557

self.disable_initiator_tag = (

1558

gobject.timeout_add(

1559

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

1560

* 1000), self.disable))

1187

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

1188

return

1189

# Reschedule timeout

1190

gobject.source_remove(self.disable_initiator_tag)

1191

self.disable_initiator_tag = None

1192

self.expires = None

1193

time_to_die = _timedelta_to_milliseconds((self

1194

.last_checked_ok

1195

+ self.timeout)

1196

- datetime.datetime

1197

.utcnow())

1198

if time_to_die <= 0:

1199

# The timeout has passed

1200

self.disable()

1201

else:

1202

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

1203

+ datetime.timedelta(milliseconds =

1204

time_to_die))

1205

self.disable_initiator_tag = (gobject.timeout_add

1206

(time_to_die, self.disable))

1561

1207

1562

1208

# ExtendedTimeout - property

1563

1209

@dbus_service_property(_interface, signature="t",

1564

1210

access="readwrite")

1565

1211

def ExtendedTimeout_dbus_property(self, value=None):

1566

1212

if value is None: # get

1567

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

1568

* 1000)

1213

return dbus.UInt64(self.extended_timeout_milliseconds())

1569

1214

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

1570

1215

1571

1216

# Interval - property

1573

1218

access="readwrite")

1574

1219

def Interval_dbus_property(self, value=None):

1575

1220

if value is None: # get

1576

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

1221

return dbus.UInt64(self.interval_milliseconds())

1577

1222

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

1578

1223

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

1579

1224

return

1580

if self.enabled:

1581

# Reschedule checker run

1582

gobject.source_remove(self.checker_initiator_tag)

1583

self.checker_initiator_tag = (gobject.timeout_add

1584

(value, self.start_checker))

1585

self.start_checker() # Start one now, too

1225

# Reschedule checker run

1226

gobject.source_remove(self.checker_initiator_tag)

1227

self.checker_initiator_tag = (gobject.timeout_add

1228

(value, self.start_checker))

1229

self.start_checker() # Start one now, too

1586

1230

1587

1231

# Checker - property

1588

1232

@dbus_service_property(_interface, signature="s",

1590

1234

def Checker_dbus_property(self, value=None):

1591

1235

if value is None: # get

1592

1236

return dbus.String(self.checker_command)

1593

self.checker_command = str(value)

1237

self.checker_command = value

1594

1238

1595

1239

# CheckerRunning - property

1596

1240

@dbus_service_property(_interface, signature="b",

1612

1256

@dbus_service_property(_interface, signature="ay",

1613

1257

access="write", byte_arrays=True)

1614

1258

def Secret_dbus_property(self, value):

1615

self.secret = bytes(value)

1259

self.secret = str(value)

1616

1260

1617

1261

del _interface

1618

1262

1625

1269

raise KeyError()

1626

1270

1627

1271

def __getattribute__(self, name):

1628

if name == '_pipe':

1272

if(name == '_pipe'):

1629

1273

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

1630

1274

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

1631

1275

data = self._pipe.recv()

1638

1282

return func

1639

1283

1640

1284

def __setattr__(self, name, value):

1641

if name == '_pipe':

1285

if(name == '_pipe'):

1642

1286

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

1643

1287

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

1644

1288

1289

class ClientDBusTransitional(ClientDBus):

1290

__metaclass__ = AlternateDBusNamesMetaclass

1645

1291

1646

1292

class ClientHandler(socketserver.BaseRequestHandler, object):

1647

1293

"""A class to handle client connections.

1652

1298

def handle(self):

1653

1299

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

1654

1300

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

1655

str(self.client_address))

1301

unicode(self.client_address))

1656

1302

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

1657

1303

self.server.child_pipe.fileno())

1658

1304

1684

1330

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

1685

1331

try:

1686

1332

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

1687

raise RuntimeError(line)

1333

raise RuntimeError

1688

1334

except (ValueError, IndexError, RuntimeError) as error:

1689

1335

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

1690

1336

return

1730

1376

client.Rejected("Disabled")

1731

1377

return

1732

1378

1733

if client.approved or not client.approval_delay:

1379

if client._approved or not client.approval_delay:

1734

1380

#We are approved or approval is disabled

1735

1381

break

1736

elif client.approved is None:

1382

elif client._approved is None:

1737

1383

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

1738

1384

client.name)

1739

1385

if self.server.use_dbus:

1740

1386

# Emit D-Bus signal

1741

1387

client.NeedApproval(

1742

client.approval_delay.total_seconds()

1743

* 1000, client.approved_by_default)

1388

client.approval_delay_milliseconds(),

1389

client.approved_by_default)

1744

1390

else:

1745

1391

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

1746

1392

client.name)

1752

1398

#wait until timeout or approved

1753

1399

time = datetime.datetime.now()

1754

1400

client.changedstate.acquire()

1755

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

1401

(client.changedstate.wait

1402

(float(client._timedelta_to_milliseconds(delay)

1403

/ 1000)))

1756

1404

client.changedstate.release()

1757

1405

time2 = datetime.datetime.now()

1758

1406

if (time2 - time) >= delay:

1774

1422

try:

1775

1423

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

1776

1424

except gnutls.errors.GNUTLSError as error:

1777

logger.warning("gnutls send failed",

1778

exc_info=error)

1425

logger.warning("gnutls send failed")

1779

1426

return

1780

1427

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

1781

1428

sent, len(client.secret)

1784

1431

1785

1432

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

1786

1433

# bump the timeout using extended_timeout

1787

client.bump_timeout(client.extended_timeout)

1434

client.checked_ok(client.extended_timeout)

1788

1435

if self.server.use_dbus:

1789

1436

# Emit D-Bus signal

1790

1437

client.GotSecret()

1795

1442

try:

1796

1443

session.bye()

1797

1444

except gnutls.errors.GNUTLSError as error:

1798

logger.warning("GnuTLS bye failed",

1799

exc_info=error)

1445

logger.warning("GnuTLS bye failed")

1800

1446

1801

1447

@staticmethod

1802

1448

def peer_certificate(session):

1858

1504

# Convert the buffer to a Python bytestring

1859

1505

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

1860

1506

# Convert the bytestring to hexadecimal notation

1861

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

1507

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

1862

1508

return hex_fpr

1863

1509

1864

1510

1867

1513

def sub_process_main(self, request, address):

1868

1514

try:

1869

1515

self.finish_request(request, address)

1870

except Exception:

1516

except:

1871

1517

self.handle_error(request, address)

1872

1518

self.close_request(request)

1873

1519

1874

1520

def process_request(self, request, address):

1875

1521

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

1876

1522

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

1877

args = (request, address))

1523

args = (request,

1524

address))

1878

1525

proc.start()

1879

1526

return proc

1880

1527

1895

1542

1896

1543

def add_pipe(self, parent_pipe, proc):

1897

1544

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

1898

raise NotImplementedError()

1545

raise NotImplementedError

1899

1546

1900

1547

1901

1548

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1908

1555

use_ipv6: Boolean; to use IPv6 or not

1909

1556

"""

1910

1557

def __init__(self, server_address, RequestHandlerClass,

1911

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

1912

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

1913

creating a new one with socket.socket().

1914

"""

1558

interface=None, use_ipv6=True):

1915

1559

self.interface = interface

1916

1560

if use_ipv6:

1917

1561

self.address_family = socket.AF_INET6

1918

if socketfd is not None:

1919

# Save the file descriptor

1920

self.socketfd = socketfd

1921

# Save the original socket.socket() function

1922

self.socket_socket = socket.socket

1923

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

1924

#

1925

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

1926

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

1927

# patching socket.socket.)

1928

#

1929

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

1930

@functools.wraps(socket.socket)

1931

def socket_wrapper(*args, **kwargs):

1932

# Restore original function so subsequent calls are

1933

# not affected.

1934

socket.socket = self.socket_socket

1935

del self.socket_socket

1936

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

1937

# saved file descriptor.

1938

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

1939

# Replace socket.socket() function with wrapper

1940

socket.socket = socket_wrapper

1941

# The socketserver.TCPServer.__init__ will call

1942

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

1943

# socket_wrapper(), if socketfd was set.

1944

1562

socketserver.TCPServer.__init__(self, server_address,

1945

1563

RequestHandlerClass)

1946

1947

1564

def server_bind(self):

1948

1565

"""This overrides the normal server_bind() function

1949

1566

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

1957

1574

try:

1958

1575

self.socket.setsockopt(socket.SOL_SOCKET,

1959

1576

SO_BINDTODEVICE,

1960

(self.interface + "\0")

1961

.encode("utf-8"))

1577

str(self.interface

1578

+ '\0'))

1962

1579

except socket.error as error:

1963

if error.errno == errno.EPERM:

1964

logger.error("No permission to bind to"

1965

" interface %s", self.interface)

1966

elif error.errno == errno.ENOPROTOOPT:

1580

if error[0] == errno.EPERM:

1581

logger.error("No permission to"

1582

" bind to interface %s",

1583

self.interface)

1584

elif error[0] == errno.ENOPROTOOPT:

1967

1585

logger.error("SO_BINDTODEVICE not available;"

1968

1586

" cannot bind to interface %s",

1969

1587

self.interface)

1970

elif error.errno == errno.ENODEV:

1971

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

1972

" cannot bind", self.interface)

1973

1588

else:

1974

1589

raise

1975

1590

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

1978

1593

if self.address_family == socket.AF_INET6:

1979

1594

any_address = "::" # in6addr_any

1980

1595

else:

1981

any_address = "0.0.0.0" # INADDR_ANY

1596

any_address = socket.INADDR_ANY

1982

1597

self.server_address = (any_address,

1983

1598

self.server_address[1])

1984

1599

elif not self.server_address[1]:

2005

1620

"""

2006

1621

def __init__(self, server_address, RequestHandlerClass,

2007

1622

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

2008

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

1623

gnutls_priority=None, use_dbus=True):

2009

1624

self.enabled = False

2010

1625

self.clients = clients

2011

1626

if self.clients is None:

2012

self.clients = {}

1627

self.clients = set()

2013

1628

self.use_dbus = use_dbus

2014

1629

self.gnutls_priority = gnutls_priority

2015

1630

IPv6_TCPServer.__init__(self, server_address,

2016

1631

RequestHandlerClass,

2017

1632

interface = interface,

2018

use_ipv6 = use_ipv6,

2019

socketfd = socketfd)

1633

use_ipv6 = use_ipv6)

2020

1634

def server_activate(self):

2021

1635

if self.enabled:

2022

1636

return socketserver.TCPServer.server_activate(self)

2035

1649

2036

1650

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

2037

1651

proc = None, client_object=None):

1652

condition_names = {

1653

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

1654

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

1655

# blocking).

1656

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

1657

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

1658

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

1659

# broken, usually for pipes and

1660

# sockets).

1661

}

1662

conditions_string = ' | '.join(name

1663

for cond, name in

1664

condition_names.iteritems()

1665

if cond & condition)

2038

1666

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

2039

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

1667

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

2040

1668

# Wait for other process to exit

2041

1669

proc.join()

2042

1670

return False

2049

1677

fpr = request[1]

2050

1678

address = request[2]

2051

1679

2052

for c in self.clients.itervalues():

1680

for c in self.clients:

2053

1681

if c.fingerprint == fpr:

2054

1682

client = c

2055

1683

break

2100

1728

return True

2101

1729

2102

1730

2103

def rfc3339_duration_to_delta(duration):

2104

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

2105

2106

>>> rfc3339_duration_to_delta("P7D")

2107

datetime.timedelta(7)

2108

>>> rfc3339_duration_to_delta("PT60S")

2109

datetime.timedelta(0, 60)

2110

>>> rfc3339_duration_to_delta("PT60M")

2111

datetime.timedelta(0, 3600)

2112

>>> rfc3339_duration_to_delta("PT24H")

2113

datetime.timedelta(1)

2114

>>> rfc3339_duration_to_delta("P1W")

2115

datetime.timedelta(7)

2116

>>> rfc3339_duration_to_delta("PT5M30S")

2117

datetime.timedelta(0, 330)

2118

>>> rfc3339_duration_to_delta("P1DT3M20S")

2119

datetime.timedelta(1, 200)

2120

"""

2121

2122

# Parsing an RFC 3339 duration with regular expressions is not

2123

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

2124

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

2125

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

2126

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

2127

# avoid excessive use of external libraries.

2128

2129

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

2130

Token = collections.namedtuple("Token",

2131

("regexp", # To match token; if

2132

# "value" is not None,

2133

# must have a "group"

2134

# containing digits

2135

"value", # datetime.timedelta or

2136

# None

2137

"followers")) # Tokens valid after

2138

# this token

2139

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

2140

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

2141

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

2142

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

2143

datetime.timedelta(seconds=1),

2144

frozenset((token_end,)))

2145

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

2146

datetime.timedelta(minutes=1),

2147

frozenset((token_second, token_end)))

2148

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

2149

datetime.timedelta(hours=1),

2150

frozenset((token_minute, token_end)))

2151

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

2152

None,

2153

frozenset((token_hour, token_minute,

2154

token_second)))

2155

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

2156

datetime.timedelta(days=1),

2157

frozenset((token_time, token_end)))

2158

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

2159

datetime.timedelta(weeks=4),

2160

frozenset((token_day, token_end)))

2161

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

2162

datetime.timedelta(weeks=52),

2163

frozenset((token_month, token_end)))

2164

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

2165

datetime.timedelta(weeks=1),

2166

frozenset((token_end,)))

2167

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

2168

frozenset((token_year, token_month,

2169

token_day, token_time,

2170

token_week)))

2171

# Define starting values

2172

value = datetime.timedelta() # Value so far

2173

found_token = None

2174

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

2175

s = duration # String left to parse

2176

# Loop until end token is found

2177

while found_token is not token_end:

2178

# Search for any currently valid tokens

2179

for token in followers:

2180

match = token.regexp.match(s)

2181

if match is not None:

2182

# Token found

2183

if token.value is not None:

2184

# Value found, parse digits

2185

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

2186

# Add to value so far

2187

value += factor * token.value

2188

# Strip token from string

2189

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

2190

# Go to found token

2191

found_token = token

2192

# Set valid next tokens

2193

followers = found_token.followers

2194

break

2195

else:

2196

# No currently valid tokens were found

2197

raise ValueError("Invalid RFC 3339 duration")

2198

# End token found

2199

return value

2200

2201

2202

1731

def string_to_delta(interval):

2203

1732

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

2204

1733

2215

1744

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

2216

1745

datetime.timedelta(0, 330)

2217

1746

"""

2218

2219

try:

2220

return rfc3339_duration_to_delta(interval)

2221

except ValueError:

2222

pass

2223

2224

1747

timevalue = datetime.timedelta(0)

2225

1748

for s in interval.split():

2226

1749

try:

2227

suffix = s[-1]

1750

suffix = unicode(s[-1])

2228

1751

value = int(s[:-1])

2229

1752

if suffix == "d":

2230

1753

delta = datetime.timedelta(value)

2237

1760

elif suffix == "w":

2238

1761

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

2239

1762

else:

2240

raise ValueError("Unknown suffix {!r}"

2241

.format(suffix))

2242

except IndexError as e:

1763

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

1764

except (ValueError, IndexError) as e:

2243

1765

raise ValueError(*(e.args))

2244

1766

timevalue += delta

2245

1767

return timevalue

2246

1768

2247

1769

1770

def if_nametoindex(interface):

1771

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

1772

1773

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

1774

global if_nametoindex

1775

try:

1776

if_nametoindex = (ctypes.cdll.LoadLibrary

1777

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

1778

.if_nametoindex)

1779

except (OSError, AttributeError):

1780

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

1781

def if_nametoindex(interface):

1782

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

1783

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

1784

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

1785

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1786

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

1787

interface))

1788

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

1789

ifreq[16:20])[0]

1790

return interface_index

1791

return if_nametoindex(interface)

1792

1793

2248

1794

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

2249

1795

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

2250

1796

2258

1804

sys.exit()

2259

1805

if not noclose:

2260

1806

# Close all standard open file descriptors

2261

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

1807

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

2262

1808

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

2263

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

2264

.format(os.devnull))

1809

raise OSError(errno.ENODEV,

1810

"%s not a character device"

1811

% os.path.devnull)

2265

1812

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

2266

1813

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

2267

1814

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

2276

1823

2277

1824

parser = argparse.ArgumentParser()

2278

1825

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

2279

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

1826

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

2280

1827

help="show version number and exit")

2281

1828

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

2282

1829

help="Bind to interface IF")

2288

1835

help="Run self-test")

2289

1836

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

2290

1837

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

2291

" to terminal", default=None)

1838

" to terminal")

2292

1839

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

2293

1840

help="Debug level for stdout output")

2294

1841

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

2301

1848

" files")

2302

1849

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

2303

1850

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

2304

" system bus interface", default=None)

1851

" system bus interface")

2305

1852

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

2306

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

2307

default=None)

2308

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

2309

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

2310

" state", default=None)

2311

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

2312

help="Specify a file descriptor to a network"

2313

" socket to use instead of creating one")

2314

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

2315

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

2316

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

2317

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

2318

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

2319

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

2320

default=None)

2321

1853

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

2322

1854

options = parser.parse_args()

2323

1855

2324

1856

if options.check:

2325

1857

import doctest

2326

fail_count, test_count = doctest.testmod()

2327

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

1858

doctest.testmod()

1859

sys.exit()

2328

1860

2329

1861

# Default values for config file for server-global settings

2330

1862

server_defaults = { "interface": "",

2332

1864

"port": "",

2333

1865

"debug": "False",

2334

1866

"priority":

2335

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

1867

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

2336

1868

"servicename": "Mandos",

2337

1869

"use_dbus": "True",

2338

1870

"use_ipv6": "True",

2339

1871

"debuglevel": "",

2340

"restore": "True",

2341

"socket": "",

2342

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

2343

"foreground": "False",

2344

"zeroconf": "True",

2345

1872

}

2346

1873

2347

1874

# Parse config file for server-global settings

2352

1879

# Convert the SafeConfigParser object to a dict

2353

1880

server_settings = server_config.defaults()

2354

1881

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

2355

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

1882

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

2356

1883

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

2357

1884

option)

2358

1885

if server_settings["port"]:

2359

1886

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

2360

1887

"port")

2361

if server_settings["socket"]:

2362

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

2363

"socket")

2364

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

2365

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

2366

# happen with a supplied network socket.

2367

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

2368

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

2369

["socket"])

2370

1888

del server_config

2371

1889

2372

1890

# Override the settings from the config file with command line

2373

1891

# options, if set.

2374

1892

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

2375

1893

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

2376

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

2377

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

1894

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

2378

1895

value = getattr(options, option)

2379

1896

if value is not None:

2380

1897

server_settings[option] = value

2381

1898

del options

2382

1899

# Force all strings to be unicode

2383

1900

for option in server_settings.keys():

2384

if isinstance(server_settings[option], bytes):

2385

server_settings[option] = (server_settings[option]

2386

.decode("utf-8"))

2387

# Force all boolean options to be boolean

2388

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

2389

"foreground", "zeroconf"):

2390

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

2391

# Debug implies foreground

2392

if server_settings["debug"]:

2393

server_settings["foreground"] = True

1901

if type(server_settings[option]) is str:

1902

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

2394

1903

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

2395

1904

2396

1905

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

2397

1906

2398

if (not server_settings["zeroconf"] and

2399

not (server_settings["port"]

2400

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

2401

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

2402

" Zeroconf")

2403

2404

1907

# For convenience

2405

1908

debug = server_settings["debug"]

2406

1909

debuglevel = server_settings["debuglevel"]

2407

1910

use_dbus = server_settings["use_dbus"]

2408

1911

use_ipv6 = server_settings["use_ipv6"]

2409

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

2410

stored_state_file)

2411

foreground = server_settings["foreground"]

2412

zeroconf = server_settings["zeroconf"]

2413

2414

if debug:

2415

initlogger(debug, logging.DEBUG)

2416

else:

2417

if not debuglevel:

2418

initlogger(debug)

2419

else:

2420

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

2421

initlogger(debug, level)

2422

1912

2423

1913

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

2424

1914

syslogger.setFormatter(logging.Formatter

2425

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

2426

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

2427

.format(server_settings

2428

["servicename"])))

1915

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

1916

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

1917

% server_settings["servicename"]))

2429

1918

2430

1919

# Parse config file with clients

2431

client_config = configparser.SafeConfigParser(Client

2432

.client_defaults)

1920

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

1921

"extended_timeout": "15m",

1922

"interval": "2m",

1923

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

1924

"host": "",

1925

"approval_delay": "0s",

1926

"approval_duration": "1s",

1927

}

1928

client_config = configparser.SafeConfigParser(client_defaults)

2433

1929

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

2434

1930

"clients.conf"))

2435

1931

2436

1932

global mandos_dbus_service

2437

1933

mandos_dbus_service = None

2438

1934

2439

socketfd = None

2440

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

2441

socketfd = server_settings["socket"]

2442

1935

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

2443

1936

server_settings["port"]),

2444

1937

ClientHandler,

2447

1940

use_ipv6=use_ipv6,

2448

1941

gnutls_priority=

2449

1942

server_settings["priority"],

2450

use_dbus=use_dbus,

2451

socketfd=socketfd)

2452

if not foreground:

2453

pidfilename = "/run/mandos.pid"

2454

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

2455

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

2456

pidfile = None

1943

use_dbus=use_dbus)

1944

if not debug:

1945

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

2457

1946

try:

2458

1947

pidfile = open(pidfilename, "w")

2459

except IOError as e:

2460

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

2461

exc_info=e)

1948

except IOError:

1949

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

2462

1950

2463

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

1951

try:

1952

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

1953

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

1954

except KeyError:

2464

1955

try:

2465

uid = pwd.getpwnam(name).pw_uid

2466

gid = pwd.getpwnam(name).pw_gid

2467

break

1956

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

1957

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

2468

1958

except KeyError:

2469

continue

2470

else:

2471

uid = 65534

2472

gid = 65534

1959

try:

1960

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

1961

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

1962

except KeyError:

1963

uid = 65534

1964

gid = 65534

2473

1965

try:

2474

1966

os.setgid(gid)

2475

1967

os.setuid(uid)

2476

1968

except OSError as error:

2477

if error.errno != errno.EPERM:

2478

raise

1969

if error[0] != errno.EPERM:

1970

raise error

1971

1972

if not debug and not debuglevel:

1973

syslogger.setLevel(logging.WARNING)

1974

console.setLevel(logging.WARNING)

1975

if debuglevel:

1976

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

1977

syslogger.setLevel(level)

1978

console.setLevel(level)

2479

1979

2480

1980

if debug:

2481

1981

# Enable all possible GnuTLS debugging

2492

1992

.gnutls_global_set_log_function(debug_gnutls))

2493

1993

2494

1994

# Redirect stdin so all checkers get /dev/null

2495

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

1995

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

2496

1996

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

2497

1997

if null > 2:

2498

1998

os.close(null)

1999

else:

2000

# No console logging

2001

logger.removeHandler(console)

2499

2002

2500

2003

# Need to fork before connecting to D-Bus

2501

if not foreground:

2004

if not debug:

2502

2005

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

2503

2006

daemon()

2504

2007

2505

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

2506

# need to inform gobject that threads will be used.

2507

gobject.threads_init()

2508

2509

2008

global main_loop

2510

2009

# From the Avahi example code

2511

DBusGMainLoop(set_as_default=True)

2010

DBusGMainLoop(set_as_default=True )

2512

2011

main_loop = gobject.MainLoop()

2513

2012

bus = dbus.SystemBus()

2514

2013

# End of Avahi example code

2520

2019

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

2521

2020

do_not_queue=True))

2522

2021

except dbus.exceptions.NameExistsException as e:

2523

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

2022

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

2524

2023

use_dbus = False

2525

2024

server_settings["use_dbus"] = False

2526

2025

tcp_server.use_dbus = False

2527

if zeroconf:

2528

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2529

service = AvahiServiceToSyslog(name =

2530

server_settings["servicename"],

2531

servicetype = "_mandos._tcp",

2532

protocol = protocol, bus = bus)

2533

if server_settings["interface"]:

2534

service.interface = (if_nametoindex

2535

(server_settings["interface"]

2536

.encode("utf-8")))

2026

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2027

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

2028

servicetype = "_mandos._tcp",

2029

protocol = protocol, bus = bus)

2030

if server_settings["interface"]:

2031

service.interface = (if_nametoindex

2032

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

2537

2033

2538

2034

global multiprocessing_manager

2539

2035

multiprocessing_manager = multiprocessing.Manager()

2540

2036

2541

2037

client_class = Client

2542

2038

if use_dbus:

2543

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

2039

client_class = functools.partial(ClientDBusTransitional,

2040

bus = bus)

2041

def client_config_items(config, section):

2042

special_settings = {

2043

"approved_by_default":

2044

lambda: config.getboolean(section,

2045

"approved_by_default"),

2046

}

2047

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

2626

2048

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

2049

yield (name, special_settings[name]())

2050

except KeyError:

2051

yield (name, value)

2052

2053

tcp_server.clients.update(set(

2054

client_class(name = section,

2055

config= dict(client_config_items(

2056

client_config, section)))

2057

for section in client_config.sections()))

2652

2058

if not tcp_server.clients:

2653

2059

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("{}\n".format(pid).encode("utf-8"))

2661

except IOError:

2662

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

2663

pidfilename, pid)

2664

del pidfile

2060

2061

if not debug:

2062

try:

2063

with pidfile:

2064

pid = os.getpid()

2065

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

2066

del pidfile

2067

except IOError:

2068

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

2069

pidfilename, pid)

2070

except NameError:

2071

# "pidfile" was never created

2072

pass

2665

2073

del pidfilename

2074

2075

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

2666

2076

2667

2077

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

2668

2078

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

2669

2079

2670

2080

if use_dbus:

2671

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

2672

"se.bsnet.fukt.Mandos"})

2673

class MandosDBusService(DBusObjectWithProperties):

2081

class MandosDBusService(dbus.service.Object):

2674

2082

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

2675

2083

def __init__(self):

2676

2084

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

2677

2085

_interface = "se.recompile.Mandos"

2678

2086

2679

@dbus_interface_annotations(_interface)

2680

def _foo(self):

2681

return { "org.freedesktop.DBus.Property"

2682

".EmitsChangedSignal":

2683

"false"}

2684

2685

2087

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

2686

2088

def ClientAdded(self, objpath):

2687

2089

"D-Bus signal"

2701

2103

def GetAllClients(self):

2702

2104

"D-Bus method"

2703

2105

return dbus.Array(c.dbus_object_path

2704

for c in

2705

tcp_server.clients.itervalues())

2106

for c in tcp_server.clients)

2706

2107

2707

2108

@dbus.service.method(_interface,

2708

2109

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

2710

2111

"D-Bus method"

2711

2112

return dbus.Dictionary(

2712

2113

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

2713

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

2114

for c in tcp_server.clients),

2714

2115

signature="oa{sv}")

2715

2116

2716

2117

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

2717

2118

def RemoveClient(self, object_path):

2718

2119

"D-Bus method"

2719

for c in tcp_server.clients.itervalues():

2120

for c in tcp_server.clients:

2720

2121

if c.dbus_object_path == object_path:

2721

del tcp_server.clients[c.name]

2122

tcp_server.clients.remove(c)

2722

2123

c.remove_from_connection()

2723

2124

# Don't signal anything except ClientRemoved

2724

2125

c.disable(quiet=True)

2729

2130

2730

2131

del _interface

2731

2132

2732

mandos_dbus_service = MandosDBusService()

2133

class MandosDBusServiceTransitional(MandosDBusService):

2134

__metaclass__ = AlternateDBusNamesMetaclass

2135

mandos_dbus_service = MandosDBusServiceTransitional()

2733

2136

2734

2137

def cleanup():

2735

2138

"Cleanup function; run on exit"

2736

if zeroconf:

2737

service.cleanup()

2139

service.cleanup()

2738

2140

2739

2141

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

2795

2142

while tcp_server.clients:

2796

name, client = tcp_server.clients.popitem()

2143

client = tcp_server.clients.pop()

2797

2144

if use_dbus:

2798

2145

client.remove_from_connection()

2146

client.disable_hook = None

2799

2147

# Don't signal anything except ClientRemoved

2800

2148

client.disable(quiet=True)

2801

2149

if use_dbus:

2803

2151

mandos_dbus_service.ClientRemoved(client

2804

2152

.dbus_object_path,

2805

2153

client.name)

2806

client_settings.clear()

2807

2154

2808

2155

atexit.register(cleanup)

2809

2156

2810

for client in tcp_server.clients.itervalues():

2157

for client in tcp_server.clients:

2811

2158

if use_dbus:

2812

2159

# Emit D-Bus signal

2813

2160

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2814

# Need to initiate checking of clients

2815

if client.enabled:

2816

client.init_checker()

2161

client.enable()

2817

2162

2818

2163

tcp_server.enable()

2819

2164

tcp_server.server_activate()

2820

2165

2821

2166

# Find out what port we got

2822

if zeroconf:

2823

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

2167

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

2824

2168

if use_ipv6:

2825

2169

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

2826

" flowinfo %d, scope_id %d",

2827

*tcp_server.socket.getsockname())

2170

" flowinfo %d, scope_id %d"

2171

% tcp_server.socket.getsockname())

2828

2172

else: # IPv4

2829

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

2830

*tcp_server.socket.getsockname())

2173

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

2174

% tcp_server.socket.getsockname())

2831

2175

2832

2176

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

2833

2177

2834

2178

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

2179

# From the Avahi example code

2180

try:

2181

service.activate()

2182

except dbus.exceptions.DBusException as error:

2183

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

2184

cleanup()

2185

sys.exit(1)

2186

# End of Avahi example code

2844

2187

2845

2188

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

2846

2189

lambda *args, **kwargs:

2850

2193

logger.debug("Starting main loop")

2851

2194

main_loop.run()

2852

2195

except AvahiError as error:

2853

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

2196

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

2854

2197

cleanup()

2855

2198

sys.exit(1)

2856

2199

except KeyboardInterrupt:

2861

2204

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

2862

2205

cleanup()

2863

2206

2207

2864

2208

if __name__ == '__main__':

2865

2209

main()