/mandos/release : revision 237.7.281

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

2

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

3

#

4

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

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

28

# along with this program. If not, see

29

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

30

#

31

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

31

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

32

#

33

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

37

39

import SocketServer as socketserver

38

40

import socket

39

import optparse

41

import argparse

40

42

import datetime

41

43

import errno

42

44

import gnutls.crypto

62

64

import functools

63

65

import cPickle as pickle

64

66

import multiprocessing

67

import types

68

import binascii

69

import tempfile

70

import itertools

71

import collections

65

72

66

73

import dbus

67

74

import dbus.service

81

88

except ImportError:

82

89

SO_BINDTODEVICE = None

83

90

84

85

version = "1.2.3"

86

87

#logger = logging.getLogger('mandos')

88

logger = logging.Logger('mandos')

89

syslogger = (logging.handlers.SysLogHandler

90

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

91

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

92

syslogger.setFormatter(logging.Formatter

93

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

94

' %(message)s'))

95

logger.addHandler(syslogger)

96

97

console = logging.StreamHandler()

98

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

99

' %(levelname)s:'

100

' %(message)s'))

101

logger.addHandler(console)

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

102

224

103

225

class AvahiError(Exception):

104

226

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

105

227

self.value = value

106

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

107

def __unicode__(self):

108

return unicode(repr(self.value))

228

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

229

**kwargs)

109

230

110

231

class AvahiServiceError(AvahiError):

111

232

pass

122

243

Used to optionally bind to the specified interface.

123

244

name: string; Example: 'Mandos'

124

245

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

125

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

246

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

126

247

port: integer; what port to announce

127

248

TXT: list of strings; TXT record for the service

128

249

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

134

255

server: D-Bus Server

135

256

bus: dbus.SystemBus()

136

257

"""

258

137

259

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

138

260

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

139

261

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

151

273

self.group = None # our entry group

152

274

self.server = None

153

275

self.bus = bus

276

self.entry_group_state_changed_match = None

277

154

278

def rename(self):

155

279

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

156

280

if self.rename_count >= self.max_renames:

158

282

" after %i retries, exiting.",

159

283

self.rename_count)

160

284

raise AvahiServiceError("Too many renames")

161

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

285

self.name = str(self.server

286

.GetAlternativeServiceName(self.name))

162

287

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

163

288

self.name)

164

syslogger.setFormatter(logging.Formatter

165

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

166

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

167

% self.name))

168

289

self.remove()

169

290

try:

170

291

self.add()

171

except dbus.exceptions.DBusException, error:

172

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

292

except dbus.exceptions.DBusException as error:

293

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

173

294

self.cleanup()

174

295

os._exit(1)

175

296

self.rename_count += 1

297

176

298

def remove(self):

177

299

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

300

if self.entry_group_state_changed_match is not None:

301

self.entry_group_state_changed_match.remove()

302

self.entry_group_state_changed_match = None

178

303

if self.group is not None:

179

304

self.group.Reset()

305

180

306

def add(self):

181

307

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

308

self.remove()

182

309

if self.group is None:

183

310

self.group = dbus.Interface(

184

311

self.bus.get_object(avahi.DBUS_NAME,

185

312

self.server.EntryGroupNew()),

186

313

avahi.DBUS_INTERFACE_ENTRY_GROUP)

187

self.group.connect_to_signal('StateChanged',

188

self

189

.entry_group_state_changed)

314

self.entry_group_state_changed_match = (

315

self.group.connect_to_signal(

316

'StateChanged', self.entry_group_state_changed))

190

317

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

191

318

self.name, self.type)

192

319

self.group.AddService(

198

325

dbus.UInt16(self.port),

199

326

avahi.string_array_to_txt_array(self.TXT))

200

327

self.group.Commit()

328

201

329

def entry_group_state_changed(self, state, error):

202

330

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

203

331

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

209

337

self.rename()

210

338

elif state == avahi.ENTRY_GROUP_FAILURE:

211

339

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

212

unicode(error))

213

raise AvahiGroupError("State changed: %s"

214

% unicode(error))

340

str(error))

341

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

342

.format(error))

343

215

344

def cleanup(self):

216

345

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

217

346

if self.group is not None:

218

self.group.Free()

347

try:

348

self.group.Free()

349

except (dbus.exceptions.UnknownMethodException,

350

dbus.exceptions.DBusException):

351

pass

219

352

self.group = None

220

def server_state_changed(self, state):

353

self.remove()

354

355

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

221

356

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

222

357

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

223

if state == avahi.SERVER_COLLISION:

224

logger.error("Zeroconf server name collision")

225

self.remove()

358

bad_states = { avahi.SERVER_INVALID:

359

"Zeroconf server invalid",

360

avahi.SERVER_REGISTERING: None,

361

avahi.SERVER_COLLISION:

362

"Zeroconf server name collision",

363

avahi.SERVER_FAILURE:

364

"Zeroconf server failure" }

365

if state in bad_states:

366

if bad_states[state] is not None:

367

if error is None:

368

logger.error(bad_states[state])

369

else:

370

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

371

self.cleanup()

226

372

elif state == avahi.SERVER_RUNNING:

227

373

self.add()

374

else:

375

if error is None:

376

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

377

else:

378

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

379

228

380

def activate(self):

229

381

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

230

382

if self.server is None:

231

383

self.server = dbus.Interface(

232

384

self.bus.get_object(avahi.DBUS_NAME,

233

avahi.DBUS_PATH_SERVER),

385

avahi.DBUS_PATH_SERVER,

386

follow_name_owner_changes=True),

234

387

avahi.DBUS_INTERFACE_SERVER)

235

388

self.server.connect_to_signal("StateChanged",

236

389

self.server_state_changed)

237

390

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

238

391

239

392

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

240

404

class Client(object):

241

405

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

242

406

243

407

Attributes:

244

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

408

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

245

409

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

246

410

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

247

411

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

254

418

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

255

419

checker_initiator_tag: a gobject event source tag, or None

256

420

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

257

423

current_checker_command: string; current running checker_command

258

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

259

424

disable_initiator_tag: a gobject event source tag, or None

260

425

enabled: bool()

261

426

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

264

429

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

265

430

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

266

431

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

267

last_enabled: datetime.datetime(); (UTC)

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

268

436

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

269

437

D-Bus identifiers

270

438

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

271

439

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

272

440

until this client is disabled

441

extended_timeout: extra long timeout when secret has been sent

273

442

runtime_expansions: Allowed attributes for runtime expansion.

443

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

444

disabled, or None

445

server_settings: The server_settings dict from main()

274

446

"""

275

447

276

448

runtime_expansions = ("approval_delay", "approval_duration",

277

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

278

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

449

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

450

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

451

"last_approval_request", "last_checked_ok",

279

452

"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

}

280

463

281

464

@staticmethod

282

def _timedelta_to_milliseconds(td):

283

"Convert a datetime.timedelta() to milliseconds"

284

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

285

+ (td.seconds * 1000)

286

+ (td.microseconds // 1000))

287

288

def timeout_milliseconds(self):

289

"Return the 'timeout' attribute in milliseconds"

290

return self._timedelta_to_milliseconds(self.timeout)

291

292

def interval_milliseconds(self):

293

"Return the 'interval' attribute in milliseconds"

294

return self._timedelta_to_milliseconds(self.interval)

295

296

def approval_delay_milliseconds(self):

297

return self._timedelta_to_milliseconds(self.approval_delay)

298

299

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

300

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

301

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

302

attribute."""

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

303

512

self.name = name

304

if config is None:

305

config = {}

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

306

530

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

307

531

# Uppercase and remove spaces from fingerprint for later

308

532

# comparison purposes with return value from the fingerprint()

309

533

# function

310

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

311

.replace(" ", ""))

312

534

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

313

if "secret" in config:

314

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

315

elif "secfile" in config:

316

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

317

(config["secfile"])),

318

"rb") as secfile:

319

self.secret = secfile.read()

320

else:

321

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

322

% self.name)

323

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

324

self.created = datetime.datetime.utcnow()

325

self.enabled = False

326

self.last_approval_request = None

327

self.last_enabled = None

328

self.last_checked_ok = None

329

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

330

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

331

self.disable_hook = disable_hook

535

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

536

datetime.datetime.utcnow())

537

538

# attributes specific for this server instance

332

539

self.checker = None

333

540

self.checker_initiator_tag = None

334

541

self.disable_initiator_tag = None

335

542

self.checker_callback_tag = None

336

self.checker_command = config["checker"]

337

543

self.current_checker_command = None

338

self.last_connect = None

339

self._approved = None

340

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

341

True)

544

self.approved = None

342

545

self.approvals_pending = 0

343

self.approval_delay = string_to_delta(

344

config["approval_delay"])

345

self.approval_duration = string_to_delta(

346

config["approval_duration"])

347

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

546

self.changedstate = (multiprocessing_manager

547

.Condition(multiprocessing_manager

548

.Lock()))

549

self.client_structure = [attr for attr in

550

self.__dict__.iterkeys()

551

if not attr.startswith("_")]

552

self.client_structure.append("client_structure")

553

554

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

555

lambda obj:

556

isinstance(obj,

557

property)):

558

if not name.startswith("_"):

559

self.client_structure.append(name)

348

560

561

# Send notice to process children that client state has changed

349

562

def send_changedstate(self):

350

self.changedstate.acquire()

351

self.changedstate.notify_all()

352

self.changedstate.release()

353

563

with self.changedstate:

564

self.changedstate.notify_all()

565

354

566

def enable(self):

355

567

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

356

568

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

357

569

# Already enabled

358

570

return

359

self.send_changedstate()

571

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

572

self.enabled = True

360

573

self.last_enabled = datetime.datetime.utcnow()

361

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

362

# and every interval from then on.

363

self.checker_initiator_tag = (gobject.timeout_add

364

(self.interval_milliseconds(),

365

self.start_checker))

366

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

367

self.disable_initiator_tag = (gobject.timeout_add

368

(self.timeout_milliseconds(),

369

self.disable))

370

self.enabled = True

371

# Also start a new checker *right now*.

372

self.start_checker()

574

self.init_checker()

575

self.send_changedstate()

373

576

374

577

def disable(self, quiet=True):

375

578

"""Disable this client."""

376

579

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

377

580

return False

378

581

if not quiet:

379

self.send_changedstate()

380

if not quiet:

381

582

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

382

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

583

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

383

584

gobject.source_remove(self.disable_initiator_tag)

384

585

self.disable_initiator_tag = None

385

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

586

self.expires = None

587

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

386

588

gobject.source_remove(self.checker_initiator_tag)

387

589

self.checker_initiator_tag = None

388

590

self.stop_checker()

389

if self.disable_hook:

390

self.disable_hook(self)

391

591

self.enabled = False

592

if not quiet:

593

self.send_changedstate()

392

594

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

393

595

return False

394

596

395

597

def __del__(self):

396

self.disable_hook = None

397

598

self.disable()

398

599

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

399

619

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

400

620

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

401

621

self.checker_callback_tag = None

402

622

self.checker = None

403

623

if os.WIFEXITED(condition):

404

exitstatus = os.WEXITSTATUS(condition)

405

if exitstatus == 0:

624

self.last_checker_status = os.WEXITSTATUS(condition)

625

if self.last_checker_status == 0:

406

626

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

407

627

vars(self))

408

628

self.checked_ok()

410

630

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

411

631

vars(self))

412

632

else:

633

self.last_checker_status = -1

413

634

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

414

635

vars(self))

415

636

416

637

def checked_ok(self):

417

"""Bump up the timeout for this client.

418

419

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

420

alive and well.

421

"""

638

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

422

639

self.last_checked_ok = datetime.datetime.utcnow()

423

gobject.source_remove(self.disable_initiator_tag)

424

self.disable_initiator_tag = (gobject.timeout_add

425

(self.timeout_milliseconds(),

426

self.disable))

640

self.last_checker_status = 0

641

self.bump_timeout()

642

643

def bump_timeout(self, timeout=None):

644

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

645

if timeout is None:

646

timeout = self.timeout

647

if self.disable_initiator_tag is not None:

648

gobject.source_remove(self.disable_initiator_tag)

649

self.disable_initiator_tag = None

650

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

651

self.disable_initiator_tag = (gobject.timeout_add

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

654

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

427

655

428

656

def need_approval(self):

429

657

self.last_approval_request = datetime.datetime.utcnow()

434

662

If a checker already exists, leave it running and do

435

663

nothing."""

436

664

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

437

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

438

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

439

# client would inevitably timeout, since no checker would get

440

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

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

441

669

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

442

670

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

443

671

# should be.

445

673

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

446

674

try:

447

675

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

448

except (AttributeError, OSError), error:

449

if (isinstance(error, OSError)

450

and error.errno != errno.ECHILD):

451

raise error

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

452

681

else:

453

682

if pid:

454

683

logger.warning("Checker was a zombie")

457

686

self.current_checker_command)

458

687

# Start a new checker if needed

459

688

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 }

460

693

try:

461

# In case checker_command has exactly one % operator

462

command = self.checker_command % self.host

463

except TypeError:

464

# Escape attributes for the shell

465

escaped_attrs = dict(

466

(attr,

467

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

468

errors=

469

'replace')))

470

for attr in

471

self.runtime_expansions)

472

473

try:

474

command = self.checker_command % escaped_attrs

475

except TypeError, error:

476

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

477

' %s', self.checker_command, error)

478

return True # Try again later

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

479

699

self.current_checker_command = command

480

700

try:

481

701

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

484

704

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

485

705

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

486

706

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

487

715

self.checker = subprocess.Popen(command,

488

716

close_fds=True,

489

shell=True, cwd="/")

490

self.checker_callback_tag = (gobject.child_watch_add

491

(self.checker.pid,

492

self.checker_callback,

493

data=command))

494

# The checker may have completed before the gobject

495

# watch was added. Check for this.

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:

496

730

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

497

if pid:

498

gobject.source_remove(self.checker_callback_tag)

499

self.checker_callback(pid, status, command)

500

except OSError, error:

501

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

502

error)

731

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)

503

741

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

504

742

return True

505

743

512

750

return

513

751

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

514

752

try:

515

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

753

self.checker.terminate()

516

754

#time.sleep(0.5)

517

755

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

518

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

519

except OSError, error:

756

# self.checker.kill()

757

except OSError as error:

520

758

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

521

759

raise

522

760

self.checker = None

523

761

762

524

763

def dbus_service_property(dbus_interface, signature="v",

525

764

access="readwrite", byte_arrays=False):

526

765

"""Decorators for marking methods of a DBusObjectWithProperties to

537

776

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

538

777

if byte_arrays and signature != "ay":

539

778

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

540

" signature %r" % signature)

779

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

541

780

def decorator(func):

542

781

func._dbus_is_property = True

543

782

func._dbus_interface = dbus_interface

551

790

return decorator

552

791

553

792

793

def dbus_interface_annotations(dbus_interface):

794

"""Decorator for marking functions returning interface annotations

795

796

Usage:

797

798

@dbus_interface_annotations("org.example.Interface")

799

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

800

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

801

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

802

"false"}

803

"""

804

def decorator(func):

805

func._dbus_is_interface = True

806

func._dbus_interface = dbus_interface

807

func._dbus_name = dbus_interface

808

return func

809

return decorator

810

811

812

def dbus_annotations(annotations):

813

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

814

Usage:

815

816

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

817

"org.freedesktop.DBus.Property."

818

"EmitsChangedSignal": "false"})

819

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

820

access="r")

821

def Property_dbus_property(self):

822

return dbus.Boolean(False)

823

"""

824

def decorator(func):

825

func._dbus_annotations = annotations

826

return func

827

return decorator

828

829

554

830

class DBusPropertyException(dbus.exceptions.DBusException):

555

831

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

556

832

"""

557

def __unicode__(self):

558

return unicode(str(self))

559

833

pass

560

834

561

835

class DBusPropertyAccessException(DBusPropertyException):

562

836

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

572

846

573

847

class DBusObjectWithProperties(dbus.service.Object):

574

848

"""A D-Bus object with properties.

575

849

576

850

Classes inheriting from this can use the dbus_service_property

577

851

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

578

852

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

579

853

"""

580

854

581

855

@staticmethod

582

def _is_dbus_property(obj):

583

return getattr(obj, "_dbus_is_property", False)

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)

584

864

585

def _get_all_dbus_properties(self):

865

def _get_all_dbus_things(self, thing):

586

866

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

587

867

"""

588

return ((prop._dbus_name, prop)

589

for name, prop in

590

inspect.getmembers(self, self._is_dbus_property))

868

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

869

name),

870

athing.__get__(self))

871

for cls in self.__class__.__mro__

872

for name, athing in

873

inspect.getmembers(cls,

874

self._is_dbus_thing(thing)))

591

875

592

876

def _get_dbus_property(self, interface_name, property_name):

593

877

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

594

878

property with the specified name and interface.

595

879

"""

596

for name in (property_name,

597

property_name + "_dbus_property"):

598

prop = getattr(self, name, None)

599

if (prop is None

600

or not self._is_dbus_property(prop)

601

or prop._dbus_name != property_name

602

or (interface_name and prop._dbus_interface

603

and interface_name != prop._dbus_interface)):

604

continue

605

return prop

880

for cls in self.__class__.__mro__:

881

for name, value in (inspect.getmembers

882

(cls,

883

self._is_dbus_thing("property"))):

884

if (value._dbus_name == property_name

885

and value._dbus_interface == interface_name):

886

return value.__get__(self)

887

606

888

# No such property

607

889

raise DBusPropertyNotFound(self.dbus_object_path + ":"

608

890

+ interface_name + "."

632

914

# The byte_arrays option is not supported yet on

633

915

# signatures other than "ay".

634

916

if prop._dbus_signature != "ay":

635

raise ValueError

636

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

637

for byte in value))

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

638

922

prop(value)

639

923

640

924

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

642

926

def GetAll(self, interface_name):

643

927

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

644

928

standard.

645

929

646

930

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

647

931

"""

648

all = {}

649

for name, prop in self._get_all_dbus_properties():

932

properties = {}

933

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

650

934

if (interface_name

651

935

and interface_name != prop._dbus_interface):

652

936

# Interface non-empty but did not match

656

940

continue

657

941

value = prop()

658

942

if not hasattr(value, "variant_level"):

659

all[name] = value

943

properties[name] = value

660

944

continue

661

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

662

value.variant_level+1)

663

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

945

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

946

value.variant_level+1)

947

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

948

949

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

950

def PropertiesChanged(self, interface_name, changed_properties,

951

invalidated_properties):

952

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

953

standard.

954

"""

955

pass

664

956

665

957

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

666

958

out_signature="s",

667

959

path_keyword='object_path',

668

960

connection_keyword='connection')

669

961

def Introspect(self, object_path, connection):

670

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

962

"""Overloading of standard D-Bus method.

963

964

Inserts property tags and interface annotation tags.

671

965

"""

672

966

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

673

967

connection)

680

974

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

681

975

return e

682

976

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

977

# Add property tags

683

978

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

684

979

for name, prop

685

in self._get_all_dbus_properties()

980

in self._get_all_dbus_things("property")

686

981

if prop._dbus_interface

687

982

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

688

983

if_tag.appendChild(tag)

984

# Add annotation tags

985

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

986

for tag in if_tag.getElementsByTagName(typ):

987

annots = dict()

988

for name, prop in (self.

989

_get_all_dbus_things(typ)):

990

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

991

and prop._dbus_interface

992

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

993

annots.update(getattr

994

(prop,

995

"_dbus_annotations",

996

{}))

997

for name, value in annots.items():

998

ann_tag = document.createElement(

999

"annotation")

1000

ann_tag.setAttribute("name", name)

1001

ann_tag.setAttribute("value", value)

1002

tag.appendChild(ann_tag)

1003

# Add interface annotation tags

1004

for annotation, value in dict(

1005

itertools.chain.from_iterable(

1006

annotations().items()

1007

for name, annotations in

1008

self._get_all_dbus_things("interface")

1009

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

1010

)).items():

1011

ann_tag = document.createElement("annotation")

1012

ann_tag.setAttribute("name", annotation)

1013

ann_tag.setAttribute("value", value)

1014

if_tag.appendChild(ann_tag)

689

1015

# Add the names to the return values for the

690

1016

# "org.freedesktop.DBus.Properties" methods

691

1017

if (if_tag.getAttribute("name")

704

1030

xmlstring = document.toxml("utf-8")

705

1031

document.unlink()

706

1032

except (AttributeError, xml.dom.DOMException,

707

xml.parsers.expat.ExpatError), error:

1033

xml.parsers.expat.ExpatError) as error:

708

1034

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

709

error)

1035

exc_info=error)

710

1036

return xmlstring

711

1037

712

1038

1039

def datetime_to_dbus(dt, variant_level=0):

1040

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

1041

if dt is None:

1042

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

1043

return dbus.String(dt.isoformat(),

1044

variant_level=variant_level)

1045

1046

1047

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1048

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

1049

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

1050

interface names according to the "alt_interface_names" mapping.

1051

Usage:

1052

1053

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

1054

"net.example.AlternateInterface"})

1055

class SampleDBusObject(dbus.service.Object):

1056

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

1057

def SampleDBusMethod():

1058

pass

1059

1060

The above "SampleDBusMethod" on "SampleDBusObject" will be

1061

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

1062

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

1063

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

1064

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

1065

1066

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

1067

(from DBusObjectWithProperties) and interfaces (from the

1068

dbus_interface_annotations decorator).

1069

"""

1070

def wrapper(cls):

1071

for orig_interface_name, alt_interface_name in (

1072

alt_interface_names.items()):

1073

attr = {}

1074

interface_names = set()

1075

# Go though all attributes of the class

1076

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

1077

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

1078

# with the wrong interface name

1079

if (not hasattr(attribute, "_dbus_interface")

1080

or not attribute._dbus_interface

1081

.startswith(orig_interface_name)):

1082

continue

1083

# Create an alternate D-Bus interface name based on

1084

# the current name

1085

alt_interface = (attribute._dbus_interface

1086

.replace(orig_interface_name,

1087

alt_interface_name))

1088

interface_names.add(alt_interface)

1089

# Is this a D-Bus signal?

1090

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

1091

# Extract the original non-method undecorated

1092

# function by black magic

1093

nonmethod_func = (dict(

1094

zip(attribute.func_code.co_freevars,

1095

attribute.__closure__))["func"]

1096

.cell_contents)

1097

# Create a new, but exactly alike, function

1098

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

1099

# with the alternate D-Bus interface name

1100

new_function = (dbus.service.signal

1101

(alt_interface,

1102

attribute._dbus_signature)

1103

(types.FunctionType(

1104

nonmethod_func.func_code,

1105

nonmethod_func.func_globals,

1106

nonmethod_func.func_name,

1107

nonmethod_func.func_defaults,

1108

nonmethod_func.func_closure)))

1109

# Copy annotations, if any

1110

try:

1111

new_function._dbus_annotations = (

1112

dict(attribute._dbus_annotations))

1113

except AttributeError:

1114

pass

1115

# Define a creator of a function to call both the

1116

# original and alternate functions, so both the

1117

# original and alternate signals gets sent when

1118

# the function is called

1119

def fixscope(func1, func2):

1120

"""This function is a scope container to pass

1121

func1 and func2 to the "call_both" function

1122

outside of its arguments"""

1123

def call_both(*args, **kwargs):

1124

"""This function will emit two D-Bus

1125

signals by calling func1 and func2"""

1126

func1(*args, **kwargs)

1127

func2(*args, **kwargs)

1128

return call_both

1129

# Create the "call_both" function and add it to

1130

# the class

1131

attr[attrname] = fixscope(attribute, new_function)

1132

# Is this a D-Bus method?

1133

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

1134

# Create a new, but exactly alike, function

1135

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

1136

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

1137

# to the class.

1138

attr[attrname] = (dbus.service.method

1139

(alt_interface,

1140

attribute._dbus_in_signature,

1141

attribute._dbus_out_signature)

1142

(types.FunctionType

1143

(attribute.func_code,

1144

attribute.func_globals,

1145

attribute.func_name,

1146

attribute.func_defaults,

1147

attribute.func_closure)))

1148

# Copy annotations, if any

1149

try:

1150

attr[attrname]._dbus_annotations = (

1151

dict(attribute._dbus_annotations))

1152

except AttributeError:

1153

pass

1154

# Is this a D-Bus property?

1155

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

1156

# Create a new, but exactly alike, function

1157

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

1158

# property with the alternate D-Bus interface

1159

# name. Add it to the class.

1160

attr[attrname] = (dbus_service_property

1161

(alt_interface,

1162

attribute._dbus_signature,

1163

attribute._dbus_access,

1164

attribute

1165

._dbus_get_args_options

1166

["byte_arrays"])

1167

(types.FunctionType

1168

(attribute.func_code,

1169

attribute.func_globals,

1170

attribute.func_name,

1171

attribute.func_defaults,

1172

attribute.func_closure)))

1173

# Copy annotations, if any

1174

try:

1175

attr[attrname]._dbus_annotations = (

1176

dict(attribute._dbus_annotations))

1177

except AttributeError:

1178

pass

1179

# Is this a D-Bus interface?

1180

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

1181

# Create a new, but exactly alike, function

1182

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

1183

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

1184

# to the class.

1185

attr[attrname] = (dbus_interface_annotations

1186

(alt_interface)

1187

(types.FunctionType

1188

(attribute.func_code,

1189

attribute.func_globals,

1190

attribute.func_name,

1191

attribute.func_defaults,

1192

attribute.func_closure)))

1193

if deprecate:

1194

# Deprecate all alternate interfaces

1195

iname="_AlternateDBusNames_interface_annotation{}"

1196

for interface_name in interface_names:

1197

@dbus_interface_annotations(interface_name)

1198

def func(self):

1199

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

1200

"true" }

1201

# Find an unused name

1202

for aname in (iname.format(i)

1203

for i in itertools.count()):

1204

if aname not in attr:

1205

attr[aname] = func

1206

break

1207

if interface_names:

1208

# Replace the class with a new subclass of it with

1209

# methods, signals, etc. as created above.

1210

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

1211

(cls,), attr)

1212

return cls

1213

return wrapper

1214

1215

1216

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

1217

"se.bsnet.fukt.Mandos"})

713

1218

class ClientDBus(Client, DBusObjectWithProperties):

714

1219

"""A Client class using D-Bus

715

1220

721

1226

runtime_expansions = (Client.runtime_expansions

722

1227

+ ("dbus_object_path",))

723

1228

1229

_interface = "se.recompile.Mandos.Client"

1230

724

1231

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

725

1232

726

1233

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

727

self._approvals_pending = 0

728

1234

self.bus = bus

729

1235

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

730

1236

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

731

1237

# the D-Bus

732

client_object_name = unicode(self.name).translate(

1238

client_object_name = str(self.name).translate(

733

1239

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

734

1240

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

735

1241

self.dbus_object_path = (dbus.ObjectPath

736

1242

("/clients/" + client_object_name))

737

1243

DBusObjectWithProperties.__init__(self, self.bus,

738

1244

self.dbus_object_path)

739

740

def _get_approvals_pending(self):

741

return self._approvals_pending

742

def _set_approvals_pending(self, value):

743

old_value = self._approvals_pending

744

self._approvals_pending = value

745

bval = bool(value)

746

if (hasattr(self, "dbus_object_path")

747

and bval is not bool(old_value)):

748

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

749

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

750

dbus_bool)

751

752

approvals_pending = property(_get_approvals_pending,

753

_set_approvals_pending)

754

del _get_approvals_pending, _set_approvals_pending

755

756

@staticmethod

757

def _datetime_to_dbus(dt, variant_level=0):

758

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

759

return dbus.String(dt.isoformat(),

760

variant_level=variant_level)

761

762

def enable(self):

763

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

764

r = Client.enable(self)

765

if oldstate != self.enabled:

766

# Emit D-Bus signals

767

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

768

dbus.Boolean(True, variant_level=1))

769

self.PropertyChanged(

770

dbus.String("LastEnabled"),

771

self._datetime_to_dbus(self.last_enabled,

772

variant_level=1))

773

return r

774

775

def disable(self, quiet = False):

776

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

777

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

778

if not quiet and oldstate != self.enabled:

779

# Emit D-Bus signal

780

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

781

dbus.Boolean(False, variant_level=1))

782

return r

1245

1246

def notifychangeproperty(transform_func,

1247

dbus_name, type_func=lambda x: x,

1248

variant_level=1, invalidate_only=False,

1249

_interface=_interface):

1250

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

1251

its changes to DBus.

1252

1253

transform_fun: Function that takes a value and a variant_level

1254

and transforms it to a D-Bus type.

1255

dbus_name: D-Bus name of the variable

1256

type_func: Function that transform the value before sending it

1257

to the D-Bus. Default: no transform

1258

variant_level: D-Bus variant level. Default: 1

1259

"""

1260

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

1261

def setter(self, value):

1262

if hasattr(self, "dbus_object_path"):

1263

if (not hasattr(self, attrname) or

1264

type_func(getattr(self, attrname, None))

1265

!= type_func(value)):

1266

if invalidate_only:

1267

self.PropertiesChanged(_interface,

1268

dbus.Dictionary(),

1269

dbus.Array

1270

((dbus_name,)))

1271

else:

1272

dbus_value = transform_func(type_func(value),

1273

variant_level

1274

=variant_level)

1275

self.PropertyChanged(dbus.String(dbus_name),

1276

dbus_value)

1277

self.PropertiesChanged(_interface,

1278

dbus.Dictionary({

1279

dbus.String(dbus_name):

1280

dbus_value }), dbus.Array())

1281

setattr(self, attrname, value)

1282

1283

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

1284

1285

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1286

approvals_pending = notifychangeproperty(dbus.Boolean,

1287

"ApprovalPending",

1288

type_func = bool)

1289

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

1290

last_enabled = notifychangeproperty(datetime_to_dbus,

1291

"LastEnabled")

1292

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

1293

type_func = lambda checker:

1294

checker is not None)

1295

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1296

"LastCheckedOK")

1297

last_checker_status = notifychangeproperty(dbus.Int16,

1298

"LastCheckerStatus")

1299

last_approval_request = notifychangeproperty(

1300

datetime_to_dbus, "LastApprovalRequest")

1301

approved_by_default = notifychangeproperty(dbus.Boolean,

1302

"ApprovedByDefault")

1303

approval_delay = notifychangeproperty(dbus.UInt64,

1304

"ApprovalDelay",

1305

type_func =

1306

lambda td: td.total_seconds()

1307

* 1000)

1308

approval_duration = notifychangeproperty(

1309

dbus.UInt64, "ApprovalDuration",

1310

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

1311

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

1312

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

1313

type_func = lambda td:

1314

td.total_seconds() * 1000)

1315

extended_timeout = notifychangeproperty(

1316

dbus.UInt64, "ExtendedTimeout",

1317

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

1318

interval = notifychangeproperty(dbus.UInt64,

1319

"Interval",

1320

type_func =

1321

lambda td: td.total_seconds()

1322

* 1000)

1323

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

1324

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

1325

invalidate_only=True)

1326

1327

del notifychangeproperty

783

1328

784

1329

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

785

1330

try:

794

1339

*args, **kwargs):

795

1340

self.checker_callback_tag = None

796

1341

self.checker = None

797

# Emit D-Bus signal

798

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

799

dbus.Boolean(False, variant_level=1))

800

1342

if os.WIFEXITED(condition):

801

1343

exitstatus = os.WEXITSTATUS(condition)

802

1344

# Emit D-Bus signal

812

1354

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

813

1355

*args, **kwargs)

814

1356

815

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

816

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

817

# Emit D-Bus signal

818

self.PropertyChanged(

819

dbus.String("LastCheckedOK"),

820

(self._datetime_to_dbus(self.last_checked_ok,

821

variant_level=1)))

822

return r

823

824

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

825

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

826

# Emit D-Bus signal

827

self.PropertyChanged(

828

dbus.String("LastApprovalRequest"),

829

(self._datetime_to_dbus(self.last_approval_request,

830

variant_level=1)))

831

return r

832

833

1357

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

834

old_checker = self.checker

835

if self.checker is not None:

836

old_checker_pid = self.checker.pid

837

else:

838

old_checker_pid = None

1358

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

839

1359

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

840

1360

# Only if new checker process was started

841

1361

if (self.checker is not None

842

1362

and old_checker_pid != self.checker.pid):

843

1363

# Emit D-Bus signal

844

1364

self.CheckerStarted(self.current_checker_command)

845

self.PropertyChanged(

846

dbus.String("CheckerRunning"),

847

dbus.Boolean(True, variant_level=1))

848

1365

return r

849

1366

850

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

851

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

852

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

853

if (old_checker is not None

854

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

855

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

856

dbus.Boolean(False, variant_level=1))

857

return r

858

859

1367

def _reset_approved(self):

860

self._approved = None

1368

self.approved = None

861

1369

return False

862

1370

863

1371

def approve(self, value=True):

1372

self.approved = value

1373

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

1374

* 1000), self._reset_approved)

864

1375

self.send_changedstate()

865

self._approved = value

866

gobject.timeout_add(self._timedelta_to_milliseconds

867

(self.approval_duration),

868

self._reset_approved)

869

870

1376

871

1377

## D-Bus methods, signals & properties

872

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

1378

1379

## Interfaces

873

1380

874

1381

## Signals

875

1382

886

1393

pass

887

1394

888

1395

# PropertyChanged - signal

1396

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

889

1397

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

890

1398

def PropertyChanged(self, property, value):

891

1399

"D-Bus signal"

922

1430

# CheckedOK - method

923

1431

@dbus.service.method(_interface)

924

1432

def CheckedOK(self):

925

return self.checked_ok()

1433

self.checked_ok()

926

1434

927

1435

# Enable - method

928

1436

@dbus.service.method(_interface)

961

1469

if value is None: # get

962

1470

return dbus.Boolean(self.approved_by_default)

963

1471

self.approved_by_default = bool(value)

964

# Emit D-Bus signal

965

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

966

dbus.Boolean(value, variant_level=1))

967

1472

968

1473

# ApprovalDelay - property

969

1474

@dbus_service_property(_interface, signature="t",

970

1475

access="readwrite")

971

1476

def ApprovalDelay_dbus_property(self, value=None):

972

1477

if value is None: # get

973

return dbus.UInt64(self.approval_delay_milliseconds())

1478

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

1479

* 1000)

974

1480

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

975

# Emit D-Bus signal

976

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

977

dbus.UInt64(value, variant_level=1))

978

1481

979

1482

# ApprovalDuration - property

980

1483

@dbus_service_property(_interface, signature="t",

981

1484

access="readwrite")

982

1485

def ApprovalDuration_dbus_property(self, value=None):

983

1486

if value is None: # get

984

return dbus.UInt64(self._timedelta_to_milliseconds(

985

self.approval_duration))

1487

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

1488

* 1000)

986

1489

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

987

# Emit D-Bus signal

988

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

989

dbus.UInt64(value, variant_level=1))

990

1490

991

1491

# Name - property

992

1492

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

1004

1504

def Host_dbus_property(self, value=None):

1005

1505

if value is None: # get

1006

1506

return dbus.String(self.host)

1007

self.host = value

1008

# Emit D-Bus signal

1009

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

1010

dbus.String(value, variant_level=1))

1507

self.host = str(value)

1011

1508

1012

1509

# Created - property

1013

1510

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

1014

1511

def Created_dbus_property(self):

1015

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

1512

return datetime_to_dbus(self.created)

1016

1513

1017

1514

# LastEnabled - property

1018

1515

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

1019

1516

def LastEnabled_dbus_property(self):

1020

if self.last_enabled is None:

1021

return dbus.String("")

1022

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

1517

return datetime_to_dbus(self.last_enabled)

1023

1518

1024

1519

# Enabled - property

1025

1520

@dbus_service_property(_interface, signature="b",

1039

1534

if value is not None:

1040

1535

self.checked_ok()

1041

1536

return

1042

if self.last_checked_ok is None:

1043

return dbus.String("")

1044

return dbus.String(self._datetime_to_dbus(self

1045

.last_checked_ok))

1537

return datetime_to_dbus(self.last_checked_ok)

1538

1539

# LastCheckerStatus - property

1540

@dbus_service_property(_interface, signature="n",

1541

access="read")

1542

def LastCheckerStatus_dbus_property(self):

1543

return dbus.Int16(self.last_checker_status)

1544

1545

# Expires - property

1546

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

1547

def Expires_dbus_property(self):

1548

return datetime_to_dbus(self.expires)

1046

1549

1047

1550

# LastApprovalRequest - property

1048

1551

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

1049

1552

def LastApprovalRequest_dbus_property(self):

1050

if self.last_approval_request is None:

1051

return dbus.String("")

1052

return dbus.String(self.

1053

_datetime_to_dbus(self

1054

.last_approval_request))

1553

return datetime_to_dbus(self.last_approval_request)

1055

1554

1056

1555

# Timeout - property

1057

1556

@dbus_service_property(_interface, signature="t",

1058

1557

access="readwrite")

1059

1558

def Timeout_dbus_property(self, value=None):

1060

1559

if value is None: # get

1061

return dbus.UInt64(self.timeout_milliseconds())

1560

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

1561

old_timeout = self.timeout

1062

1562

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

1063

# Emit D-Bus signal

1064

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

1065

dbus.UInt64(value, variant_level=1))

1066

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

1067

return

1068

# Reschedule timeout

1069

gobject.source_remove(self.disable_initiator_tag)

1070

self.disable_initiator_tag = None

1071

time_to_die = (self.

1072

_timedelta_to_milliseconds((self

1073

.last_checked_ok

1074

+ self.timeout)

1075

- datetime.datetime

1076

.utcnow()))

1077

if time_to_die <= 0:

1078

# The timeout has passed

1079

self.disable()

1080

else:

1081

self.disable_initiator_tag = (gobject.timeout_add

1082

(time_to_die, self.disable))

1563

# Reschedule disabling

1564

if self.enabled:

1565

now = datetime.datetime.utcnow()

1566

self.expires += self.timeout - old_timeout

1567

if self.expires <= now:

1568

# The timeout has passed

1569

self.disable()

1570

else:

1571

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

1572

is None):

1573

return

1574

gobject.source_remove(self.disable_initiator_tag)

1575

self.disable_initiator_tag = (

1576

gobject.timeout_add(

1577

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

1578

* 1000), self.disable))

1579

1580

# ExtendedTimeout - property

1581

@dbus_service_property(_interface, signature="t",

1582

access="readwrite")

1583

def ExtendedTimeout_dbus_property(self, value=None):

1584

if value is None: # get

1585

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

1586

* 1000)

1587

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

1083

1588

1084

1589

# Interval - property

1085

1590

@dbus_service_property(_interface, signature="t",

1086

1591

access="readwrite")

1087

1592

def Interval_dbus_property(self, value=None):

1088

1593

if value is None: # get

1089

return dbus.UInt64(self.interval_milliseconds())

1594

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

1090

1595

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

1091

# Emit D-Bus signal

1092

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

1093

dbus.UInt64(value, variant_level=1))

1094

1596

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

1095

1597

return

1096

# Reschedule checker run

1097

gobject.source_remove(self.checker_initiator_tag)

1098

self.checker_initiator_tag = (gobject.timeout_add

1099

(value, self.start_checker))

1100

self.start_checker() # Start one now, too

1101

1598

if self.enabled:

1599

# Reschedule checker run

1600

gobject.source_remove(self.checker_initiator_tag)

1601

self.checker_initiator_tag = (gobject.timeout_add

1602

(value, self.start_checker))

1603

self.start_checker() # Start one now, too

1604

1102

1605

# Checker - property

1103

1606

@dbus_service_property(_interface, signature="s",

1104

1607

access="readwrite")

1105

1608

def Checker_dbus_property(self, value=None):

1106

1609

if value is None: # get

1107

1610

return dbus.String(self.checker_command)

1108

self.checker_command = value

1109

# Emit D-Bus signal

1110

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

1111

dbus.String(self.checker_command,

1112

variant_level=1))

1611

self.checker_command = str(value)

1113

1612

1114

1613

# CheckerRunning - property

1115

1614

@dbus_service_property(_interface, signature="b",

1131

1630

@dbus_service_property(_interface, signature="ay",

1132

1631

access="write", byte_arrays=True)

1133

1632

def Secret_dbus_property(self, value):

1134

self.secret = str(value)

1633

self.secret = bytes(value)

1135

1634

1136

1635

del _interface

1137

1636

1142

1641

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

1143

1642

if not self._pipe.recv():

1144

1643

raise KeyError()

1145

1644

1146

1645

def __getattribute__(self, name):

1147

if(name == '_pipe'):

1646

if name == '_pipe':

1148

1647

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

1149

1648

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

1150

1649

data = self._pipe.recv()

1155

1654

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

1156

1655

return self._pipe.recv()[1]

1157

1656

return func

1158

1657

1159

1658

def __setattr__(self, name, value):

1160

if(name == '_pipe'):

1659

if name == '_pipe':

1161

1660

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

1162

1661

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

1163

1662

1171

1670

def handle(self):

1172

1671

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

1173

1672

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

1174

unicode(self.client_address))

1673

str(self.client_address))

1175

1674

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

1176

1675

self.server.child_pipe.fileno())

1177

1676

1178

1677

session = (gnutls.connection

1179

1678

.ClientSession(self.request,

1180

1679

gnutls.connection

1181

1680

.X509Credentials()))

1182

1681

1183

1682

# Note: gnutls.connection.X509Credentials is really a

1184

1683

# generic GnuTLS certificate credentials object so long as

1185

1684

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

1186

1685

# here despite using OpenPGP certificates.

1187

1686

1188

1687

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

1189

1688

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

1190

1689

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

1196

1695

(gnutls.library.functions

1197

1696

.gnutls_priority_set_direct(session._c_object,

1198

1697

priority, None))

1199

1698

1200

1699

# Start communication using the Mandos protocol

1201

1700

# Get protocol number

1202

1701

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

1203

1702

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

1204

1703

try:

1205

1704

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

1206

raise RuntimeError

1207

except (ValueError, IndexError, RuntimeError), error:

1705

raise RuntimeError(line)

1706

except (ValueError, IndexError, RuntimeError) as error:

1208

1707

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

1209

1708

return

1210

1709

1211

1710

# Start GnuTLS connection

1212

1711

try:

1213

1712

session.handshake()

1214

except gnutls.errors.GNUTLSError, error:

1713

except gnutls.errors.GNUTLSError as error:

1215

1714

logger.warning("Handshake failed: %s", error)

1216

1715

# Do not run session.bye() here: the session is not

1217

1716

# established. Just abandon the request.

1218

1717

return

1219

1718

logger.debug("Handshake succeeded")

1220

1719

1221

1720

approval_required = False

1222

1721

try:

1223

1722

try:

1224

1723

fpr = self.fingerprint(self.peer_certificate

1225

1724

(session))

1226

except (TypeError, gnutls.errors.GNUTLSError), error:

1725

except (TypeError,

1726

gnutls.errors.GNUTLSError) as error:

1227

1727

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

1228

1728

return

1229

1729

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

1230

1730

1231

1731

try:

1232

1732

client = ProxyClient(child_pipe, fpr,

1233

1733

self.client_address)

1241

1741

1242

1742

while True:

1243

1743

if not client.enabled:

1244

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

1744

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

1245

1745

client.name)

1246

1746

if self.server.use_dbus:

1247

1747

# Emit D-Bus signal

1248

client.Rejected("Disabled")

1748

client.Rejected("Disabled")

1249

1749

return

1250

1750

1251

if client._approved or not client.approval_delay:

1751

if client.approved or not client.approval_delay:

1252

1752

#We are approved or approval is disabled

1253

1753

break

1254

elif client._approved is None:

1754

elif client.approved is None:

1255

1755

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

1256

1756

client.name)

1257

1757

if self.server.use_dbus:

1258

1758

# Emit D-Bus signal

1259

1759

client.NeedApproval(

1260

client.approval_delay_milliseconds(),

1261

client.approved_by_default)

1760

client.approval_delay.total_seconds()

1761

* 1000, client.approved_by_default)

1262

1762

else:

1263

1763

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

1264

1764

client.name)

1268

1768

return

1269

1769

1270

1770

#wait until timeout or approved

1271

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

1272

1771

time = datetime.datetime.now()

1273

1772

client.changedstate.acquire()

1274

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

1773

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

1275

1774

client.changedstate.release()

1276

1775

time2 = datetime.datetime.now()

1277

1776

if (time2 - time) >= delay:

1292

1791

while sent_size < len(client.secret):

1293

1792

try:

1294

1793

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

1295

except (gnutls.errors.GNUTLSError), error:

1296

logger.warning("gnutls send failed")

1794

except gnutls.errors.GNUTLSError as error:

1795

logger.warning("gnutls send failed",

1796

exc_info=error)

1297

1797

return

1298

1798

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

1299

1799

sent, len(client.secret)

1300

1800

- (sent_size + sent))

1301

1801

sent_size += sent

1302

1802

1303

1803

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

1304

# bump the timeout as if seen

1305

client.checked_ok()

1804

# bump the timeout using extended_timeout

1805

client.bump_timeout(client.extended_timeout)

1306

1806

if self.server.use_dbus:

1307

1807

# Emit D-Bus signal

1308

1808

client.GotSecret()

1312

1812

client.approvals_pending -= 1

1313

1813

try:

1314

1814

session.bye()

1315

except (gnutls.errors.GNUTLSError), error:

1316

logger.warning("GnuTLS bye failed")

1815

except gnutls.errors.GNUTLSError as error:

1816

logger.warning("GnuTLS bye failed",

1817

exc_info=error)

1317

1818

1318

1819

@staticmethod

1319

1820

def peer_certificate(session):

1375

1876

# Convert the buffer to a Python bytestring

1376

1877

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

1377

1878

# Convert the bytestring to hexadecimal notation

1378

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

1879

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

1379

1880

return hex_fpr

1380

1881

1381

1882

1384

1885

def sub_process_main(self, request, address):

1385

1886

try:

1386

1887

self.finish_request(request, address)

1387

except:

1888

except Exception:

1388

1889

self.handle_error(request, address)

1389

1890

self.close_request(request)

1390

1891

1391

1892

def process_request(self, request, address):

1392

1893

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

1393

multiprocessing.Process(target = self.sub_process_main,

1394

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

1894

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

1895

args = (request, address))

1896

proc.start()

1897

return proc

1898

1395

1899

1396

1900

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1397

1901

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

1401

1905

This function creates a new pipe in self.pipe

1402

1906

"""

1403

1907

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1404

1405

super(MultiprocessingMixInWithPipe,

1406

self).process_request(request, client_address)

1908

1909

proc = MultiprocessingMixIn.process_request(self, request,

1910

client_address)

1407

1911

self.child_pipe.close()

1408

self.add_pipe(parent_pipe)

1409

1410

def add_pipe(self, parent_pipe):

1912

self.add_pipe(parent_pipe, proc)

1913

1914

def add_pipe(self, parent_pipe, proc):

1411

1915

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

1412

raise NotImplementedError

1916

raise NotImplementedError()

1917

1413

1918

1414

1919

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1415

1920

socketserver.TCPServer, object):

1421

1926

use_ipv6: Boolean; to use IPv6 or not

1422

1927

"""

1423

1928

def __init__(self, server_address, RequestHandlerClass,

1424

interface=None, use_ipv6=True):

1929

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

1930

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

1931

creating a new one with socket.socket().

1932

"""

1425

1933

self.interface = interface

1426

1934

if use_ipv6:

1427

1935

self.address_family = socket.AF_INET6

1936

if socketfd is not None:

1937

# Save the file descriptor

1938

self.socketfd = socketfd

1939

# Save the original socket.socket() function

1940

self.socket_socket = socket.socket

1941

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

1942

#

1943

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

1944

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

1945

# patching socket.socket.)

1946

#

1947

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

1948

@functools.wraps(socket.socket)

1949

def socket_wrapper(*args, **kwargs):

1950

# Restore original function so subsequent calls are

1951

# not affected.

1952

socket.socket = self.socket_socket

1953

del self.socket_socket

1954

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

1955

# saved file descriptor.

1956

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

1957

# Replace socket.socket() function with wrapper

1958

socket.socket = socket_wrapper

1959

# The socketserver.TCPServer.__init__ will call

1960

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

1961

# socket_wrapper(), if socketfd was set.

1428

1962

socketserver.TCPServer.__init__(self, server_address,

1429

1963

RequestHandlerClass)

1964

1430

1965

def server_bind(self):

1431

1966

"""This overrides the normal server_bind() function

1432

1967

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

1440

1975

try:

1441

1976

self.socket.setsockopt(socket.SOL_SOCKET,

1442

1977

SO_BINDTODEVICE,

1443

str(self.interface

1444

+ '\0'))

1445

except socket.error, error:

1446

if error[0] == errno.EPERM:

1447

logger.error("No permission to"

1448

" bind to interface %s",

1449

self.interface)

1450

elif error[0] == errno.ENOPROTOOPT:

1978

(self.interface + "\0")

1979

.encode("utf-8"))

1980

except socket.error as error:

1981

if error.errno == errno.EPERM:

1982

logger.error("No permission to bind to"

1983

" interface %s", self.interface)

1984

elif error.errno == errno.ENOPROTOOPT:

1451

1985

logger.error("SO_BINDTODEVICE not available;"

1452

1986

" cannot bind to interface %s",

1453

1987

self.interface)

1988

elif error.errno == errno.ENODEV:

1989

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

1990

" cannot bind", self.interface)

1454

1991

else:

1455

1992

raise

1456

1993

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

1459

1996

if self.address_family == socket.AF_INET6:

1460

1997

any_address = "::" # in6addr_any

1461

1998

else:

1462

any_address = socket.INADDR_ANY

1999

any_address = "0.0.0.0" # INADDR_ANY

1463

2000

self.server_address = (any_address,

1464

2001

self.server_address[1])

1465

2002

elif not self.server_address[1]:

1486

2023

"""

1487

2024

def __init__(self, server_address, RequestHandlerClass,

1488

2025

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

1489

gnutls_priority=None, use_dbus=True):

2026

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

1490

2027

self.enabled = False

1491

2028

self.clients = clients

1492

2029

if self.clients is None:

1493

self.clients = set()

2030

self.clients = {}

1494

2031

self.use_dbus = use_dbus

1495

2032

self.gnutls_priority = gnutls_priority

1496

2033

IPv6_TCPServer.__init__(self, server_address,

1497

2034

RequestHandlerClass,

1498

2035

interface = interface,

1499

use_ipv6 = use_ipv6)

2036

use_ipv6 = use_ipv6,

2037

socketfd = socketfd)

1500

2038

def server_activate(self):

1501

2039

if self.enabled:

1502

2040

return socketserver.TCPServer.server_activate(self)

2041

1503

2042

def enable(self):

1504

2043

self.enabled = True

1505

def add_pipe(self, parent_pipe):

2044

2045

def add_pipe(self, parent_pipe, proc):

1506

2046

# Call "handle_ipc" for both data and EOF events

1507

2047

gobject.io_add_watch(parent_pipe.fileno(),

1508

2048

gobject.IO_IN | gobject.IO_HUP,

1509

2049

functools.partial(self.handle_ipc,

1510

parent_pipe = parent_pipe))

1511

2050

parent_pipe =

2051

parent_pipe,

2052

proc = proc))

2053

1512

2054

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

1513

client_object=None):

1514

condition_names = {

1515

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

1516

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

1517

# blocking).

1518

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

1519

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

1520

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

1521

# broken, usually for pipes and

1522

# sockets).

1523

}

1524

conditions_string = ' | '.join(name

1525

for cond, name in

1526

condition_names.iteritems()

1527

if cond & condition)

1528

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

1529

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

2055

proc = None, client_object=None):

2056

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

2057

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

2058

# Wait for other process to exit

2059

proc.join()

1530

2060

return False

1531

2061

1532

2062

# Read a request from the child

1537

2067

fpr = request[1]

1538

2068

address = request[2]

1539

2069

1540

for c in self.clients:

2070

for c in self.clients.itervalues():

1541

2071

if c.fingerprint == fpr:

1542

2072

client = c

1543

2073

break

1544

2074

else:

1545

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

1546

"dress: %s", fpr, address)

2075

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

2076

"dress: %s", fpr, address)

1547

2077

if self.use_dbus:

1548

2078

# Emit D-Bus signal

1549

mandos_dbus_service.ClientNotFound(fpr, address[0])

2079

mandos_dbus_service.ClientNotFound(fpr,

2080

address[0])

1550

2081

parent_pipe.send(False)

1551

2082

return False

1552

2083

1553

2084

gobject.io_add_watch(parent_pipe.fileno(),

1554

2085

gobject.IO_IN | gobject.IO_HUP,

1555

2086

functools.partial(self.handle_ipc,

1556

parent_pipe = parent_pipe,

1557

client_object = client))

2087

parent_pipe =

2088

parent_pipe,

2089

proc = proc,

2090

client_object =

2091

client))

1558

2092

parent_pipe.send(True)

1559

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

2093

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

2094

# same fileno

1560

2095

return False

1561

2096

if command == 'funcall':

1562

2097

funcname = request[1]

1563

2098

args = request[2]

1564

2099

kwargs = request[3]

1565

2100

1566

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

1567

2101

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

2102

funcname)(*args,

2103

**kwargs)))

2104

1568

2105

if command == 'getattr':

1569

2106

attrname = request[1]

1570

2107

if callable(client_object.__getattribute__(attrname)):

1571

2108

parent_pipe.send(('function',))

1572

2109

else:

1573

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

2110

parent_pipe.send(('data', client_object

2111

.__getattribute__(attrname)))

1574

2112

1575

2113

if command == 'setattr':

1576

2114

attrname = request[1]

1577

2115

value = request[2]

1578

2116

setattr(client_object, attrname, value)

1579

2117

1580

2118

return True

1581

2119

1582

2120

2121

def rfc3339_duration_to_delta(duration):

2122

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

2123

2124

>>> rfc3339_duration_to_delta("P7D")

2125

datetime.timedelta(7)

2126

>>> rfc3339_duration_to_delta("PT60S")

2127

datetime.timedelta(0, 60)

2128

>>> rfc3339_duration_to_delta("PT60M")

2129

datetime.timedelta(0, 3600)

2130

>>> rfc3339_duration_to_delta("PT24H")

2131

datetime.timedelta(1)

2132

>>> rfc3339_duration_to_delta("P1W")

2133

datetime.timedelta(7)

2134

>>> rfc3339_duration_to_delta("PT5M30S")

2135

datetime.timedelta(0, 330)

2136

>>> rfc3339_duration_to_delta("P1DT3M20S")

2137

datetime.timedelta(1, 200)

2138

"""

2139

2140

# Parsing an RFC 3339 duration with regular expressions is not

2141

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

2142

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

2143

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

2144

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

2145

# avoid excessive use of external libraries.

2146

2147

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

2148

Token = collections.namedtuple("Token",

2149

("regexp", # To match token; if

2150

# "value" is not None,

2151

# must have a "group"

2152

# containing digits

2153

"value", # datetime.timedelta or

2154

# None

2155

"followers")) # Tokens valid after

2156

# this token

2157

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

2158

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

2159

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

2160

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

2161

datetime.timedelta(seconds=1),

2162

frozenset((token_end,)))

2163

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

2164

datetime.timedelta(minutes=1),

2165

frozenset((token_second, token_end)))

2166

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

2167

datetime.timedelta(hours=1),

2168

frozenset((token_minute, token_end)))

2169

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

2170

None,

2171

frozenset((token_hour, token_minute,

2172

token_second)))

2173

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

2174

datetime.timedelta(days=1),

2175

frozenset((token_time, token_end)))

2176

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

2177

datetime.timedelta(weeks=4),

2178

frozenset((token_day, token_end)))

2179

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

2180

datetime.timedelta(weeks=52),

2181

frozenset((token_month, token_end)))

2182

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

2183

datetime.timedelta(weeks=1),

2184

frozenset((token_end,)))

2185

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

2186

frozenset((token_year, token_month,

2187

token_day, token_time,

2188

token_week)))

2189

# Define starting values

2190

value = datetime.timedelta() # Value so far

2191

found_token = None

2192

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

2193

s = duration # String left to parse

2194

# Loop until end token is found

2195

while found_token is not token_end:

2196

# Search for any currently valid tokens

2197

for token in followers:

2198

match = token.regexp.match(s)

2199

if match is not None:

2200

# Token found

2201

if token.value is not None:

2202

# Value found, parse digits

2203

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

2204

# Add to value so far

2205

value += factor * token.value

2206

# Strip token from string

2207

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

2208

# Go to found token

2209

found_token = token

2210

# Set valid next tokens

2211

followers = found_token.followers

2212

break

2213

else:

2214

# No currently valid tokens were found

2215

raise ValueError("Invalid RFC 3339 duration")

2216

# End token found

2217

return value

2218

2219

1583

2220

def string_to_delta(interval):

1584

2221

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

1585

2222

1596

2233

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

1597

2234

datetime.timedelta(0, 330)

1598

2235

"""

2236

2237

try:

2238

return rfc3339_duration_to_delta(interval)

2239

except ValueError:

2240

pass

2241

1599

2242

timevalue = datetime.timedelta(0)

1600

2243

for s in interval.split():

1601

2244

try:

1602

suffix = unicode(s[-1])

2245

suffix = s[-1]

1603

2246

value = int(s[:-1])

1604

2247

if suffix == "d":

1605

2248

delta = datetime.timedelta(value)

1612

2255

elif suffix == "w":

1613

2256

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

1614

2257

else:

1615

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

1616

except (ValueError, IndexError), e:

2258

raise ValueError("Unknown suffix {!r}"

2259

.format(suffix))

2260

except IndexError as e:

1617

2261

raise ValueError(*(e.args))

1618

2262

timevalue += delta

1619

2263

return timevalue

1620

2264

1621

2265

1622

def if_nametoindex(interface):

1623

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

1624

1625

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

1626

global if_nametoindex

1627

try:

1628

if_nametoindex = (ctypes.cdll.LoadLibrary

1629

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

1630

.if_nametoindex)

1631

except (OSError, AttributeError):

1632

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

1633

def if_nametoindex(interface):

1634

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

1635

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

1636

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

1637

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1638

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

1639

interface))

1640

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

1641

ifreq[16:20])[0]

1642

return interface_index

1643

return if_nametoindex(interface)

1644

1645

1646

2266

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

1647

2267

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

1648

2268

1656

2276

sys.exit()

1657

2277

if not noclose:

1658

2278

# Close all standard open file descriptors

1659

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

2279

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

1660

2280

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

1661

raise OSError(errno.ENODEV,

1662

"%s not a character device"

1663

% os.path.devnull)

2281

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

2282

.format(os.devnull))

1664

2283

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

1665

2284

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

1666

2285

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

1673

2292

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

1674

2293

# Parsing of options, both command line and config file

1675

2294

1676

parser = optparse.OptionParser(version = "%%prog %s" % version)

1677

parser.add_option("-i", "--interface", type="string",

1678

metavar="IF", help="Bind to interface IF")

1679

parser.add_option("-a", "--address", type="string",

1680

help="Address to listen for requests on")

1681

parser.add_option("-p", "--port", type="int",

1682

help="Port number to receive requests on")

1683

parser.add_option("--check", action="store_true",

1684

help="Run self-test")

1685

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

1686

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

1687

" terminal")

1688

parser.add_option("--debuglevel", type="string", metavar="LEVEL",

1689

help="Debug level for stdout output")

1690

parser.add_option("--priority", type="string", help="GnuTLS"

1691

" priority string (see GnuTLS documentation)")

1692

parser.add_option("--servicename", type="string",

1693

metavar="NAME", help="Zeroconf service name")

1694

parser.add_option("--configdir", type="string",

1695

default="/etc/mandos", metavar="DIR",

1696

help="Directory to search for configuration"

1697

" files")

1698

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

1699

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

1700

" system bus interface")

1701

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

1702

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

1703

options = parser.parse_args()[0]

2295

parser = argparse.ArgumentParser()

2296

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

2297

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

2298

help="show version number and exit")

2299

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

2300

help="Bind to interface IF")

2301

parser.add_argument("-a", "--address",

2302

help="Address to listen for requests on")

2303

parser.add_argument("-p", "--port", type=int,

2304

help="Port number to receive requests on")

2305

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

2306

help="Run self-test")

2307

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

2308

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

2309

" to terminal", default=None)

2310

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

2311

help="Debug level for stdout output")

2312

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

2313

" priority string (see GnuTLS documentation)")

2314

parser.add_argument("--servicename",

2315

metavar="NAME", help="Zeroconf service name")

2316

parser.add_argument("--configdir",

2317

default="/etc/mandos", metavar="DIR",

2318

help="Directory to search for configuration"

2319

" files")

2320

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

2321

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

2322

" system bus interface", default=None)

2323

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

2324

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

2325

default=None)

2326

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

2327

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

2328

" state", default=None)

2329

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

2330

help="Specify a file descriptor to a network"

2331

" socket to use instead of creating one")

2332

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

2333

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

2334

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

2335

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

2336

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

2337

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

2338

default=None)

2339

2340

options = parser.parse_args()

1704

2341

1705

2342

if options.check:

1706

2343

import doctest

1707

doctest.testmod()

1708

sys.exit()

2344

fail_count, test_count = doctest.testmod()

2345

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

1709

2346

1710

2347

# Default values for config file for server-global settings

1711

2348

server_defaults = { "interface": "",

1713

2350

"port": "",

1714

2351

"debug": "False",

1715

2352

"priority":

1716

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

2353

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

1717

2354

"servicename": "Mandos",

1718

2355

"use_dbus": "True",

1719

2356

"use_ipv6": "True",

1720

2357

"debuglevel": "",

2358

"restore": "True",

2359

"socket": "",

2360

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

2361

"foreground": "False",

2362

"zeroconf": "True",

1721

2363

}

1722

2364

1723

2365

# Parse config file for server-global settings

1728

2370

# Convert the SafeConfigParser object to a dict

1729

2371

server_settings = server_config.defaults()

1730

2372

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

1731

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

2373

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

1732

2374

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

1733

2375

option)

1734

2376

if server_settings["port"]:

1735

2377

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

1736

2378

"port")

2379

if server_settings["socket"]:

2380

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

2381

"socket")

2382

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

2383

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

2384

# happen with a supplied network socket.

2385

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

2386

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

2387

["socket"])

1737

2388

del server_config

1738

2389

1739

2390

# Override the settings from the config file with command line

1740

2391

# options, if set.

1741

2392

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

1742

2393

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

1743

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

2394

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

2395

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

1744

2396

value = getattr(options, option)

1745

2397

if value is not None:

1746

2398

server_settings[option] = value

1747

2399

del options

1748

2400

# Force all strings to be unicode

1749

2401

for option in server_settings.keys():

1750

if type(server_settings[option]) is str:

1751

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

2402

if isinstance(server_settings[option], bytes):

2403

server_settings[option] = (server_settings[option]

2404

.decode("utf-8"))

2405

# Force all boolean options to be boolean

2406

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

2407

"foreground", "zeroconf"):

2408

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

2409

# Debug implies foreground

2410

if server_settings["debug"]:

2411

server_settings["foreground"] = True

1752

2412

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

1753

2413

1754

2414

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

1755

2415

2416

if (not server_settings["zeroconf"] and

2417

not (server_settings["port"]

2418

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

2419

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

2420

" Zeroconf")

2421

1756

2422

# For convenience

1757

2423

debug = server_settings["debug"]

1758

2424

debuglevel = server_settings["debuglevel"]

1759

2425

use_dbus = server_settings["use_dbus"]

1760

2426

use_ipv6 = server_settings["use_ipv6"]

1761

2427

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

2428

stored_state_file)

2429

foreground = server_settings["foreground"]

2430

zeroconf = server_settings["zeroconf"]

2431

2432

if debug:

2433

initlogger(debug, logging.DEBUG)

2434

else:

2435

if not debuglevel:

2436

initlogger(debug)

2437

else:

2438

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

2439

initlogger(debug, level)

2440

1762

2441

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

1763

2442

syslogger.setFormatter(logging.Formatter

1764

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

1765

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

1766

% server_settings["servicename"]))

2443

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

2444

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

2445

.format(server_settings

2446

["servicename"])))

1767

2447

1768

2448

# Parse config file with clients

1769

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

1770

"interval": "5m",

1771

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

1772

"host": "",

1773

"approval_delay": "0s",

1774

"approval_duration": "1s",

1775

}

1776

client_config = configparser.SafeConfigParser(client_defaults)

2449

client_config = configparser.SafeConfigParser(Client

2450

.client_defaults)

1777

2451

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

1778

2452

"clients.conf"))

1779

2453

1780

2454

global mandos_dbus_service

1781

2455

mandos_dbus_service = None

1782

2456

2457

socketfd = None

2458

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

2459

socketfd = server_settings["socket"]

1783

2460

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

1784

2461

server_settings["port"]),

1785

2462

ClientHandler,

1788

2465

use_ipv6=use_ipv6,

1789

2466

gnutls_priority=

1790

2467

server_settings["priority"],

1791

use_dbus=use_dbus)

1792

if not debug:

1793

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

2468

use_dbus=use_dbus,

2469

socketfd=socketfd)

2470

if not foreground:

2471

pidfilename = "/run/mandos.pid"

2472

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

2473

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

2474

pidfile = None

1794

2475

try:

1795

2476

pidfile = open(pidfilename, "w")

1796

except IOError:

1797

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

2477

except IOError as e:

2478

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

2479

exc_info=e)

1798

2480

1799

try:

1800

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

1801

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

1802

except KeyError:

2481

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

1803

2482

try:

1804

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

1805

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

2483

uid = pwd.getpwnam(name).pw_uid

2484

gid = pwd.getpwnam(name).pw_gid

2485

break

1806

2486

except KeyError:

1807

try:

1808

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

1809

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

1810

except KeyError:

1811

uid = 65534

1812

gid = 65534

2487

continue

2488

else:

2489

uid = 65534

2490

gid = 65534

1813

2491

try:

1814

2492

os.setgid(gid)

1815

2493

os.setuid(uid)

1816

except OSError, error:

1817

if error[0] != errno.EPERM:

1818

raise error

2494

except OSError as error:

2495

if error.errno != errno.EPERM:

2496

raise

1819

2497

1820

if not debug and not debuglevel:

1821

syslogger.setLevel(logging.WARNING)

1822

console.setLevel(logging.WARNING)

1823

if debuglevel:

1824

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

1825

syslogger.setLevel(level)

1826

console.setLevel(level)

1827

1828

2498

if debug:

1829

2499

# Enable all possible GnuTLS debugging

1830

2500

1840

2510

.gnutls_global_set_log_function(debug_gnutls))

1841

2511

1842

2512

# Redirect stdin so all checkers get /dev/null

1843

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

2513

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

1844

2514

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

1845

2515

if null > 2:

1846

2516

os.close(null)

1847

else:

1848

# No console logging

1849

logger.removeHandler(console)

1850

2517

1851

2518

# Need to fork before connecting to D-Bus

1852

if not debug:

2519

if not foreground:

1853

2520

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

1854

2521

daemon()

1855

2522

2523

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

2524

# need to inform gobject that threads will be used.

2525

gobject.threads_init()

2526

1856

2527

global main_loop

1857

2528

# From the Avahi example code

1858

DBusGMainLoop(set_as_default=True )

2529

DBusGMainLoop(set_as_default=True)

1859

2530

main_loop = gobject.MainLoop()

1860

2531

bus = dbus.SystemBus()

1861

2532

# End of Avahi example code

1862

2533

if use_dbus:

1863

2534

try:

1864

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

2535

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

1865

2536

bus, do_not_queue=True)

1866

except dbus.exceptions.NameExistsException, e:

1867

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

2537

old_bus_name = (dbus.service.BusName

2538

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

2539

do_not_queue=True))

2540

except dbus.exceptions.NameExistsException as e:

2541

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

1868

2542

use_dbus = False

1869

2543

server_settings["use_dbus"] = False

1870

2544

tcp_server.use_dbus = False

1871

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1872

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

1873

servicetype = "_mandos._tcp",

1874

protocol = protocol, bus = bus)

1875

if server_settings["interface"]:

1876

service.interface = (if_nametoindex

1877

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

2545

if zeroconf:

2546

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2547

service = AvahiServiceToSyslog(name =

2548

server_settings["servicename"],

2549

servicetype = "_mandos._tcp",

2550

protocol = protocol, bus = bus)

2551

if server_settings["interface"]:

2552

service.interface = (if_nametoindex

2553

(server_settings["interface"]

2554

.encode("utf-8")))

1878

2555

1879

2556

global multiprocessing_manager

1880

2557

multiprocessing_manager = multiprocessing.Manager()

1882

2559

client_class = Client

1883

2560

if use_dbus:

1884

2561

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

1885

def client_config_items(config, section):

1886

special_settings = {

1887

"approved_by_default":

1888

lambda: config.getboolean(section,

1889

"approved_by_default"),

1890

}

1891

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

2562

2563

client_settings = Client.config_parser(client_config)

2564

old_client_settings = {}

2565

clients_data = {}

2566

2567

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

2568

global wnull

2569

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

2570

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

2571

# mode

2572

if debug or not foreground:

2573

wnull.close()

2574

2575

# Get client data and settings from last running state.

2576

if server_settings["restore"]:

2577

try:

2578

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

2579

clients_data, old_client_settings = (pickle.load

2580

(stored_state))

2581

os.remove(stored_state_path)

2582

except IOError as e:

2583

if e.errno == errno.ENOENT:

2584

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

2585

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

2586

else:

2587

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

2588

exc_info=e)

2589

raise

2590

except EOFError as e:

2591

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

2592

"EOFError:", exc_info=e)

2593

2594

with PGPEngine() as pgp:

2595

for client_name, client in clients_data.items():

2596

# Skip removed clients

2597

if client_name not in client_settings:

2598

continue

2599

2600

# Decide which value to use after restoring saved state.

2601

# We have three different values: Old config file,

2602

# new config file, and saved state.

2603

# New config value takes precedence if it differs from old

2604

# config value, otherwise use saved state.

2605

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

2606

try:

2607

# For each value in new config, check if it

2608

# differs from the old config value (Except for

2609

# the "secret" attribute)

2610

if (name != "secret" and

2611

value != old_client_settings[client_name]

2612

[name]):

2613

client[name] = value

2614

except KeyError:

2615

pass

2616

2617

# Clients who has passed its expire date can still be

2618

# enabled if its last checker was successful. Clients

2619

# whose checker succeeded before we stored its state is

2620

# assumed to have successfully run all checkers during

2621

# downtime.

2622

if client["enabled"]:

2623

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

2624

if not client["last_checked_ok"]:

2625

logger.warning(

2626

"disabling client {} - Client never "

2627

"performed a successful checker"

2628

.format(client_name))

2629

client["enabled"] = False

2630

elif client["last_checker_status"] != 0:

2631

logger.warning(

2632

"disabling client {} - Client last"

2633

" checker failed with error code {}"

2634

.format(client_name,

2635

client["last_checker_status"]))

2636

client["enabled"] = False

2637

else:

2638

client["expires"] = (datetime.datetime

2639

.utcnow()

2640

+ client["timeout"])

2641

logger.debug("Last checker succeeded,"

2642

" keeping {} enabled"

2643

.format(client_name))

1892

2644

try:

1893

yield (name, special_settings[name]())

1894

except KeyError:

1895

yield (name, value)

1896

1897

tcp_server.clients.update(set(

1898

client_class(name = section,

1899

config= dict(client_config_items(

1900

client_config, section)))

1901

for section in client_config.sections()))

2645

client["secret"] = (

2646

pgp.decrypt(client["encrypted_secret"],

2647

client_settings[client_name]

2648

["secret"]))

2649

except PGPError:

2650

# If decryption fails, we use secret from new settings

2651

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

2652

.format(client_name))

2653

client["secret"] = (

2654

client_settings[client_name]["secret"])

2655

2656

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

2657

for client_name in (set(old_client_settings)

2658

- set(client_settings)):

2659

del clients_data[client_name]

2660

for client_name in (set(client_settings)

2661

- set(old_client_settings)):

2662

clients_data[client_name] = client_settings[client_name]

2663

2664

# Create all client objects

2665

for client_name, client in clients_data.items():

2666

tcp_server.clients[client_name] = client_class(

2667

name = client_name, settings = client,

2668

server_settings = server_settings)

2669

1902

2670

if not tcp_server.clients:

1903

2671

logger.warning("No clients defined")

1904

1905

if not debug:

1906

try:

1907

with pidfile:

1908

pid = os.getpid()

1909

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

1910

del pidfile

1911

except IOError:

1912

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

1913

pidfilename, pid)

1914

except NameError:

1915

# "pidfile" was never created

1916

pass

2672

2673

if not foreground:

2674

if pidfile is not None:

2675

try:

2676

with pidfile:

2677

pid = os.getpid()

2678

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

2679

except IOError:

2680

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

2681

pidfilename, pid)

2682

del pidfile

1917

2683

del pidfilename

1918

1919

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

1920

2684

1921

2685

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

1922

2686

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

1923

2687

1924

2688

if use_dbus:

1925

class MandosDBusService(dbus.service.Object):

2689

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

2690

"se.bsnet.fukt.Mandos"})

2691

class MandosDBusService(DBusObjectWithProperties):

1926

2692

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

1927

2693

def __init__(self):

1928

2694

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

1929

_interface = "se.bsnet.fukt.Mandos"

2695

_interface = "se.recompile.Mandos"

2696

2697

@dbus_interface_annotations(_interface)

2698

def _foo(self):

2699

return { "org.freedesktop.DBus.Property"

2700

".EmitsChangedSignal":

2701

"false"}

1930

2702

1931

2703

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

1932

2704

def ClientAdded(self, objpath):

1947

2719

def GetAllClients(self):

1948

2720

"D-Bus method"

1949

2721

return dbus.Array(c.dbus_object_path

1950

for c in tcp_server.clients)

2722

for c in

2723

tcp_server.clients.itervalues())

1951

2724

1952

2725

@dbus.service.method(_interface,

1953

2726

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

1954

2727

def GetAllClientsWithProperties(self):

1955

2728

"D-Bus method"

1956

2729

return dbus.Dictionary(

1957

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

1958

for c in tcp_server.clients),

2730

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

2731

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

1959

2732

signature="oa{sv}")

1960

2733

1961

2734

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

1962

2735

def RemoveClient(self, object_path):

1963

2736

"D-Bus method"

1964

for c in tcp_server.clients:

2737

for c in tcp_server.clients.itervalues():

1965

2738

if c.dbus_object_path == object_path:

1966

tcp_server.clients.remove(c)

2739

del tcp_server.clients[c.name]

1967

2740

c.remove_from_connection()

1968

2741

# Don't signal anything except ClientRemoved

1969

2742

c.disable(quiet=True)

1978

2751

1979

2752

def cleanup():

1980

2753

"Cleanup function; run on exit"

1981

service.cleanup()

1982

2754

if zeroconf:

2755

service.cleanup()

2756

2757

multiprocessing.active_children()

2758

wnull.close()

2759

if not (tcp_server.clients or client_settings):

2760

return

2761

2762

# Store client before exiting. Secrets are encrypted with key

2763

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

2764

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

2765

clients = {}

2766

with PGPEngine() as pgp:

2767

for client in tcp_server.clients.itervalues():

2768

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

2769

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

2770

key)

2771

client_dict = {}

2772

2773

# A list of attributes that can not be pickled

2774

# + secret.

2775

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

2776

"checker", "server_settings" }

2777

for name, typ in (inspect.getmembers

2778

(dbus.service.Object)):

2779

exclude.add(name)

2780

2781

client_dict["encrypted_secret"] = (client

2782

.encrypted_secret)

2783

for attr in client.client_structure:

2784

if attr not in exclude:

2785

client_dict[attr] = getattr(client, attr)

2786

2787

clients[client.name] = client_dict

2788

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

2789

2790

try:

2791

with (tempfile.NamedTemporaryFile

2792

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

2793

dir=os.path.dirname(stored_state_path),

2794

delete=False)) as stored_state:

2795

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

2796

tempname=stored_state.name

2797

os.rename(tempname, stored_state_path)

2798

except (IOError, OSError) as e:

2799

if not debug:

2800

try:

2801

os.remove(tempname)

2802

except NameError:

2803

pass

2804

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

2805

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

2806

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

2807

else:

2808

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

2809

exc_info=e)

2810

raise

2811

2812

# Delete all clients, and settings from config

1983

2813

while tcp_server.clients:

1984

client = tcp_server.clients.pop()

2814

name, client = tcp_server.clients.popitem()

1985

2815

if use_dbus:

1986

2816

client.remove_from_connection()

1987

client.disable_hook = None

1988

2817

# Don't signal anything except ClientRemoved

1989

2818

client.disable(quiet=True)

1990

2819

if use_dbus:

1991

2820

# Emit D-Bus signal

1992

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2821

mandos_dbus_service.ClientRemoved(client

2822

.dbus_object_path,

1993

2823

client.name)

2824

client_settings.clear()

1994

2825

1995

2826

atexit.register(cleanup)

1996

2827

1997

for client in tcp_server.clients:

2828

for client in tcp_server.clients.itervalues():

1998

2829

if use_dbus:

1999

2830

# Emit D-Bus signal

2000

2831

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2001

client.enable()

2832

# Need to initiate checking of clients

2833

if client.enabled:

2834

client.init_checker()

2002

2835

2003

2836

tcp_server.enable()

2004

2837

tcp_server.server_activate()

2005

2838

2006

2839

# Find out what port we got

2007

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

2840

if zeroconf:

2841

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

2008

2842

if use_ipv6:

2009

2843

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

2010

" flowinfo %d, scope_id %d"

2011

% tcp_server.socket.getsockname())

2844

" flowinfo %d, scope_id %d",

2845

*tcp_server.socket.getsockname())

2012

2846

else: # IPv4

2013

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

2014

% tcp_server.socket.getsockname())

2847

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

2848

*tcp_server.socket.getsockname())

2015

2849

2016

2850

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

2017

2851

2018

2852

try:

2019

# From the Avahi example code

2020

try:

2021

service.activate()

2022

except dbus.exceptions.DBusException, error:

2023

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

2024

cleanup()

2025

sys.exit(1)

2026

# End of Avahi example code

2853

if zeroconf:

2854

# From the Avahi example code

2855

try:

2856

service.activate()

2857

except dbus.exceptions.DBusException as error:

2858

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

2859

cleanup()

2860

sys.exit(1)

2861

# End of Avahi example code

2027

2862

2028

2863

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

2029

2864

lambda *args, **kwargs:

2032

2867

2033

2868

logger.debug("Starting main loop")

2034

2869

main_loop.run()

2035

except AvahiError, error:

2036

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

2870

except AvahiError as error:

2871

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

2037

2872

cleanup()

2038

2873

sys.exit(1)

2039

2874

except KeyboardInterrupt: