/mandos/trunk : revision 482

1

#!/usr/bin/python2.7

1

#!/usr/bin/python

2

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

3

#

4

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

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

28

# along with this program. If not, see

29

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

30

#

31

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

31

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

32

#

33

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

64

62

import functools

65

63

import cPickle as pickle

66

64

import multiprocessing

67

import types

68

import binascii

69

import tempfile

70

import itertools

71

import collections

72

65

73

66

import dbus

74

67

import dbus.service

88

81

except ImportError:

89

82

SO_BINDTODEVICE = None

90

83

91

if sys.version_info.major == 2:

92

str = unicode

93

94

version = "1.6.9"

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

84

85

version = "1.3.0"

86

87

#logger = logging.getLogger('mandos')

88

logger = logging.Logger('mandos')

89

syslogger = (logging.handlers.SysLogHandler

90

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

91

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

92

syslogger.setFormatter(logging.Formatter

93

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

94

' %(message)s'))

95

logger.addHandler(syslogger)

96

97

console = logging.StreamHandler()

98

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

99

' %(levelname)s:'

100

' %(message)s'))

101

logger.addHandler(console)

224

102

225

103

class AvahiError(Exception):

226

104

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

227

105

self.value = value

228

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

229

**kwargs)

106

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

107

def __unicode__(self):

108

return unicode(repr(self.value))

230

109

231

110

class AvahiServiceError(AvahiError):

232

111

pass

243

122

Used to optionally bind to the specified interface.

244

123

name: string; Example: 'Mandos'

245

124

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

246

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

125

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

247

126

port: integer; what port to announce

248

127

TXT: list of strings; TXT record for the service

249

128

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

255

134

server: D-Bus Server

256

135

bus: dbus.SystemBus()

257

136

"""

258

259

137

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

260

138

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

261

139

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

274

152

self.server = None

275

153

self.bus = bus

276

154

self.entry_group_state_changed_match = None

277

278

def rename(self, remove=True):

155

def rename(self):

279

156

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

280

157

if self.rename_count >= self.max_renames:

281

158

logger.critical("No suitable Zeroconf service name found"

282

159

" after %i retries, exiting.",

283

160

self.rename_count)

284

161

raise AvahiServiceError("Too many renames")

285

self.name = str(self.server

286

.GetAlternativeServiceName(self.name))

287

self.rename_count += 1

162

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

288

163

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

289

164

self.name)

290

if remove:

291

self.remove()

165

syslogger.setFormatter(logging.Formatter

166

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

167

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

168

% self.name))

169

self.remove()

292

170

try:

293

171

self.add()

294

172

except dbus.exceptions.DBusException as error:

295

if (error.get_dbus_name()

296

== "org.freedesktop.Avahi.CollisionError"):

297

logger.info("Local Zeroconf service name collision.")

298

return self.rename(remove=False)

299

else:

300

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

301

self.cleanup()

302

os._exit(1)

303

173

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

174

self.cleanup()

175

os._exit(1)

176

self.rename_count += 1

304

177

def remove(self):

305

178

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

179

if self.group is not None:

180

try:

181

self.group.Free()

182

except (dbus.exceptions.UnknownMethodException,

183

dbus.exceptions.DBusException) as e:

184

pass

185

self.group = None

306

186

if self.entry_group_state_changed_match is not None:

307

187

self.entry_group_state_changed_match.remove()

308

188

self.entry_group_state_changed_match = None

309

if self.group is not None:

310

self.group.Reset()

311

312

189

def add(self):

313

190

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

314

191

self.remove()

315

if self.group is None:

316

self.group = dbus.Interface(

317

self.bus.get_object(avahi.DBUS_NAME,

318

self.server.EntryGroupNew()),

319

avahi.DBUS_INTERFACE_ENTRY_GROUP)

192

self.group = dbus.Interface(

193

self.bus.get_object(avahi.DBUS_NAME,

194

self.server.EntryGroupNew(),

195

follow_name_owner_changes=True),

196

avahi.DBUS_INTERFACE_ENTRY_GROUP)

320

197

self.entry_group_state_changed_match = (

321

198

self.group.connect_to_signal(

322

'StateChanged', self.entry_group_state_changed))

199

'StateChanged', self .entry_group_state_changed))

323

200

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

324

201

self.name, self.type)

325

202

self.group.AddService(

331

208

dbus.UInt16(self.port),

332

209

avahi.string_array_to_txt_array(self.TXT))

333

210

self.group.Commit()

334

335

211

def entry_group_state_changed(self, state, error):

336

212

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

337

213

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

343

219

self.rename()

344

220

elif state == avahi.ENTRY_GROUP_FAILURE:

345

221

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

346

str(error))

347

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

348

.format(error))

349

222

unicode(error))

223

raise AvahiGroupError("State changed: %s"

224

% unicode(error))

350

225

def cleanup(self):

351

226

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

352

if self.group is not None:

353

try:

354

self.group.Free()

355

except (dbus.exceptions.UnknownMethodException,

356

dbus.exceptions.DBusException):

357

pass

358

self.group = None

359

227

self.remove()

360

361

228

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

362

229

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

363

230

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

369

236

avahi.SERVER_FAILURE:

370

237

"Zeroconf server failure" }

371

238

if state in bad_states:

372

if bad_states[state] is not None:

373

if error is None:

374

logger.error(bad_states[state])

375

else:

376

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

377

self.cleanup()

239

if bad_states[state]:

240

logger.error(bad_states[state])

241

self.remove()

378

242

elif state == avahi.SERVER_RUNNING:

379

243

self.add()

380

244

else:

381

if error is None:

382

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

383

else:

384

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

385

245

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

386

246

def activate(self):

387

247

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

388

248

if self.server is None:

396

256

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

397

257

398

258

399

class AvahiServiceToSyslog(AvahiService):

400

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

401

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

402

ret = AvahiService.rename(self, *args, **kwargs)

403

syslogger.setFormatter(logging.Formatter

404

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

405

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

406

.format(self.name)))

407

return ret

408

409

410

259

class Client(object):

411

260

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

412

261

413

262

Attributes:

414

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

263

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

415

264

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

416

265

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

417

266

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

424

273

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

425

274

checker_initiator_tag: a gobject event source tag, or None

426

275

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

427

client_structure: Object describing what attributes a client has

428

and is used for storing the client at exit

429

276

current_checker_command: string; current running checker_command

277

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

430

278

disable_initiator_tag: a gobject event source tag, or None

431

279

enabled: bool()

432

280

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

435

283

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

436

284

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

437

285

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

438

last_checker_status: integer between 0 and 255 reflecting exit

439

status of last checker. -1 reflects crashed

440

checker, -2 means no checker completed yet.

441

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

286

last_enabled: datetime.datetime(); (UTC)

442

287

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

443

288

D-Bus identifiers

444

289

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

445

290

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

446

291

until this client is disabled

447

extended_timeout: extra long timeout when secret has been sent

448

292

runtime_expansions: Allowed attributes for runtime expansion.

449

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

450

disabled, or None

451

server_settings: The server_settings dict from main()

452

293

"""

453

294

454

295

runtime_expansions = ("approval_delay", "approval_duration",

455

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

456

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

457

"last_approval_request", "last_checked_ok",

296

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

297

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

458

298

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

459

client_defaults = { "timeout": "PT5M",

460

"extended_timeout": "PT15M",

461

"interval": "PT2M",

462

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

463

"host": "",

464

"approval_delay": "PT0S",

465

"approval_duration": "PT1S",

466

"approved_by_default": "True",

467

"enabled": "True",

468

}

469

299

470

300

@staticmethod

471

def config_parser(config):

472

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

473

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

474

with exceptions for any special settings as defined above.

475

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

476

value given the same arguments.

477

"""

478

settings = {}

479

for client_name in config.sections():

480

section = dict(config.items(client_name))

481

client = settings[client_name] = {}

482

483

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

484

# Reformat values from string types to Python types

485

client["approved_by_default"] = config.getboolean(

486

client_name, "approved_by_default")

487

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

488

"enabled")

489

490

# Uppercase and remove spaces from fingerprint for later

491

# comparison purposes with return value from the

492

# fingerprint() function

493

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

494

.replace(" ", ""))

495

if "secret" in section:

496

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

497

elif "secfile" in section:

498

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

499

(section["secfile"])),

500

"rb") as secfile:

501

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

502

else:

503

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

504

.format(section))

505

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

506

client["extended_timeout"] = string_to_delta(

507

section["extended_timeout"])

508

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

509

client["approval_delay"] = string_to_delta(

510

section["approval_delay"])

511

client["approval_duration"] = string_to_delta(

512

section["approval_duration"])

513

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

514

client["last_approval_request"] = None

515

client["last_checked_ok"] = None

516

client["last_checker_status"] = -2

517

518

return settings

519

520

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

301

def _timedelta_to_milliseconds(td):

302

"Convert a datetime.timedelta() to milliseconds"

303

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

304

+ (td.seconds * 1000)

305

+ (td.microseconds // 1000))

306

307

def timeout_milliseconds(self):

308

"Return the 'timeout' attribute in milliseconds"

309

return self._timedelta_to_milliseconds(self.timeout)

310

311

def interval_milliseconds(self):

312

"Return the 'interval' attribute in milliseconds"

313

return self._timedelta_to_milliseconds(self.interval)

314

315

def approval_delay_milliseconds(self):

316

return self._timedelta_to_milliseconds(self.approval_delay)

317

318

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

319

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

320

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

321

attribute."""

521

322

self.name = name

522

if server_settings is None:

523

server_settings = {}

524

self.server_settings = server_settings

525

# adding all client settings

526

for setting, value in settings.items():

527

setattr(self, setting, value)

528

529

if self.enabled:

530

if not hasattr(self, "last_enabled"):

531

self.last_enabled = datetime.datetime.utcnow()

532

if not hasattr(self, "expires"):

533

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

534

+ self.timeout)

535

else:

536

self.last_enabled = None

537

self.expires = None

538

323

if config is None:

324

config = {}

539

325

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

326

# Uppercase and remove spaces from fingerprint for later

327

# comparison purposes with return value from the fingerprint()

328

# function

329

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

330

.replace(" ", ""))

540

331

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

541

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

542

datetime.datetime.utcnow())

543

544

# attributes specific for this server instance

332

if "secret" in config:

333

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

334

elif "secfile" in config:

335

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

336

(config["secfile"])),

337

"rb") as secfile:

338

self.secret = secfile.read()

339

else:

340

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

341

% self.name)

342

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

343

self.created = datetime.datetime.utcnow()

344

self.enabled = False

345

self.last_approval_request = None

346

self.last_enabled = None

347

self.last_checked_ok = None

348

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

349

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

350

self.disable_hook = disable_hook

545

351

self.checker = None

546

352

self.checker_initiator_tag = None

547

353

self.disable_initiator_tag = None

548

354

self.checker_callback_tag = None

355

self.checker_command = config["checker"]

549

356

self.current_checker_command = None

550

self.approved = None

357

self.last_connect = None

358

self._approved = None

359

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

360

True)

551

361

self.approvals_pending = 0

552

self.changedstate = (multiprocessing_manager

553

.Condition(multiprocessing_manager

554

.Lock()))

555

self.client_structure = [attr for attr in

556

self.__dict__.iterkeys()

557

if not attr.startswith("_")]

558

self.client_structure.append("client_structure")

559

560

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

561

lambda obj:

562

isinstance(obj,

563

property)):

564

if not name.startswith("_"):

565

self.client_structure.append(name)

362

self.approval_delay = string_to_delta(

363

config["approval_delay"])

364

self.approval_duration = string_to_delta(

365

config["approval_duration"])

366

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

566

367

567

# Send notice to process children that client state has changed

568

368

def send_changedstate(self):

569

with self.changedstate:

570

self.changedstate.notify_all()

571

369

self.changedstate.acquire()

370

self.changedstate.notify_all()

371

self.changedstate.release()

372

572

373

def enable(self):

573

374

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

574

375

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

575

376

# Already enabled

576

377

return

577

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

578

self.enabled = True

378

self.send_changedstate()

579

379

self.last_enabled = datetime.datetime.utcnow()

580

self.init_checker()

581

self.send_changedstate()

380

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

381

# and every interval from then on.

382

self.checker_initiator_tag = (gobject.timeout_add

383

(self.interval_milliseconds(),

384

self.start_checker))

385

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

386

self.disable_initiator_tag = (gobject.timeout_add

387

(self.timeout_milliseconds(),

388

self.disable))

389

self.enabled = True

390

# Also start a new checker *right now*.

391

self.start_checker()

582

392

583

393

def disable(self, quiet=True):

584

394

"""Disable this client."""

585

395

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

586

396

return False

587

397

if not quiet:

398

self.send_changedstate()

399

if not quiet:

588

400

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

589

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

401

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

590

402

gobject.source_remove(self.disable_initiator_tag)

591

403

self.disable_initiator_tag = None

592

self.expires = None

593

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

404

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

594

405

gobject.source_remove(self.checker_initiator_tag)

595

406

self.checker_initiator_tag = None

596

407

self.stop_checker()

408

if self.disable_hook:

409

self.disable_hook(self)

597

410

self.enabled = False

598

if not quiet:

599

self.send_changedstate()

600

411

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

601

412

return False

602

413

603

414

def __del__(self):

415

self.disable_hook = None

604

416

self.disable()

605

417

606

def init_checker(self):

607

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

608

# and every interval from then on.

609

if self.checker_initiator_tag is not None:

610

gobject.source_remove(self.checker_initiator_tag)

611

self.checker_initiator_tag = (gobject.timeout_add

612

(int(self.interval

613

.total_seconds() * 1000),

614

self.start_checker))

615

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

616

if self.disable_initiator_tag is not None:

617

gobject.source_remove(self.disable_initiator_tag)

618

self.disable_initiator_tag = (gobject.timeout_add

619

(int(self.timeout

620

.total_seconds() * 1000),

621

self.disable))

622

# Also start a new checker *right now*.

623

self.start_checker()

624

625

418

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

626

419

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

627

420

self.checker_callback_tag = None

628

421

self.checker = None

629

422

if os.WIFEXITED(condition):

630

self.last_checker_status = os.WEXITSTATUS(condition)

631

if self.last_checker_status == 0:

423

exitstatus = os.WEXITSTATUS(condition)

424

if exitstatus == 0:

632

425

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

633

426

vars(self))

634

427

self.checked_ok()

636

429

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

637

430

vars(self))

638

431

else:

639

self.last_checker_status = -1

640

432

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

641

433

vars(self))

642

434

643

435

def checked_ok(self):

644

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

436

"""Bump up the timeout for this client.

437

438

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

439

alive and well.

440

"""

645

441

self.last_checked_ok = datetime.datetime.utcnow()

646

self.last_checker_status = 0

647

self.bump_timeout()

648

649

def bump_timeout(self, timeout=None):

650

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

651

if timeout is None:

652

timeout = self.timeout

653

if self.disable_initiator_tag is not None:

654

gobject.source_remove(self.disable_initiator_tag)

655

self.disable_initiator_tag = None

656

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

657

self.disable_initiator_tag = (gobject.timeout_add

658

(int(timeout.total_seconds()

659

* 1000), self.disable))

660

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

442

gobject.source_remove(self.disable_initiator_tag)

443

self.disable_initiator_tag = (gobject.timeout_add

444

(self.timeout_milliseconds(),

445

self.disable))

661

446

662

447

def need_approval(self):

663

448

self.last_approval_request = datetime.datetime.utcnow()

668

453

If a checker already exists, leave it running and do

669

454

nothing."""

670

455

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

671

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

672

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

673

# would inevitably timeout, since no checker would get a

674

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

456

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

457

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

458

# client would inevitably timeout, since no checker would get

459

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

675

460

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

676

461

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

677

462

# should be.

679

464

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

680

465

try:

681

466

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

682

except AttributeError:

683

pass

684

except OSError as error:

685

if error.errno != errno.ECHILD:

686

raise

467

except (AttributeError, OSError) as error:

468

if (isinstance(error, OSError)

469

and error.errno != errno.ECHILD):

470

raise error

687

471

else:

688

472

if pid:

689

473

logger.warning("Checker was a zombie")

692

476

self.current_checker_command)

693

477

# Start a new checker if needed

694

478

if self.checker is None:

695

# Escape attributes for the shell

696

escaped_attrs = { attr:

697

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

698

for attr in self.runtime_expansions }

699

479

try:

700

command = self.checker_command % escaped_attrs

701

except TypeError as error:

702

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

703

self.checker_command, exc_info=error)

704

return True # Try again later

480

# In case checker_command has exactly one % operator

481

command = self.checker_command % self.host

482

except TypeError:

483

# Escape attributes for the shell

484

escaped_attrs = dict(

485

(attr,

486

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

487

errors=

488

'replace')))

489

for attr in

490

self.runtime_expansions)

491

492

try:

493

command = self.checker_command % escaped_attrs

494

except TypeError as error:

495

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

496

' %s', self.checker_command, error)

497

return True # Try again later

705

498

self.current_checker_command = command

706

499

try:

707

500

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

710

503

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

711

504

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

712

505

# always replaced by /dev/null.)

713

# The exception is when not debugging but nevertheless

714

# running in the foreground; use the previously

715

# created wnull.

716

popen_args = {}

717

if (not self.server_settings["debug"]

718

and self.server_settings["foreground"]):

719

popen_args.update({"stdout": wnull,

720

"stderr": wnull })

721

506

self.checker = subprocess.Popen(command,

722

507

close_fds=True,

723

shell=True, cwd="/",

724

**popen_args)

725

except OSError as error:

726

logger.error("Failed to start subprocess",

727

exc_info=error)

728

return True

729

self.checker_callback_tag = (gobject.child_watch_add

730

(self.checker.pid,

731

self.checker_callback,

732

data=command))

733

# The checker may have completed before the gobject

734

# watch was added. Check for this.

735

try:

508

shell=True, cwd="/")

509

self.checker_callback_tag = (gobject.child_watch_add

510

(self.checker.pid,

511

self.checker_callback,

512

data=command))

513

# The checker may have completed before the gobject

514

# watch was added. Check for this.

736

515

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

516

if pid:

517

gobject.source_remove(self.checker_callback_tag)

518

self.checker_callback(pid, status, command)

737

519

except OSError as error:

738

if error.errno == errno.ECHILD:

739

# This should never happen

740

logger.error("Child process vanished",

741

exc_info=error)

742

return True

743

raise

744

if pid:

745

gobject.source_remove(self.checker_callback_tag)

746

self.checker_callback(pid, status, command)

520

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

521

error)

747

522

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

748

523

return True

749

524

756

531

return

757

532

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

758

533

try:

759

self.checker.terminate()

534

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

760

535

#time.sleep(0.5)

761

536

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

762

# self.checker.kill()

537

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

763

538

except OSError as error:

764

539

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

765

540

raise

766

541

self.checker = None

767

542

768

769

543

def dbus_service_property(dbus_interface, signature="v",

770

544

access="readwrite", byte_arrays=False):

771

545

"""Decorators for marking methods of a DBusObjectWithProperties to

782

556

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

783

557

if byte_arrays and signature != "ay":

784

558

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

785

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

559

" signature %r" % signature)

786

560

def decorator(func):

787

561

func._dbus_is_property = True

788

562

func._dbus_interface = dbus_interface

796

570

return decorator

797

571

798

572

799

def dbus_interface_annotations(dbus_interface):

800

"""Decorator for marking functions returning interface annotations

801

802

Usage:

803

804

@dbus_interface_annotations("org.example.Interface")

805

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

806

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

807

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

808

"false"}

809

"""

810

def decorator(func):

811

func._dbus_is_interface = True

812

func._dbus_interface = dbus_interface

813

func._dbus_name = dbus_interface

814

return func

815

return decorator

816

817

818

def dbus_annotations(annotations):

819

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

820

Usage:

821

822

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

823

"org.freedesktop.DBus.Property."

824

"EmitsChangedSignal": "false"})

825

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

826

access="r")

827

def Property_dbus_property(self):

828

return dbus.Boolean(False)

829

"""

830

def decorator(func):

831

func._dbus_annotations = annotations

832

return func

833

return decorator

834

835

836

573

class DBusPropertyException(dbus.exceptions.DBusException):

837

574

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

838

575

"""

839

pass

576

def __unicode__(self):

577

return unicode(str(self))

578

840

579

841

580

class DBusPropertyAccessException(DBusPropertyException):

842

581

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

852

591

853

592

class DBusObjectWithProperties(dbus.service.Object):

854

593

"""A D-Bus object with properties.

855

594

856

595

Classes inheriting from this can use the dbus_service_property

857

596

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

858

597

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

859

598

"""

860

599

861

600

@staticmethod

862

def _is_dbus_thing(thing):

863

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

864

865

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

866

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

867

"""

868

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

869

False)

601

def _is_dbus_property(obj):

602

return getattr(obj, "_dbus_is_property", False)

870

603

871

def _get_all_dbus_things(self, thing):

604

def _get_all_dbus_properties(self):

872

605

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

873

606

"""

874

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

875

name),

876

athing.__get__(self))

877

for cls in self.__class__.__mro__

878

for name, athing in

879

inspect.getmembers(cls,

880

self._is_dbus_thing(thing)))

607

return ((prop._dbus_name, prop)

608

for name, prop in

609

inspect.getmembers(self, self._is_dbus_property))

881

610

882

611

def _get_dbus_property(self, interface_name, property_name):

883

612

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

884

613

property with the specified name and interface.

885

614

"""

886

for cls in self.__class__.__mro__:

887

for name, value in (inspect.getmembers

888

(cls,

889

self._is_dbus_thing("property"))):

890

if (value._dbus_name == property_name

891

and value._dbus_interface == interface_name):

892

return value.__get__(self)

893

615

for name in (property_name,

616

property_name + "_dbus_property"):

617

prop = getattr(self, name, None)

618

if (prop is None

619

or not self._is_dbus_property(prop)

620

or prop._dbus_name != property_name

621

or (interface_name and prop._dbus_interface

622

and interface_name != prop._dbus_interface)):

623

continue

624

return prop

894

625

# No such property

895

626

raise DBusPropertyNotFound(self.dbus_object_path + ":"

896

627

+ interface_name + "."

920

651

# The byte_arrays option is not supported yet on

921

652

# signatures other than "ay".

922

653

if prop._dbus_signature != "ay":

923

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

924

"'ay' signature {!r}"

925

.format(prop._dbus_signature))

926

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

927

for byte in value))

654

raise ValueError

655

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

656

for byte in value))

928

657

prop(value)

929

658

930

659

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

932

661

def GetAll(self, interface_name):

933

662

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

934

663

standard.

935

664

936

665

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

937

666

"""

938

properties = {}

939

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

667

all = {}

668

for name, prop in self._get_all_dbus_properties():

940

669

if (interface_name

941

670

and interface_name != prop._dbus_interface):

942

671

# Interface non-empty but did not match

946

675

continue

947

676

value = prop()

948

677

if not hasattr(value, "variant_level"):

949

properties[name] = value

678

all[name] = value

950

679

continue

951

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

952

value.variant_level+1)

953

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

954

955

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

956

def PropertiesChanged(self, interface_name, changed_properties,

957

invalidated_properties):

958

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

959

standard.

960

"""

961

pass

680

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

681

value.variant_level+1)

682

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

962

683

963

684

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

964

685

out_signature="s",

965

686

path_keyword='object_path',

966

687

connection_keyword='connection')

967

688

def Introspect(self, object_path, connection):

968

"""Overloading of standard D-Bus method.

969

970

Inserts property tags and interface annotation tags.

689

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

971

690

"""

972

691

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

973

692

connection)

980

699

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

981

700

return e

982

701

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

983

# Add property tags

984

702

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

985

703

for name, prop

986

in self._get_all_dbus_things("property")

704

in self._get_all_dbus_properties()

987

705

if prop._dbus_interface

988

706

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

989

707

if_tag.appendChild(tag)

990

# Add annotation tags

991

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

992

for tag in if_tag.getElementsByTagName(typ):

993

annots = dict()

994

for name, prop in (self.

995

_get_all_dbus_things(typ)):

996

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

997

and prop._dbus_interface

998

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

999

annots.update(getattr

1000

(prop,

1001

"_dbus_annotations",

1002

{}))

1003

for name, value in annots.items():

1004

ann_tag = document.createElement(

1005

"annotation")

1006

ann_tag.setAttribute("name", name)

1007

ann_tag.setAttribute("value", value)

1008

tag.appendChild(ann_tag)

1009

# Add interface annotation tags

1010

for annotation, value in dict(

1011

itertools.chain.from_iterable(

1012

annotations().items()

1013

for name, annotations in

1014

self._get_all_dbus_things("interface")

1015

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

1016

)).items():

1017

ann_tag = document.createElement("annotation")

1018

ann_tag.setAttribute("name", annotation)

1019

ann_tag.setAttribute("value", value)

1020

if_tag.appendChild(ann_tag)

1021

708

# Add the names to the return values for the

1022

709

# "org.freedesktop.DBus.Properties" methods

1023

710

if (if_tag.getAttribute("name")

1038

725

except (AttributeError, xml.dom.DOMException,

1039

726

xml.parsers.expat.ExpatError) as error:

1040

727

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

1041

exc_info=error)

728

error)

1042

729

return xmlstring

1043

730

1044

731

1045

def datetime_to_dbus(dt, variant_level=0):

1046

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

1047

if dt is None:

1048

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

1049

return dbus.String(dt.isoformat(),

1050

variant_level=variant_level)

1051

1052

1053

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1054

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

1055

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

1056

interface names according to the "alt_interface_names" mapping.

1057

Usage:

1058

1059

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

1060

"net.example.AlternateInterface"})

1061

class SampleDBusObject(dbus.service.Object):

1062

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

1063

def SampleDBusMethod():

1064

pass

1065

1066

The above "SampleDBusMethod" on "SampleDBusObject" will be

1067

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

1068

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

1069

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

1070

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

1071

1072

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

1073

(from DBusObjectWithProperties) and interfaces (from the

1074

dbus_interface_annotations decorator).

1075

"""

1076

def wrapper(cls):

1077

for orig_interface_name, alt_interface_name in (

1078

alt_interface_names.items()):

1079

attr = {}

1080

interface_names = set()

1081

# Go though all attributes of the class

1082

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

1083

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

1084

# with the wrong interface name

1085

if (not hasattr(attribute, "_dbus_interface")

1086

or not attribute._dbus_interface

1087

.startswith(orig_interface_name)):

1088

continue

1089

# Create an alternate D-Bus interface name based on

1090

# the current name

1091

alt_interface = (attribute._dbus_interface

1092

.replace(orig_interface_name,

1093

alt_interface_name))

1094

interface_names.add(alt_interface)

1095

# Is this a D-Bus signal?

1096

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

1097

# Extract the original non-method undecorated

1098

# function by black magic

1099

nonmethod_func = (dict(

1100

zip(attribute.func_code.co_freevars,

1101

attribute.__closure__))["func"]

1102

.cell_contents)

1103

# Create a new, but exactly alike, function

1104

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

1105

# with the alternate D-Bus interface name

1106

new_function = (dbus.service.signal

1107

(alt_interface,

1108

attribute._dbus_signature)

1109

(types.FunctionType(

1110

nonmethod_func.func_code,

1111

nonmethod_func.func_globals,

1112

nonmethod_func.func_name,

1113

nonmethod_func.func_defaults,

1114

nonmethod_func.func_closure)))

1115

# Copy annotations, if any

1116

try:

1117

new_function._dbus_annotations = (

1118

dict(attribute._dbus_annotations))

1119

except AttributeError:

1120

pass

1121

# Define a creator of a function to call both the

1122

# original and alternate functions, so both the

1123

# original and alternate signals gets sent when

1124

# the function is called

1125

def fixscope(func1, func2):

1126

"""This function is a scope container to pass

1127

func1 and func2 to the "call_both" function

1128

outside of its arguments"""

1129

def call_both(*args, **kwargs):

1130

"""This function will emit two D-Bus

1131

signals by calling func1 and func2"""

1132

func1(*args, **kwargs)

1133

func2(*args, **kwargs)

1134

return call_both

1135

# Create the "call_both" function and add it to

1136

# the class

1137

attr[attrname] = fixscope(attribute, new_function)

1138

# Is this a D-Bus method?

1139

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

1140

# Create a new, but exactly alike, function

1141

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

1142

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

1143

# to the class.

1144

attr[attrname] = (dbus.service.method

1145

(alt_interface,

1146

attribute._dbus_in_signature,

1147

attribute._dbus_out_signature)

1148

(types.FunctionType

1149

(attribute.func_code,

1150

attribute.func_globals,

1151

attribute.func_name,

1152

attribute.func_defaults,

1153

attribute.func_closure)))

1154

# Copy annotations, if any

1155

try:

1156

attr[attrname]._dbus_annotations = (

1157

dict(attribute._dbus_annotations))

1158

except AttributeError:

1159

pass

1160

# Is this a D-Bus property?

1161

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

1162

# Create a new, but exactly alike, function

1163

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

1164

# property with the alternate D-Bus interface

1165

# name. Add it to the class.

1166

attr[attrname] = (dbus_service_property

1167

(alt_interface,

1168

attribute._dbus_signature,

1169

attribute._dbus_access,

1170

attribute

1171

._dbus_get_args_options

1172

["byte_arrays"])

1173

(types.FunctionType

1174

(attribute.func_code,

1175

attribute.func_globals,

1176

attribute.func_name,

1177

attribute.func_defaults,

1178

attribute.func_closure)))

1179

# Copy annotations, if any

1180

try:

1181

attr[attrname]._dbus_annotations = (

1182

dict(attribute._dbus_annotations))

1183

except AttributeError:

1184

pass

1185

# Is this a D-Bus interface?

1186

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

1187

# Create a new, but exactly alike, function

1188

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

1189

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

1190

# to the class.

1191

attr[attrname] = (dbus_interface_annotations

1192

(alt_interface)

1193

(types.FunctionType

1194

(attribute.func_code,

1195

attribute.func_globals,

1196

attribute.func_name,

1197

attribute.func_defaults,

1198

attribute.func_closure)))

1199

if deprecate:

1200

# Deprecate all alternate interfaces

1201

iname="_AlternateDBusNames_interface_annotation{}"

1202

for interface_name in interface_names:

1203

@dbus_interface_annotations(interface_name)

1204

def func(self):

1205

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

1206

"true" }

1207

# Find an unused name

1208

for aname in (iname.format(i)

1209

for i in itertools.count()):

1210

if aname not in attr:

1211

attr[aname] = func

1212

break

1213

if interface_names:

1214

# Replace the class with a new subclass of it with

1215

# methods, signals, etc. as created above.

1216

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

1217

(cls,), attr)

1218

return cls

1219

return wrapper

1220

1221

1222

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

1223

"se.bsnet.fukt.Mandos"})

1224

732

class ClientDBus(Client, DBusObjectWithProperties):

1225

733

"""A Client class using D-Bus

1226

734

1232

740

runtime_expansions = (Client.runtime_expansions

1233

741

+ ("dbus_object_path",))

1234

742

1235

_interface = "se.recompile.Mandos.Client"

1236

1237

743

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

1238

744

1239

745

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

746

self._approvals_pending = 0

1240

747

self.bus = bus

1241

748

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

1242

749

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

1243

750

# the D-Bus

1244

client_object_name = str(self.name).translate(

751

client_object_name = unicode(self.name).translate(

1245

752

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

1246

753

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

1247

754

self.dbus_object_path = (dbus.ObjectPath

1248

755

("/clients/" + client_object_name))

1249

756

DBusObjectWithProperties.__init__(self, self.bus,

1250

757

self.dbus_object_path)

1251

1252

def notifychangeproperty(transform_func,

1253

dbus_name, type_func=lambda x: x,

1254

variant_level=1, invalidate_only=False,

1255

_interface=_interface):

1256

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

1257

its changes to DBus.

1258

1259

transform_fun: Function that takes a value and a variant_level

1260

and transforms it to a D-Bus type.

1261

dbus_name: D-Bus name of the variable

1262

type_func: Function that transform the value before sending it

1263

to the D-Bus. Default: no transform

1264

variant_level: D-Bus variant level. Default: 1

1265

"""

1266

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

1267

def setter(self, value):

1268

if hasattr(self, "dbus_object_path"):

1269

if (not hasattr(self, attrname) or

1270

type_func(getattr(self, attrname, None))

1271

!= type_func(value)):

1272

if invalidate_only:

1273

self.PropertiesChanged(_interface,

1274

dbus.Dictionary(),

1275

dbus.Array

1276

((dbus_name,)))

1277

else:

1278

dbus_value = transform_func(type_func(value),

1279

variant_level

1280

=variant_level)

1281

self.PropertyChanged(dbus.String(dbus_name),

1282

dbus_value)

1283

self.PropertiesChanged(_interface,

1284

dbus.Dictionary({

1285

dbus.String(dbus_name):

1286

dbus_value }), dbus.Array())

1287

setattr(self, attrname, value)

1288

1289

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

1290

1291

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1292

approvals_pending = notifychangeproperty(dbus.Boolean,

1293

"ApprovalPending",

1294

type_func = bool)

1295

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

1296

last_enabled = notifychangeproperty(datetime_to_dbus,

1297

"LastEnabled")

1298

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

1299

type_func = lambda checker:

1300

checker is not None)

1301

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1302

"LastCheckedOK")

1303

last_checker_status = notifychangeproperty(dbus.Int16,

1304

"LastCheckerStatus")

1305

last_approval_request = notifychangeproperty(

1306

datetime_to_dbus, "LastApprovalRequest")

1307

approved_by_default = notifychangeproperty(dbus.Boolean,

1308

"ApprovedByDefault")

1309

approval_delay = notifychangeproperty(dbus.UInt64,

1310

"ApprovalDelay",

1311

type_func =

1312

lambda td: td.total_seconds()

1313

* 1000)

1314

approval_duration = notifychangeproperty(

1315

dbus.UInt64, "ApprovalDuration",

1316

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

1317

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

1318

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

1319

type_func = lambda td:

1320

td.total_seconds() * 1000)

1321

extended_timeout = notifychangeproperty(

1322

dbus.UInt64, "ExtendedTimeout",

1323

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

1324

interval = notifychangeproperty(dbus.UInt64,

1325

"Interval",

1326

type_func =

1327

lambda td: td.total_seconds()

1328

* 1000)

1329

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

1330

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

1331

invalidate_only=True)

1332

1333

del notifychangeproperty

758

759

def _get_approvals_pending(self):

760

return self._approvals_pending

761

def _set_approvals_pending(self, value):

762

old_value = self._approvals_pending

763

self._approvals_pending = value

764

bval = bool(value)

765

if (hasattr(self, "dbus_object_path")

766

and bval is not bool(old_value)):

767

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

768

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

769

dbus_bool)

770

771

approvals_pending = property(_get_approvals_pending,

772

_set_approvals_pending)

773

del _get_approvals_pending, _set_approvals_pending

774

775

@staticmethod

776

def _datetime_to_dbus(dt, variant_level=0):

777

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

778

return dbus.String(dt.isoformat(),

779

variant_level=variant_level)

780

781

def enable(self):

782

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

783

r = Client.enable(self)

784

if oldstate != self.enabled:

785

# Emit D-Bus signals

786

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

787

dbus.Boolean(True, variant_level=1))

788

self.PropertyChanged(

789

dbus.String("LastEnabled"),

790

self._datetime_to_dbus(self.last_enabled,

791

variant_level=1))

792

return r

793

794

def disable(self, quiet = False):

795

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

796

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

797

if not quiet and oldstate != self.enabled:

798

# Emit D-Bus signal

799

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

800

dbus.Boolean(False, variant_level=1))

801

return r

1334

802

1335

803

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

1336

804

try:

1345

813

*args, **kwargs):

1346

814

self.checker_callback_tag = None

1347

815

self.checker = None

816

# Emit D-Bus signal

817

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

818

dbus.Boolean(False, variant_level=1))

1348

819

if os.WIFEXITED(condition):

1349

820

exitstatus = os.WEXITSTATUS(condition)

1350

821

# Emit D-Bus signal

1360

831

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

1361

832

*args, **kwargs)

1362

833

834

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

835

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

836

# Emit D-Bus signal

837

self.PropertyChanged(

838

dbus.String("LastCheckedOK"),

839

(self._datetime_to_dbus(self.last_checked_ok,

840

variant_level=1)))

841

842

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

843

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

844

# Emit D-Bus signal

845

self.PropertyChanged(

846

dbus.String("LastApprovalRequest"),

847

(self._datetime_to_dbus(self.last_approval_request,

848

variant_level=1)))

849

return r

850

1363

851

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

1364

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

852

old_checker = self.checker

853

if self.checker is not None:

854

old_checker_pid = self.checker.pid

855

else:

856

old_checker_pid = None

1365

857

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

1366

858

# Only if new checker process was started

1367

859

if (self.checker is not None

1368

860

and old_checker_pid != self.checker.pid):

1369

861

# Emit D-Bus signal

1370

862

self.CheckerStarted(self.current_checker_command)

863

self.PropertyChanged(

864

dbus.String("CheckerRunning"),

865

dbus.Boolean(True, variant_level=1))

1371

866

return r

1372

867

868

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

869

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

870

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

871

if (old_checker is not None

872

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

873

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

874

dbus.Boolean(False, variant_level=1))

875

return r

876

1373

877

def _reset_approved(self):

1374

self.approved = None

878

self._approved = None

1375

879

return False

1376

880

1377

881

def approve(self, value=True):

1378

self.approved = value

1379

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

1380

* 1000), self._reset_approved)

1381

882

self.send_changedstate()

883

self._approved = value

884

gobject.timeout_add(self._timedelta_to_milliseconds

885

(self.approval_duration),

886

self._reset_approved)

887

1382

888

1383

889

## D-Bus methods, signals & properties

1384

1385

## Interfaces

890

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

1386

891

1387

892

## Signals

1388

893

1399

904

pass

1400

905

1401

906

# PropertyChanged - signal

1402

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

1403

907

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

1404

908

def PropertyChanged(self, property, value):

1405

909

"D-Bus signal"

1475

979

if value is None: # get

1476

980

return dbus.Boolean(self.approved_by_default)

1477

981

self.approved_by_default = bool(value)

982

# Emit D-Bus signal

983

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

984

dbus.Boolean(value, variant_level=1))

1478

985

1479

986

# ApprovalDelay - property

1480

987

@dbus_service_property(_interface, signature="t",

1481

988

access="readwrite")

1482

989

def ApprovalDelay_dbus_property(self, value=None):

1483

990

if value is None: # get

1484

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

1485

* 1000)

991

return dbus.UInt64(self.approval_delay_milliseconds())

1486

992

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

993

# Emit D-Bus signal

994

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

995

dbus.UInt64(value, variant_level=1))

1487

996

1488

997

# ApprovalDuration - property

1489

998

@dbus_service_property(_interface, signature="t",

1490

999

access="readwrite")

1491

1000

def ApprovalDuration_dbus_property(self, value=None):

1492

1001

if value is None: # get

1493

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

1494

* 1000)

1002

return dbus.UInt64(self._timedelta_to_milliseconds(

1003

self.approval_duration))

1495

1004

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

1005

# Emit D-Bus signal

1006

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

1007

dbus.UInt64(value, variant_level=1))

1496

1008

1497

1009

# Name - property

1498

1010

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

1510

1022

def Host_dbus_property(self, value=None):

1511

1023

if value is None: # get

1512

1024

return dbus.String(self.host)

1513

self.host = str(value)

1025

self.host = value

1026

# Emit D-Bus signal

1027

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

1028

dbus.String(value, variant_level=1))

1514

1029

1515

1030

# Created - property

1516

1031

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

1517

1032

def Created_dbus_property(self):

1518

return datetime_to_dbus(self.created)

1033

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

1519

1034

1520

1035

# LastEnabled - property

1521

1036

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

1522

1037

def LastEnabled_dbus_property(self):

1523

return datetime_to_dbus(self.last_enabled)

1038

if self.last_enabled is None:

1039

return dbus.String("")

1040

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

1524

1041

1525

1042

# Enabled - property

1526

1043

@dbus_service_property(_interface, signature="b",

1540

1057

if value is not None:

1541

1058

self.checked_ok()

1542

1059

return

1543

return datetime_to_dbus(self.last_checked_ok)

1544

1545

# LastCheckerStatus - property

1546

@dbus_service_property(_interface, signature="n",

1547

access="read")

1548

def LastCheckerStatus_dbus_property(self):

1549

return dbus.Int16(self.last_checker_status)

1550

1551

# Expires - property

1552

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

1553

def Expires_dbus_property(self):

1554

return datetime_to_dbus(self.expires)

1060

if self.last_checked_ok is None:

1061

return dbus.String("")

1062

return dbus.String(self._datetime_to_dbus(self

1063

.last_checked_ok))

1555

1064

1556

1065

# LastApprovalRequest - property

1557

1066

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

1558

1067

def LastApprovalRequest_dbus_property(self):

1559

return datetime_to_dbus(self.last_approval_request)

1068

if self.last_approval_request is None:

1069

return dbus.String("")

1070

return dbus.String(self.

1071

_datetime_to_dbus(self

1072

.last_approval_request))

1560

1073

1561

1074

# Timeout - property

1562

1075

@dbus_service_property(_interface, signature="t",

1563

1076

access="readwrite")

1564

1077

def Timeout_dbus_property(self, value=None):

1565

1078

if value is None: # get

1566

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

1567

old_timeout = self.timeout

1079

return dbus.UInt64(self.timeout_milliseconds())

1568

1080

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

1569

# Reschedule disabling

1570

if self.enabled:

1571

now = datetime.datetime.utcnow()

1572

self.expires += self.timeout - old_timeout

1573

if self.expires <= now:

1574

# The timeout has passed

1575

self.disable()

1576

else:

1577

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

1578

is None):

1579

return

1580

gobject.source_remove(self.disable_initiator_tag)

1581

self.disable_initiator_tag = (

1582

gobject.timeout_add(

1583

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

1584

* 1000), self.disable))

1585

1586

# ExtendedTimeout - property

1587

@dbus_service_property(_interface, signature="t",

1588

access="readwrite")

1589

def ExtendedTimeout_dbus_property(self, value=None):

1590

if value is None: # get

1591

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

1592

* 1000)

1593

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

1081

# Emit D-Bus signal

1082

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

1083

dbus.UInt64(value, variant_level=1))

1084

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

1085

return

1086

# Reschedule timeout

1087

gobject.source_remove(self.disable_initiator_tag)

1088

self.disable_initiator_tag = None

1089

time_to_die = (self.

1090

_timedelta_to_milliseconds((self

1091

.last_checked_ok

1092

+ self.timeout)

1093

- datetime.datetime

1094

.utcnow()))

1095

if time_to_die <= 0:

1096

# The timeout has passed

1097

self.disable()

1098

else:

1099

self.disable_initiator_tag = (gobject.timeout_add

1100

(time_to_die, self.disable))

1594

1101

1595

1102

# Interval - property

1596

1103

@dbus_service_property(_interface, signature="t",

1597

1104

access="readwrite")

1598

1105

def Interval_dbus_property(self, value=None):

1599

1106

if value is None: # get

1600

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

1107

return dbus.UInt64(self.interval_milliseconds())

1601

1108

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

1109

# Emit D-Bus signal

1110

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

1111

dbus.UInt64(value, variant_level=1))

1602

1112

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

1603

1113

return

1604

if self.enabled:

1605

# Reschedule checker run

1606

gobject.source_remove(self.checker_initiator_tag)

1607

self.checker_initiator_tag = (gobject.timeout_add

1608

(value, self.start_checker))

1609

self.start_checker() # Start one now, too

1610

1114

# Reschedule checker run

1115

gobject.source_remove(self.checker_initiator_tag)

1116

self.checker_initiator_tag = (gobject.timeout_add

1117

(value, self.start_checker))

1118

self.start_checker() # Start one now, too

1119

1611

1120

# Checker - property

1612

1121

@dbus_service_property(_interface, signature="s",

1613

1122

access="readwrite")

1614

1123

def Checker_dbus_property(self, value=None):

1615

1124

if value is None: # get

1616

1125

return dbus.String(self.checker_command)

1617

self.checker_command = str(value)

1126

self.checker_command = value

1127

# Emit D-Bus signal

1128

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

1129

dbus.String(self.checker_command,

1130

variant_level=1))

1618

1131

1619

1132

# CheckerRunning - property

1620

1133

@dbus_service_property(_interface, signature="b",

1636

1149

@dbus_service_property(_interface, signature="ay",

1637

1150

access="write", byte_arrays=True)

1638

1151

def Secret_dbus_property(self, value):

1639

self.secret = bytes(value)

1152

self.secret = str(value)

1640

1153

1641

1154

del _interface

1642

1155

1647

1160

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

1648

1161

if not self._pipe.recv():

1649

1162

raise KeyError()

1650

1163

1651

1164

def __getattribute__(self, name):

1652

if name == '_pipe':

1165

if(name == '_pipe'):

1653

1166

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

1654

1167

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

1655

1168

data = self._pipe.recv()

1660

1173

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

1661

1174

return self._pipe.recv()[1]

1662

1175

return func

1663

1176

1664

1177

def __setattr__(self, name, value):

1665

if name == '_pipe':

1178

if(name == '_pipe'):

1666

1179

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

1667

1180

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

1668

1181

1676

1189

def handle(self):

1677

1190

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

1678

1191

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

1679

str(self.client_address))

1192

unicode(self.client_address))

1680

1193

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

1681

1194

self.server.child_pipe.fileno())

1682

1195

1683

1196

session = (gnutls.connection

1684

1197

.ClientSession(self.request,

1685

1198

gnutls.connection

1686

1199

.X509Credentials()))

1687

1200

1688

1201

# Note: gnutls.connection.X509Credentials is really a

1689

1202

# generic GnuTLS certificate credentials object so long as

1690

1203

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

1691

1204

# here despite using OpenPGP certificates.

1692

1205

1693

1206

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

1694

1207

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

1695

1208

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

1701

1214

(gnutls.library.functions

1702

1215

.gnutls_priority_set_direct(session._c_object,

1703

1216

priority, None))

1704

1217

1705

1218

# Start communication using the Mandos protocol

1706

1219

# Get protocol number

1707

1220

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

1708

1221

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

1709

1222

try:

1710

1223

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

1711

raise RuntimeError(line)

1224

raise RuntimeError

1712

1225

except (ValueError, IndexError, RuntimeError) as error:

1713

1226

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

1714

1227

return

1715

1228

1716

1229

# Start GnuTLS connection

1717

1230

try:

1718

1231

session.handshake()

1722

1235

# established. Just abandon the request.

1723

1236

return

1724

1237

logger.debug("Handshake succeeded")

1725

1238

1726

1239

approval_required = False

1727

1240

try:

1728

1241

try:

1733

1246

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

1734

1247

return

1735

1248

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

1736

1249

1737

1250

try:

1738

1251

client = ProxyClient(child_pipe, fpr,

1739

1252

self.client_address)

1747

1260

1748

1261

while True:

1749

1262

if not client.enabled:

1750

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

1263

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

1751

1264

client.name)

1752

1265

if self.server.use_dbus:

1753

1266

# Emit D-Bus signal

1754

client.Rejected("Disabled")

1267

client.Rejected("Disabled")

1755

1268

return

1756

1269

1757

if client.approved or not client.approval_delay:

1270

if client._approved or not client.approval_delay:

1758

1271

#We are approved or approval is disabled

1759

1272

break

1760

elif client.approved is None:

1273

elif client._approved is None:

1761

1274

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

1762

1275

client.name)

1763

1276

if self.server.use_dbus:

1764

1277

# Emit D-Bus signal

1765

1278

client.NeedApproval(

1766

client.approval_delay.total_seconds()

1767

* 1000, client.approved_by_default)

1279

client.approval_delay_milliseconds(),

1280

client.approved_by_default)

1768

1281

else:

1769

1282

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

1770

1283

client.name)

1774

1287

return

1775

1288

1776

1289

#wait until timeout or approved

1290

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

1777

1291

time = datetime.datetime.now()

1778

1292

client.changedstate.acquire()

1779

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

1293

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

1780

1294

client.changedstate.release()

1781

1295

time2 = datetime.datetime.now()

1782

1296

if (time2 - time) >= delay:

1798

1312

try:

1799

1313

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

1800

1314

except gnutls.errors.GNUTLSError as error:

1801

logger.warning("gnutls send failed",

1802

exc_info=error)

1315

logger.warning("gnutls send failed")

1803

1316

return

1804

1317

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

1805

1318

sent, len(client.secret)

1806

1319

- (sent_size + sent))

1807

1320

sent_size += sent

1808

1321

1809

1322

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

1810

# bump the timeout using extended_timeout

1811

client.bump_timeout(client.extended_timeout)

1323

# bump the timeout as if seen

1324

client.checked_ok()

1812

1325

if self.server.use_dbus:

1813

1326

# Emit D-Bus signal

1814

1327

client.GotSecret()

1819

1332

try:

1820

1333

session.bye()

1821

1334

except gnutls.errors.GNUTLSError as error:

1822

logger.warning("GnuTLS bye failed",

1823

exc_info=error)

1335

logger.warning("GnuTLS bye failed")

1824

1336

1825

1337

@staticmethod

1826

1338

def peer_certificate(session):

1882

1394

# Convert the buffer to a Python bytestring

1883

1395

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

1884

1396

# Convert the bytestring to hexadecimal notation

1885

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

1397

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

1886

1398

return hex_fpr

1887

1399

1888

1400

1891

1403

def sub_process_main(self, request, address):

1892

1404

try:

1893

1405

self.finish_request(request, address)

1894

except Exception:

1406

except:

1895

1407

self.handle_error(request, address)

1896

1408

self.close_request(request)

1897

1409

1898

1410

def process_request(self, request, address):

1899

1411

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

1900

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

1901

args = (request, address))

1902

proc.start()

1903

return proc

1904

1412

multiprocessing.Process(target = self.sub_process_main,

1413

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

1905

1414

1906

1415

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1907

1416

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

1911

1420

This function creates a new pipe in self.pipe

1912

1421

"""

1913

1422

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1914

1915

proc = MultiprocessingMixIn.process_request(self, request,

1916

client_address)

1423

1424

super(MultiprocessingMixInWithPipe,

1425

self).process_request(request, client_address)

1917

1426

self.child_pipe.close()

1918

self.add_pipe(parent_pipe, proc)

1919

1920

def add_pipe(self, parent_pipe, proc):

1427

self.add_pipe(parent_pipe)

1428

1429

def add_pipe(self, parent_pipe):

1921

1430

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

1922

raise NotImplementedError()

1923

1431

raise NotImplementedError

1924

1432

1925

1433

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1926

1434

socketserver.TCPServer, object):

1932

1440

use_ipv6: Boolean; to use IPv6 or not

1933

1441

"""

1934

1442

def __init__(self, server_address, RequestHandlerClass,

1935

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

1936

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

1937

creating a new one with socket.socket().

1938

"""

1443

interface=None, use_ipv6=True):

1939

1444

self.interface = interface

1940

1445

if use_ipv6:

1941

1446

self.address_family = socket.AF_INET6

1942

if socketfd is not None:

1943

# Save the file descriptor

1944

self.socketfd = socketfd

1945

# Save the original socket.socket() function

1946

self.socket_socket = socket.socket

1947

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

1948

#

1949

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

1950

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

1951

# patching socket.socket.)

1952

#

1953

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

1954

@functools.wraps(socket.socket)

1955

def socket_wrapper(*args, **kwargs):

1956

# Restore original function so subsequent calls are

1957

# not affected.

1958

socket.socket = self.socket_socket

1959

del self.socket_socket

1960

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

1961

# saved file descriptor.

1962

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

1963

# Replace socket.socket() function with wrapper

1964

socket.socket = socket_wrapper

1965

# The socketserver.TCPServer.__init__ will call

1966

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

1967

# socket_wrapper(), if socketfd was set.

1968

1447

socketserver.TCPServer.__init__(self, server_address,

1969

1448

RequestHandlerClass)

1970

1971

1449

def server_bind(self):

1972

1450

"""This overrides the normal server_bind() function

1973

1451

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

1981

1459

try:

1982

1460

self.socket.setsockopt(socket.SOL_SOCKET,

1983

1461

SO_BINDTODEVICE,

1984

(self.interface + "\0")

1985

.encode("utf-8"))

1462

str(self.interface

1463

+ '\0'))

1986

1464

except socket.error as error:

1987

if error.errno == errno.EPERM:

1988

logger.error("No permission to bind to"

1989

" interface %s", self.interface)

1990

elif error.errno == errno.ENOPROTOOPT:

1465

if error[0] == errno.EPERM:

1466

logger.error("No permission to"

1467

" bind to interface %s",

1468

self.interface)

1469

elif error[0] == errno.ENOPROTOOPT:

1991

1470

logger.error("SO_BINDTODEVICE not available;"

1992

1471

" cannot bind to interface %s",

1993

1472

self.interface)

1994

elif error.errno == errno.ENODEV:

1995

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

1996

" cannot bind", self.interface)

1997

1473

else:

1998

1474

raise

1999

1475

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

2002

1478

if self.address_family == socket.AF_INET6:

2003

1479

any_address = "::" # in6addr_any

2004

1480

else:

2005

any_address = "0.0.0.0" # INADDR_ANY

1481

any_address = socket.INADDR_ANY

2006

1482

self.server_address = (any_address,

2007

1483

self.server_address[1])

2008

1484

elif not self.server_address[1]:

2029

1505

"""

2030

1506

def __init__(self, server_address, RequestHandlerClass,

2031

1507

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

2032

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

1508

gnutls_priority=None, use_dbus=True):

2033

1509

self.enabled = False

2034

1510

self.clients = clients

2035

1511

if self.clients is None:

2036

self.clients = {}

1512

self.clients = set()

2037

1513

self.use_dbus = use_dbus

2038

1514

self.gnutls_priority = gnutls_priority

2039

1515

IPv6_TCPServer.__init__(self, server_address,

2040

1516

RequestHandlerClass,

2041

1517

interface = interface,

2042

use_ipv6 = use_ipv6,

2043

socketfd = socketfd)

1518

use_ipv6 = use_ipv6)

2044

1519

def server_activate(self):

2045

1520

if self.enabled:

2046

1521

return socketserver.TCPServer.server_activate(self)

2047

2048

1522

def enable(self):

2049

1523

self.enabled = True

2050

2051

def add_pipe(self, parent_pipe, proc):

1524

def add_pipe(self, parent_pipe):

2052

1525

# Call "handle_ipc" for both data and EOF events

2053

1526

gobject.io_add_watch(parent_pipe.fileno(),

2054

1527

gobject.IO_IN | gobject.IO_HUP,

2055

1528

functools.partial(self.handle_ipc,

2056

parent_pipe =

2057

parent_pipe,

2058

proc = proc))

2059

1529

parent_pipe = parent_pipe))

1530

2060

1531

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

2061

proc = None, client_object=None):

2062

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

2063

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

2064

# Wait for other process to exit

2065

proc.join()

1532

client_object=None):

1533

condition_names = {

1534

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

1535

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

1536

# blocking).

1537

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

1538

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

1539

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

1540

# broken, usually for pipes and

1541

# sockets).

1542

}

1543

conditions_string = ' | '.join(name

1544

for cond, name in

1545

condition_names.iteritems()

1546

if cond & condition)

1547

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

1548

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

2066

1549

return False

2067

1550

2068

1551

# Read a request from the child

2073

1556

fpr = request[1]

2074

1557

address = request[2]

2075

1558

2076

for c in self.clients.itervalues():

1559

for c in self.clients:

2077

1560

if c.fingerprint == fpr:

2078

1561

client = c

2079

1562

break

2080

1563

else:

2081

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

2082

"dress: %s", fpr, address)

1564

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

1565

"dress: %s", fpr, address)

2083

1566

if self.use_dbus:

2084

1567

# Emit D-Bus signal

2085

mandos_dbus_service.ClientNotFound(fpr,

2086

address[0])

1568

mandos_dbus_service.ClientNotFound(fpr, address[0])

2087

1569

parent_pipe.send(False)

2088

1570

return False

2089

1571

2090

1572

gobject.io_add_watch(parent_pipe.fileno(),

2091

1573

gobject.IO_IN | gobject.IO_HUP,

2092

1574

functools.partial(self.handle_ipc,

2093

parent_pipe =

2094

parent_pipe,

2095

proc = proc,

2096

client_object =

2097

client))

1575

parent_pipe = parent_pipe,

1576

client_object = client))

2098

1577

parent_pipe.send(True)

2099

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

2100

# same fileno

1578

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

2101

1579

return False

2102

1580

if command == 'funcall':

2103

1581

funcname = request[1]

2104

1582

args = request[2]

2105

1583

kwargs = request[3]

2106

1584

2107

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

2108

funcname)(*args,

2109

**kwargs)))

2110

1585

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

1586

2111

1587

if command == 'getattr':

2112

1588

attrname = request[1]

2113

1589

if callable(client_object.__getattribute__(attrname)):

2114

1590

parent_pipe.send(('function',))

2115

1591

else:

2116

parent_pipe.send(('data', client_object

2117

.__getattribute__(attrname)))

1592

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

2118

1593

2119

1594

if command == 'setattr':

2120

1595

attrname = request[1]

2121

1596

value = request[2]

2122

1597

setattr(client_object, attrname, value)

2123

1598

2124

1599

return True

2125

1600

2126

1601

2127

def rfc3339_duration_to_delta(duration):

2128

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

2129

2130

>>> rfc3339_duration_to_delta("P7D")

2131

datetime.timedelta(7)

2132

>>> rfc3339_duration_to_delta("PT60S")

2133

datetime.timedelta(0, 60)

2134

>>> rfc3339_duration_to_delta("PT60M")

2135

datetime.timedelta(0, 3600)

2136

>>> rfc3339_duration_to_delta("PT24H")

2137

datetime.timedelta(1)

2138

>>> rfc3339_duration_to_delta("P1W")

2139

datetime.timedelta(7)

2140

>>> rfc3339_duration_to_delta("PT5M30S")

2141

datetime.timedelta(0, 330)

2142

>>> rfc3339_duration_to_delta("P1DT3M20S")

2143

datetime.timedelta(1, 200)

2144

"""

2145

2146

# Parsing an RFC 3339 duration with regular expressions is not

2147

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

2148

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

2149

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

2150

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

2151

# avoid excessive use of external libraries.

2152

2153

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

2154

Token = collections.namedtuple("Token",

2155

("regexp", # To match token; if

2156

# "value" is not None,

2157

# must have a "group"

2158

# containing digits

2159

"value", # datetime.timedelta or

2160

# None

2161

"followers")) # Tokens valid after

2162

# this token

2163

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

2164

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

2165

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

2166

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

2167

datetime.timedelta(seconds=1),

2168

frozenset((token_end,)))

2169

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

2170

datetime.timedelta(minutes=1),

2171

frozenset((token_second, token_end)))

2172

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

2173

datetime.timedelta(hours=1),

2174

frozenset((token_minute, token_end)))

2175

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

2176

None,

2177

frozenset((token_hour, token_minute,

2178

token_second)))

2179

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

2180

datetime.timedelta(days=1),

2181

frozenset((token_time, token_end)))

2182

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

2183

datetime.timedelta(weeks=4),

2184

frozenset((token_day, token_end)))

2185

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

2186

datetime.timedelta(weeks=52),

2187

frozenset((token_month, token_end)))

2188

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

2189

datetime.timedelta(weeks=1),

2190

frozenset((token_end,)))

2191

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

2192

frozenset((token_year, token_month,

2193

token_day, token_time,

2194

token_week)))

2195

# Define starting values

2196

value = datetime.timedelta() # Value so far

2197

found_token = None

2198

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

2199

s = duration # String left to parse

2200

# Loop until end token is found

2201

while found_token is not token_end:

2202

# Search for any currently valid tokens

2203

for token in followers:

2204

match = token.regexp.match(s)

2205

if match is not None:

2206

# Token found

2207

if token.value is not None:

2208

# Value found, parse digits

2209

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

2210

# Add to value so far

2211

value += factor * token.value

2212

# Strip token from string

2213

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

2214

# Go to found token

2215

found_token = token

2216

# Set valid next tokens

2217

followers = found_token.followers

2218

break

2219

else:

2220

# No currently valid tokens were found

2221

raise ValueError("Invalid RFC 3339 duration")

2222

# End token found

2223

return value

2224

2225

2226

1602

def string_to_delta(interval):

2227

1603

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

2228

1604

2239

1615

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

2240

1616

datetime.timedelta(0, 330)

2241

1617

"""

2242

2243

try:

2244

return rfc3339_duration_to_delta(interval)

2245

except ValueError:

2246

pass

2247

2248

1618

timevalue = datetime.timedelta(0)

2249

1619

for s in interval.split():

2250

1620

try:

2251

suffix = s[-1]

1621

suffix = unicode(s[-1])

2252

1622

value = int(s[:-1])

2253

1623

if suffix == "d":

2254

1624

delta = datetime.timedelta(value)

2261

1631

elif suffix == "w":

2262

1632

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

2263

1633

else:

2264

raise ValueError("Unknown suffix {!r}"

2265

.format(suffix))

2266

except IndexError as e:

1634

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

1635

except (ValueError, IndexError) as e:

2267

1636

raise ValueError(*(e.args))

2268

1637

timevalue += delta

2269

1638

return timevalue

2270

1639

2271

1640

1641

def if_nametoindex(interface):

1642

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

1643

1644

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

1645

global if_nametoindex

1646

try:

1647

if_nametoindex = (ctypes.cdll.LoadLibrary

1648

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

1649

.if_nametoindex)

1650

except (OSError, AttributeError):

1651

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

1652

def if_nametoindex(interface):

1653

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

1654

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

1655

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

1656

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1657

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

1658

interface))

1659

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

1660

ifreq[16:20])[0]

1661

return interface_index

1662

return if_nametoindex(interface)

1663

1664

2272

1665

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

2273

1666

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

2274

1667

2282

1675

sys.exit()

2283

1676

if not noclose:

2284

1677

# Close all standard open file descriptors

2285

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

1678

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

2286

1679

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

2287

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

2288

.format(os.devnull))

1680

raise OSError(errno.ENODEV,

1681

"%s not a character device"

1682

% os.path.devnull)

2289

1683

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

2290

1684

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

2291

1685

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

2300

1694

2301

1695

parser = argparse.ArgumentParser()

2302

1696

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

2303

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

1697

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

2304

1698

help="show version number and exit")

2305

1699

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

2306

1700

help="Bind to interface IF")

2312

1706

help="Run self-test")

2313

1707

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

2314

1708

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

2315

" to terminal", default=None)

1709

" to terminal")

2316

1710

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

2317

1711

help="Debug level for stdout output")

2318

1712

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

2325

1719

" files")

2326

1720

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

2327

1721

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

2328

" system bus interface", default=None)

1722

" system bus interface")

2329

1723

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

2330

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

2331

default=None)

2332

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

2333

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

2334

" state", default=None)

2335

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

2336

help="Specify a file descriptor to a network"

2337

" socket to use instead of creating one")

2338

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

2339

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

2340

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

2341

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

2342

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

2343

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

2344

default=None)

2345

1724

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

2346

1725

options = parser.parse_args()

2347

1726

2348

1727

if options.check:

2349

1728

import doctest

2350

fail_count, test_count = doctest.testmod()

2351

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

1729

doctest.testmod()

1730

sys.exit()

2352

1731

2353

1732

# Default values for config file for server-global settings

2354

1733

server_defaults = { "interface": "",

2356

1735

"port": "",

2357

1736

"debug": "False",

2358

1737

"priority":

2359

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

2360

":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

1738

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

2361

1739

"servicename": "Mandos",

2362

1740

"use_dbus": "True",

2363

1741

"use_ipv6": "True",

2364

1742

"debuglevel": "",

2365

"restore": "True",

2366

"socket": "",

2367

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

2368

"foreground": "False",

2369

"zeroconf": "True",

2370

1743

}

2371

1744

2372

1745

# Parse config file for server-global settings

2377

1750

# Convert the SafeConfigParser object to a dict

2378

1751

server_settings = server_config.defaults()

2379

1752

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

2380

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

1753

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

2381

1754

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

2382

1755

option)

2383

1756

if server_settings["port"]:

2384

1757

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

2385

1758

"port")

2386

if server_settings["socket"]:

2387

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

2388

"socket")

2389

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

2390

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

2391

# happen with a supplied network socket.

2392

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

2393

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

2394

["socket"])

2395

1759

del server_config

2396

1760

2397

1761

# Override the settings from the config file with command line

2398

1762

# options, if set.

2399

1763

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

2400

1764

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

2401

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

2402

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

1765

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

2403

1766

value = getattr(options, option)

2404

1767

if value is not None:

2405

1768

server_settings[option] = value

2406

1769

del options

2407

1770

# Force all strings to be unicode

2408

1771

for option in server_settings.keys():

2409

if isinstance(server_settings[option], bytes):

2410

server_settings[option] = (server_settings[option]

2411

.decode("utf-8"))

2412

# Force all boolean options to be boolean

2413

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

2414

"foreground", "zeroconf"):

2415

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

2416

# Debug implies foreground

2417

if server_settings["debug"]:

2418

server_settings["foreground"] = True

1772

if type(server_settings[option]) is str:

1773

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

2419

1774

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

2420

1775

2421

1776

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

2422

1777

2423

if (not server_settings["zeroconf"] and

2424

not (server_settings["port"]

2425

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

2426

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

2427

" Zeroconf")

2428

2429

1778

# For convenience

2430

1779

debug = server_settings["debug"]

2431

1780

debuglevel = server_settings["debuglevel"]

2432

1781

use_dbus = server_settings["use_dbus"]

2433

1782

use_ipv6 = server_settings["use_ipv6"]

2434

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

2435

stored_state_file)

2436

foreground = server_settings["foreground"]

2437

zeroconf = server_settings["zeroconf"]

2438

2439

if debug:

2440

initlogger(debug, logging.DEBUG)

2441

else:

2442

if not debuglevel:

2443

initlogger(debug)

2444

else:

2445

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

2446

initlogger(debug, level)

2447

1783

2448

1784

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

2449

1785

syslogger.setFormatter(logging.Formatter

2450

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

2451

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

2452

.format(server_settings

2453

["servicename"])))

1786

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

1787

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

1788

% server_settings["servicename"]))

2454

1789

2455

1790

# Parse config file with clients

2456

client_config = configparser.SafeConfigParser(Client

2457

.client_defaults)

1791

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

1792

"interval": "5m",

1793

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

1794

"host": "",

1795

"approval_delay": "0s",

1796

"approval_duration": "1s",

1797

}

1798

client_config = configparser.SafeConfigParser(client_defaults)

2458

1799

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

2459

1800

"clients.conf"))

2460

1801

2461

1802

global mandos_dbus_service

2462

1803

mandos_dbus_service = None

2463

1804

2464

socketfd = None

2465

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

2466

socketfd = server_settings["socket"]

2467

1805

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

2468

1806

server_settings["port"]),

2469

1807

ClientHandler,

2472

1810

use_ipv6=use_ipv6,

2473

1811

gnutls_priority=

2474

1812

server_settings["priority"],

2475

use_dbus=use_dbus,

2476

socketfd=socketfd)

2477

if not foreground:

2478

pidfilename = "/run/mandos.pid"

2479

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

2480

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

2481

pidfile = None

1813

use_dbus=use_dbus)

1814

if not debug:

1815

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

2482

1816

try:

2483

1817

pidfile = open(pidfilename, "w")

2484

except IOError as e:

2485

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

2486

exc_info=e)

1818

except IOError:

1819

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

2487

1820

2488

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

1821

try:

1822

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

1823

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

1824

except KeyError:

2489

1825

try:

2490

uid = pwd.getpwnam(name).pw_uid

2491

gid = pwd.getpwnam(name).pw_gid

2492

break

1826

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

1827

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

2493

1828

except KeyError:

2494

continue

2495

else:

2496

uid = 65534

2497

gid = 65534

1829

try:

1830

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

1831

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

1832

except KeyError:

1833

uid = 65534

1834

gid = 65534

2498

1835

try:

2499

1836

os.setgid(gid)

2500

1837

os.setuid(uid)

2501

1838

except OSError as error:

2502

if error.errno != errno.EPERM:

2503

raise

1839

if error[0] != errno.EPERM:

1840

raise error

2504

1841

1842

if not debug and not debuglevel:

1843

syslogger.setLevel(logging.WARNING)

1844

console.setLevel(logging.WARNING)

1845

if debuglevel:

1846

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

1847

syslogger.setLevel(level)

1848

console.setLevel(level)

1849

2505

1850

if debug:

2506

1851

# Enable all possible GnuTLS debugging

2507

1852

2517

1862

.gnutls_global_set_log_function(debug_gnutls))

2518

1863

2519

1864

# Redirect stdin so all checkers get /dev/null

2520

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

1865

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

2521

1866

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

2522

1867

if null > 2:

2523

1868

os.close(null)

1869

else:

1870

# No console logging

1871

logger.removeHandler(console)

2524

1872

2525

1873

# Need to fork before connecting to D-Bus

2526

if not foreground:

1874

if not debug:

2527

1875

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

2528

1876

daemon()

2529

1877

2530

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

2531

# need to inform gobject that threads will be used.

2532

gobject.threads_init()

2533

2534

1878

global main_loop

2535

1879

# From the Avahi example code

2536

DBusGMainLoop(set_as_default=True)

1880

DBusGMainLoop(set_as_default=True )

2537

1881

main_loop = gobject.MainLoop()

2538

1882

bus = dbus.SystemBus()

2539

1883

# End of Avahi example code

2540

1884

if use_dbus:

2541

1885

try:

2542

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

1886

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

2543

1887

bus, do_not_queue=True)

2544

old_bus_name = (dbus.service.BusName

2545

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

2546

do_not_queue=True))

2547

1888

except dbus.exceptions.NameExistsException as e:

2548

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

1889

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

2549

1890

use_dbus = False

2550

1891

server_settings["use_dbus"] = False

2551

1892

tcp_server.use_dbus = False

2552

if zeroconf:

2553

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2554

service = AvahiServiceToSyslog(name =

2555

server_settings["servicename"],

2556

servicetype = "_mandos._tcp",

2557

protocol = protocol, bus = bus)

2558

if server_settings["interface"]:

2559

service.interface = (if_nametoindex

2560

(server_settings["interface"]

2561

.encode("utf-8")))

1893

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1894

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

1895

servicetype = "_mandos._tcp",

1896

protocol = protocol, bus = bus)

1897

if server_settings["interface"]:

1898

service.interface = (if_nametoindex

1899

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

2562

1900

2563

1901

global multiprocessing_manager

2564

1902

multiprocessing_manager = multiprocessing.Manager()

2566

1904

client_class = Client

2567

1905

if use_dbus:

2568

1906

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

2569

2570

client_settings = Client.config_parser(client_config)

2571

old_client_settings = {}

2572

clients_data = {}

2573

2574

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

2575

global wnull

2576

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

2577

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

2578

# mode

2579

if debug or not foreground:

2580

wnull.close()

2581

2582

# Get client data and settings from last running state.

2583

if server_settings["restore"]:

2584

try:

2585

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

2586

clients_data, old_client_settings = (pickle.load

2587

(stored_state))

2588

os.remove(stored_state_path)

2589

except IOError as e:

2590

if e.errno == errno.ENOENT:

2591

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

2592

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

2593

else:

2594

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

2595

exc_info=e)

2596

raise

2597

except EOFError as e:

2598

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

2599

"EOFError:", exc_info=e)

2600

2601

with PGPEngine() as pgp:

2602

for client_name, client in clients_data.items():

2603

# Skip removed clients

2604

if client_name not in client_settings:

2605

continue

2606

2607

# Decide which value to use after restoring saved state.

2608

# We have three different values: Old config file,

2609

# new config file, and saved state.

2610

# New config value takes precedence if it differs from old

2611

# config value, otherwise use saved state.

2612

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

2613

try:

2614

# For each value in new config, check if it

2615

# differs from the old config value (Except for

2616

# the "secret" attribute)

2617

if (name != "secret" and

2618

value != old_client_settings[client_name]

2619

[name]):

2620

client[name] = value

2621

except KeyError:

2622

pass

2623

2624

# Clients who has passed its expire date can still be

2625

# enabled if its last checker was successful. Clients

2626

# whose checker succeeded before we stored its state is

2627

# assumed to have successfully run all checkers during

2628

# downtime.

2629

if client["enabled"]:

2630

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

2631

if not client["last_checked_ok"]:

2632

logger.warning(

2633

"disabling client {} - Client never "

2634

"performed a successful checker"

2635

.format(client_name))

2636

client["enabled"] = False

2637

elif client["last_checker_status"] != 0:

2638

logger.warning(

2639

"disabling client {} - Client last"

2640

" checker failed with error code {}"

2641

.format(client_name,

2642

client["last_checker_status"]))

2643

client["enabled"] = False

2644

else:

2645

client["expires"] = (datetime.datetime

2646

.utcnow()

2647

+ client["timeout"])

2648

logger.debug("Last checker succeeded,"

2649

" keeping {} enabled"

2650

.format(client_name))

1907

def client_config_items(config, section):

1908

special_settings = {

1909

"approved_by_default":

1910

lambda: config.getboolean(section,

1911

"approved_by_default"),

1912

}

1913

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

2651

1914

try:

2652

client["secret"] = (

2653

pgp.decrypt(client["encrypted_secret"],

2654

client_settings[client_name]

2655

["secret"]))

2656

except PGPError:

2657

# If decryption fails, we use secret from new settings

2658

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

2659

.format(client_name))

2660

client["secret"] = (

2661

client_settings[client_name]["secret"])

2662

2663

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

2664

for client_name in (set(old_client_settings)

2665

- set(client_settings)):

2666

del clients_data[client_name]

2667

for client_name in (set(client_settings)

2668

- set(old_client_settings)):

2669

clients_data[client_name] = client_settings[client_name]

2670

2671

# Create all client objects

2672

for client_name, client in clients_data.items():

2673

tcp_server.clients[client_name] = client_class(

2674

name = client_name, settings = client,

2675

server_settings = server_settings)

2676

1915

yield (name, special_settings[name]())

1916

except KeyError:

1917

yield (name, value)

1918

1919

tcp_server.clients.update(set(

1920

client_class(name = section,

1921

config= dict(client_config_items(

1922

client_config, section)))

1923

for section in client_config.sections()))

2677

1924

if not tcp_server.clients:

2678

1925

logger.warning("No clients defined")

2679

2680

if not foreground:

2681

if pidfile is not None:

2682

try:

2683

with pidfile:

2684

pid = os.getpid()

2685

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

2686

except IOError:

2687

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

2688

pidfilename, pid)

2689

del pidfile

1926

1927

if not debug:

1928

try:

1929

with pidfile:

1930

pid = os.getpid()

1931

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

1932

del pidfile

1933

except IOError:

1934

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

1935

pidfilename, pid)

1936

except NameError:

1937

# "pidfile" was never created

1938

pass

2690

1939

del pidfilename

2691

1940

1941

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

1942

2692

1943

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

2693

1944

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

2694

1945

2695

1946

if use_dbus:

2696

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

2697

"se.bsnet.fukt.Mandos"})

2698

class MandosDBusService(DBusObjectWithProperties):

1947

class MandosDBusService(dbus.service.Object):

2699

1948

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

2700

1949

def __init__(self):

2701

1950

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

2702

_interface = "se.recompile.Mandos"

2703

2704

@dbus_interface_annotations(_interface)

2705

def _foo(self):

2706

return { "org.freedesktop.DBus.Property"

2707

".EmitsChangedSignal":

2708

"false"}

1951

_interface = "se.bsnet.fukt.Mandos"

2709

1952

2710

1953

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

2711

1954

def ClientAdded(self, objpath):

2726

1969

def GetAllClients(self):

2727

1970

"D-Bus method"

2728

1971

return dbus.Array(c.dbus_object_path

2729

for c in

2730

tcp_server.clients.itervalues())

1972

for c in tcp_server.clients)

2731

1973

2732

1974

@dbus.service.method(_interface,

2733

1975

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

2734

1976

def GetAllClientsWithProperties(self):

2735

1977

"D-Bus method"

2736

1978

return dbus.Dictionary(

2737

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

2738

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

1979

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

1980

for c in tcp_server.clients),

2739

1981

signature="oa{sv}")

2740

1982

2741

1983

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

2742

1984

def RemoveClient(self, object_path):

2743

1985

"D-Bus method"

2744

for c in tcp_server.clients.itervalues():

1986

for c in tcp_server.clients:

2745

1987

if c.dbus_object_path == object_path:

2746

del tcp_server.clients[c.name]

1988

tcp_server.clients.remove(c)

2747

1989

c.remove_from_connection()

2748

1990

# Don't signal anything except ClientRemoved

2749

1991

c.disable(quiet=True)

2758

2000

2759

2001

def cleanup():

2760

2002

"Cleanup function; run on exit"

2761

if zeroconf:

2762

service.cleanup()

2763

2764

multiprocessing.active_children()

2765

wnull.close()

2766

if not (tcp_server.clients or client_settings):

2767

return

2768

2769

# Store client before exiting. Secrets are encrypted with key

2770

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

2771

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

2772

clients = {}

2773

with PGPEngine() as pgp:

2774

for client in tcp_server.clients.itervalues():

2775

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

2776

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

2777

key)

2778

client_dict = {}

2779

2780

# A list of attributes that can not be pickled

2781

# + secret.

2782

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

2783

"checker", "server_settings" }

2784

for name, typ in (inspect.getmembers

2785

(dbus.service.Object)):

2786

exclude.add(name)

2787

2788

client_dict["encrypted_secret"] = (client

2789

.encrypted_secret)

2790

for attr in client.client_structure:

2791

if attr not in exclude:

2792

client_dict[attr] = getattr(client, attr)

2793

2794

clients[client.name] = client_dict

2795

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

2796

2797

try:

2798

with (tempfile.NamedTemporaryFile

2799

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

2800

dir=os.path.dirname(stored_state_path),

2801

delete=False)) as stored_state:

2802

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

2803

tempname=stored_state.name

2804

os.rename(tempname, stored_state_path)

2805

except (IOError, OSError) as e:

2806

if not debug:

2807

try:

2808

os.remove(tempname)

2809

except NameError:

2810

pass

2811

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

2812

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

2813

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

2814

else:

2815

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

2816

exc_info=e)

2817

raise

2818

2819

# Delete all clients, and settings from config

2003

service.cleanup()

2004

2820

2005

while tcp_server.clients:

2821

name, client = tcp_server.clients.popitem()

2006

client = tcp_server.clients.pop()

2822

2007

if use_dbus:

2823

2008

client.remove_from_connection()

2009

client.disable_hook = None

2824

2010

# Don't signal anything except ClientRemoved

2825

2011

client.disable(quiet=True)

2826

2012

if use_dbus:

2827

2013

# Emit D-Bus signal

2828

mandos_dbus_service.ClientRemoved(client

2829

.dbus_object_path,

2014

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2830

2015

client.name)

2831

client_settings.clear()

2832

2016

2833

2017

atexit.register(cleanup)

2834

2018

2835

for client in tcp_server.clients.itervalues():

2019

for client in tcp_server.clients:

2836

2020

if use_dbus:

2837

2021

# Emit D-Bus signal

2838

2022

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2839

# Need to initiate checking of clients

2840

if client.enabled:

2841

client.init_checker()

2023

client.enable()

2842

2024

2843

2025

tcp_server.enable()

2844

2026

tcp_server.server_activate()

2845

2027

2846

2028

# Find out what port we got

2847

if zeroconf:

2848

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

2029

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

2849

2030

if use_ipv6:

2850

2031

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

2851

" flowinfo %d, scope_id %d",

2852

*tcp_server.socket.getsockname())

2032

" flowinfo %d, scope_id %d"

2033

% tcp_server.socket.getsockname())

2853

2034

else: # IPv4

2854

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

2855

*tcp_server.socket.getsockname())

2035

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

2036

% tcp_server.socket.getsockname())

2856

2037

2857

2038

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

2858

2039

2859

2040

try:

2860

if zeroconf:

2861

# From the Avahi example code

2862

try:

2863

service.activate()

2864

except dbus.exceptions.DBusException as error:

2865

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

2866

cleanup()

2867

sys.exit(1)

2868

# End of Avahi example code

2041

# From the Avahi example code

2042

try:

2043

service.activate()

2044

except dbus.exceptions.DBusException as error:

2045

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

2046

cleanup()

2047

sys.exit(1)

2048

# End of Avahi example code

2869

2049

2870

2050

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

2871

2051

lambda *args, **kwargs:

2875

2055

logger.debug("Starting main loop")

2876

2056

main_loop.run()

2877

2057

except AvahiError as error:

2878

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

2058

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

2879

2059

cleanup()

2880

2060

sys.exit(1)

2881

2061

except KeyboardInterrupt: