/mandos/trunk : revision 24.1.174

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

95

stored_state_file = "clients.pickle"

96

97

logger = logging.getLogger()

98

syslogger = None

99

100

try:

101

if_nametoindex = (ctypes.cdll.LoadLibrary

102

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

103

.if_nametoindex)

104

except (OSError, AttributeError):

105

def if_nametoindex(interface):

106

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

107

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

108

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

109

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

110

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

111

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

112

return interface_index

113

114

115

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

116

"""init logger and add loglevel"""

117

118

global syslogger

119

syslogger = (logging.handlers.SysLogHandler

120

(facility =

121

logging.handlers.SysLogHandler.LOG_DAEMON,

122

address = "/dev/log"))

123

syslogger.setFormatter(logging.Formatter

124

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

125

' %(message)s'))

126

logger.addHandler(syslogger)

127

128

if debug:

129

console = logging.StreamHandler()

130

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

131

' [%(process)d]:'

132

' %(levelname)s:'

133

' %(message)s'))

134

logger.addHandler(console)

135

logger.setLevel(level)

136

137

138

class PGPError(Exception):

139

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

140

pass

141

142

143

class PGPEngine(object):

144

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

145

def __init__(self):

146

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

147

self.gnupgargs = ['--batch',

148

'--home', self.tempdir,

149

'--force-mdc',

150

'--quiet',

151

'--no-use-agent']

152

153

def __enter__(self):

154

return self

155

156

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

157

self._cleanup()

158

return False

159

160

def __del__(self):

161

self._cleanup()

162

163

def _cleanup(self):

164

if self.tempdir is not None:

165

# Delete contents of tempdir

166

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

167

topdown = False):

168

for filename in files:

169

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

170

for dirname in dirs:

171

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

172

# Remove tempdir

173

os.rmdir(self.tempdir)

174

self.tempdir = None

175

176

def password_encode(self, password):

177

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

178

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

179

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

180

if len(encoded) > 2048:

181

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

182

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

183

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

184

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

185

return encoded

186

187

def encrypt(self, data, password):

188

passphrase = self.password_encode(password)

189

with tempfile.NamedTemporaryFile(dir=self.tempdir

190

) as passfile:

191

passfile.write(passphrase)

192

passfile.flush()

193

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

194

'--passphrase-file',

195

passfile.name]

196

+ self.gnupgargs,

197

stdin = subprocess.PIPE,

198

stdout = subprocess.PIPE,

199

stderr = subprocess.PIPE)

200

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

201

if proc.returncode != 0:

202

raise PGPError(err)

203

return ciphertext

204

205

def decrypt(self, data, password):

206

passphrase = self.password_encode(password)

207

with tempfile.NamedTemporaryFile(dir = self.tempdir

208

) as passfile:

209

passfile.write(passphrase)

210

passfile.flush()

211

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

212

'--passphrase-file',

213

passfile.name]

214

+ self.gnupgargs,

215

stdin = subprocess.PIPE,

216

stdout = subprocess.PIPE,

217

stderr = subprocess.PIPE)

218

decrypted_plaintext, err = proc.communicate(input

219

= data)

220

if proc.returncode != 0:

221

raise PGPError(err)

222

return decrypted_plaintext

223

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

155

def rename(self):

279

156

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

280

157

if self.rename_count >= self.max_renames:

282

159

" after %i retries, exiting.",

283

160

self.rename_count)

284

161

raise AvahiServiceError("Too many renames")

285

self.name = str(self.server

286

.GetAlternativeServiceName(self.name))

162

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

287

163

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

288

164

self.name)

165

syslogger.setFormatter(logging.Formatter

166

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

167

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

168

% self.name))

289

169

self.remove()

290

170

try:

291

171

self.add()

292

172

except dbus.exceptions.DBusException as error:

293

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

173

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

294

174

self.cleanup()

295

175

os._exit(1)

296

176

self.rename_count += 1

297

298

177

def remove(self):

299

178

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

300

179

if self.entry_group_state_changed_match is not None:

302

181

self.entry_group_state_changed_match = None

303

182

if self.group is not None:

304

183

self.group.Reset()

305

306

184

def add(self):

307

185

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

308

186

self.remove()

313

191

avahi.DBUS_INTERFACE_ENTRY_GROUP)

314

192

self.entry_group_state_changed_match = (

315

193

self.group.connect_to_signal(

316

'StateChanged', self.entry_group_state_changed))

194

'StateChanged', self .entry_group_state_changed))

317

195

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

318

196

self.name, self.type)

319

197

self.group.AddService(

325

203

dbus.UInt16(self.port),

326

204

avahi.string_array_to_txt_array(self.TXT))

327

205

self.group.Commit()

328

329

206

def entry_group_state_changed(self, state, error):

330

207

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

331

208

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

337

214

self.rename()

338

215

elif state == avahi.ENTRY_GROUP_FAILURE:

339

216

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

340

str(error))

341

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

342

.format(error))

343

217

unicode(error))

218

raise AvahiGroupError("State changed: %s"

219

% unicode(error))

344

220

def cleanup(self):

345

221

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

346

222

if self.group is not None:

347

223

try:

348

224

self.group.Free()

349

225

except (dbus.exceptions.UnknownMethodException,

350

dbus.exceptions.DBusException):

226

dbus.exceptions.DBusException) as e:

351

227

pass

352

228

self.group = None

353

229

self.remove()

354

355

230

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

356

231

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

357

232

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

376

251

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

377

252

else:

378

253

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

379

380

254

def activate(self):

381

255

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

382

256

if self.server is None:

390

264

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

391

265

392

266

393

class AvahiServiceToSyslog(AvahiService):

394

def rename(self):

395

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

396

ret = AvahiService.rename(self)

397

syslogger.setFormatter(logging.Formatter

398

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

399

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

400

.format(self.name)))

401

return ret

402

403

404

267

class Client(object):

405

268

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

406

269

407

270

Attributes:

408

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

271

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

409

272

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

410

273

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

411

274

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

418

281

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

419

282

checker_initiator_tag: a gobject event source tag, or None

420

283

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

421

client_structure: Object describing what attributes a client has

422

and is used for storing the client at exit

423

284

current_checker_command: string; current running checker_command

285

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

424

286

disable_initiator_tag: a gobject event source tag, or None

425

287

enabled: bool()

426

288

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

429

291

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

430

292

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

431

293

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

432

last_checker_status: integer between 0 and 255 reflecting exit

433

status of last checker. -1 reflects crashed

434

checker, -2 means no checker completed yet.

435

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

294

last_enabled: datetime.datetime(); (UTC)

436

295

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

437

296

D-Bus identifiers

438

297

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

439

298

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

440

299

until this client is disabled

441

extended_timeout: extra long timeout when secret has been sent

442

300

runtime_expansions: Allowed attributes for runtime expansion.

443

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

444

disabled, or None

445

server_settings: The server_settings dict from main()

446

301

"""

447

302

448

303

runtime_expansions = ("approval_delay", "approval_duration",

449

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

450

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

451

"last_approval_request", "last_checked_ok",

304

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

305

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

452

306

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

453

client_defaults = { "timeout": "PT5M",

454

"extended_timeout": "PT15M",

455

"interval": "PT2M",

456

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

457

"host": "",

458

"approval_delay": "PT0S",

459

"approval_duration": "PT1S",

460

"approved_by_default": "True",

461

"enabled": "True",

462

}

463

307

464

308

@staticmethod

465

def config_parser(config):

466

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

467

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

468

with exceptions for any special settings as defined above.

469

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

470

value given the same arguments.

471

"""

472

settings = {}

473

for client_name in config.sections():

474

section = dict(config.items(client_name))

475

client = settings[client_name] = {}

476

477

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

478

# Reformat values from string types to Python types

479

client["approved_by_default"] = config.getboolean(

480

client_name, "approved_by_default")

481

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

482

"enabled")

483

484

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

485

.replace(" ", ""))

486

if "secret" in section:

487

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

488

elif "secfile" in section:

489

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

490

(section["secfile"])),

491

"rb") as secfile:

492

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

493

else:

494

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

495

.format(section))

496

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

497

client["extended_timeout"] = string_to_delta(

498

section["extended_timeout"])

499

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

500

client["approval_delay"] = string_to_delta(

501

section["approval_delay"])

502

client["approval_duration"] = string_to_delta(

503

section["approval_duration"])

504

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

505

client["last_approval_request"] = None

506

client["last_checked_ok"] = None

507

client["last_checker_status"] = -2

508

509

return settings

510

511

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

309

def _timedelta_to_milliseconds(td):

310

"Convert a datetime.timedelta() to milliseconds"

311

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

312

+ (td.seconds * 1000)

313

+ (td.microseconds // 1000))

314

315

def timeout_milliseconds(self):

316

"Return the 'timeout' attribute in milliseconds"

317

return self._timedelta_to_milliseconds(self.timeout)

318

319

def interval_milliseconds(self):

320

"Return the 'interval' attribute in milliseconds"

321

return self._timedelta_to_milliseconds(self.interval)

322

323

def approval_delay_milliseconds(self):

324

return self._timedelta_to_milliseconds(self.approval_delay)

325

326

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

327

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

328

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

329

attribute."""

512

330

self.name = name

513

if server_settings is None:

514

server_settings = {}

515

self.server_settings = server_settings

516

# adding all client settings

517

for setting, value in settings.items():

518

setattr(self, setting, value)

519

520

if self.enabled:

521

if not hasattr(self, "last_enabled"):

522

self.last_enabled = datetime.datetime.utcnow()

523

if not hasattr(self, "expires"):

524

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

525

+ self.timeout)

526

else:

527

self.last_enabled = None

528

self.expires = None

529

331

if config is None:

332

config = {}

530

333

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

531

334

# Uppercase and remove spaces from fingerprint for later

532

335

# comparison purposes with return value from the fingerprint()

533

336

# function

337

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

338

.replace(" ", ""))

534

339

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

535

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

536

datetime.datetime.utcnow())

537

538

# attributes specific for this server instance

340

if "secret" in config:

341

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

342

elif "secfile" in config:

343

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

344

(config["secfile"])),

345

"rb") as secfile:

346

self.secret = secfile.read()

347

else:

348

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

349

% self.name)

350

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

351

self.created = datetime.datetime.utcnow()

352

self.enabled = False

353

self.last_approval_request = None

354

self.last_enabled = None

355

self.last_checked_ok = None

356

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

357

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

358

self.disable_hook = disable_hook

539

359

self.checker = None

540

360

self.checker_initiator_tag = None

541

361

self.disable_initiator_tag = None

542

362

self.checker_callback_tag = None

363

self.checker_command = config["checker"]

543

364

self.current_checker_command = None

544

self.approved = None

365

self.last_connect = None

366

self._approved = None

367

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

368

True)

545

369

self.approvals_pending = 0

546

self.changedstate = (multiprocessing_manager

547

.Condition(multiprocessing_manager

548

.Lock()))

549

self.client_structure = [attr for attr in

550

self.__dict__.iterkeys()

551

if not attr.startswith("_")]

552

self.client_structure.append("client_structure")

553

554

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

555

lambda obj:

556

isinstance(obj,

557

property)):

558

if not name.startswith("_"):

559

self.client_structure.append(name)

370

self.approval_delay = string_to_delta(

371

config["approval_delay"])

372

self.approval_duration = string_to_delta(

373

config["approval_duration"])

374

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

560

375

561

# Send notice to process children that client state has changed

562

376

def send_changedstate(self):

563

with self.changedstate:

564

self.changedstate.notify_all()

565

377

self.changedstate.acquire()

378

self.changedstate.notify_all()

379

self.changedstate.release()

380

566

381

def enable(self):

567

382

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

568

383

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

569

384

# Already enabled

570

385

return

571

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

572

self.enabled = True

386

self.send_changedstate()

573

387

self.last_enabled = datetime.datetime.utcnow()

574

self.init_checker()

575

self.send_changedstate()

388

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

389

# and every interval from then on.

390

self.checker_initiator_tag = (gobject.timeout_add

391

(self.interval_milliseconds(),

392

self.start_checker))

393

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

394

self.disable_initiator_tag = (gobject.timeout_add

395

(self.timeout_milliseconds(),

396

self.disable))

397

self.enabled = True

398

# Also start a new checker *right now*.

399

self.start_checker()

576

400

577

401

def disable(self, quiet=True):

578

402

"""Disable this client."""

579

403

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

580

404

return False

581

405

if not quiet:

406

self.send_changedstate()

407

if not quiet:

582

408

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

583

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

409

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

584

410

gobject.source_remove(self.disable_initiator_tag)

585

411

self.disable_initiator_tag = None

586

self.expires = None

587

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

412

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

588

413

gobject.source_remove(self.checker_initiator_tag)

589

414

self.checker_initiator_tag = None

590

415

self.stop_checker()

416

if self.disable_hook:

417

self.disable_hook(self)

591

418

self.enabled = False

592

if not quiet:

593

self.send_changedstate()

594

419

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

595

420

return False

596

421

597

422

def __del__(self):

423

self.disable_hook = None

598

424

self.disable()

599

425

600

def init_checker(self):

601

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

602

# and every interval from then on.

603

if self.checker_initiator_tag is not None:

604

gobject.source_remove(self.checker_initiator_tag)

605

self.checker_initiator_tag = (gobject.timeout_add

606

(int(self.interval

607

.total_seconds() * 1000),

608

self.start_checker))

609

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

610

if self.disable_initiator_tag is not None:

611

gobject.source_remove(self.disable_initiator_tag)

612

self.disable_initiator_tag = (gobject.timeout_add

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

616

# Also start a new checker *right now*.

617

self.start_checker()

618

619

426

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

620

427

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

621

428

self.checker_callback_tag = None

622

429

self.checker = None

623

430

if os.WIFEXITED(condition):

624

self.last_checker_status = os.WEXITSTATUS(condition)

625

if self.last_checker_status == 0:

431

exitstatus = os.WEXITSTATUS(condition)

432

if exitstatus == 0:

626

433

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

627

434

vars(self))

628

435

self.checked_ok()

630

437

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

631

438

vars(self))

632

439

else:

633

self.last_checker_status = -1

634

440

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

635

441

vars(self))

636

442

637

443

def checked_ok(self):

638

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

444

"""Bump up the timeout for this client.

445

446

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

447

alive and well.

448

"""

639

449

self.last_checked_ok = datetime.datetime.utcnow()

640

self.last_checker_status = 0

641

self.bump_timeout()

642

643

def bump_timeout(self, timeout=None):

644

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

645

if timeout is None:

646

timeout = self.timeout

647

if self.disable_initiator_tag is not None:

648

gobject.source_remove(self.disable_initiator_tag)

649

self.disable_initiator_tag = None

650

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

651

self.disable_initiator_tag = (gobject.timeout_add

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

654

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

450

gobject.source_remove(self.disable_initiator_tag)

451

self.disable_initiator_tag = (gobject.timeout_add

452

(self.timeout_milliseconds(),

453

self.disable))

655

454

656

455

def need_approval(self):

657

456

self.last_approval_request = datetime.datetime.utcnow()

662

461

If a checker already exists, leave it running and do

663

462

nothing."""

664

463

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

665

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

666

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

667

# would inevitably timeout, since no checker would get a

668

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

464

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

465

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

466

# client would inevitably timeout, since no checker would get

467

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

669

468

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

670

469

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

671

470

# should be.

673

472

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

674

473

try:

675

474

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

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

475

except (AttributeError, OSError) as error:

476

if (isinstance(error, OSError)

477

and error.errno != errno.ECHILD):

478

raise error

681

479

else:

682

480

if pid:

683

481

logger.warning("Checker was a zombie")

686

484

self.current_checker_command)

687

485

# Start a new checker if needed

688

486

if self.checker is None:

689

# Escape attributes for the shell

690

escaped_attrs = { attr:

691

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

692

for attr in self.runtime_expansions }

693

487

try:

694

command = self.checker_command % escaped_attrs

695

except TypeError as error:

696

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

697

self.checker_command, exc_info=error)

698

return True # Try again later

488

# In case checker_command has exactly one % operator

489

command = self.checker_command % self.host

490

except TypeError:

491

# Escape attributes for the shell

492

escaped_attrs = dict(

493

(attr,

494

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

495

errors=

496

'replace')))

497

for attr in

498

self.runtime_expansions)

499

500

try:

501

command = self.checker_command % escaped_attrs

502

except TypeError as error:

503

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

504

' %s', self.checker_command, error)

505

return True # Try again later

699

506

self.current_checker_command = command

700

507

try:

701

508

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

704

511

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

705

512

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

706

513

# always replaced by /dev/null.)

707

# The exception is when not debugging but nevertheless

708

# running in the foreground; use the previously

709

# created wnull.

710

popen_args = {}

711

if (not self.server_settings["debug"]

712

and self.server_settings["foreground"]):

713

popen_args.update({"stdout": wnull,

714

"stderr": wnull })

715

514

self.checker = subprocess.Popen(command,

716

515

close_fds=True,

717

shell=True, cwd="/",

718

**popen_args)

719

except OSError as error:

720

logger.error("Failed to start subprocess",

721

exc_info=error)

722

return True

723

self.checker_callback_tag = (gobject.child_watch_add

724

(self.checker.pid,

725

self.checker_callback,

726

data=command))

727

# The checker may have completed before the gobject

728

# watch was added. Check for this.

729

try:

516

shell=True, cwd="/")

517

self.checker_callback_tag = (gobject.child_watch_add

518

(self.checker.pid,

519

self.checker_callback,

520

data=command))

521

# The checker may have completed before the gobject

522

# watch was added. Check for this.

730

523

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

524

if pid:

525

gobject.source_remove(self.checker_callback_tag)

526

self.checker_callback(pid, status, command)

731

527

except OSError as error:

732

if error.errno == errno.ECHILD:

733

# This should never happen

734

logger.error("Child process vanished",

735

exc_info=error)

736

return True

737

raise

738

if pid:

739

gobject.source_remove(self.checker_callback_tag)

740

self.checker_callback(pid, status, command)

528

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

529

error)

741

530

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

742

531

return True

743

532

750

539

return

751

540

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

752

541

try:

753

self.checker.terminate()

542

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

754

543

#time.sleep(0.5)

755

544

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

756

# self.checker.kill()

545

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

757

546

except OSError as error:

758

547

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

759

548

raise

760

549

self.checker = None

761

550

762

763

551

def dbus_service_property(dbus_interface, signature="v",

764

552

access="readwrite", byte_arrays=False):

765

553

"""Decorators for marking methods of a DBusObjectWithProperties to

776

564

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

777

565

if byte_arrays and signature != "ay":

778

566

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

779

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

567

" signature %r" % signature)

780

568

def decorator(func):

781

569

func._dbus_is_property = True

782

570

func._dbus_interface = dbus_interface

790

578

return decorator

791

579

792

580

793

def dbus_interface_annotations(dbus_interface):

794

"""Decorator for marking functions returning interface annotations

795

796

Usage:

797

798

@dbus_interface_annotations("org.example.Interface")

799

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

800

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

801

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

802

"false"}

803

"""

804

def decorator(func):

805

func._dbus_is_interface = True

806

func._dbus_interface = dbus_interface

807

func._dbus_name = dbus_interface

808

return func

809

return decorator

810

811

812

def dbus_annotations(annotations):

813

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

814

Usage:

815

816

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

817

"org.freedesktop.DBus.Property."

818

"EmitsChangedSignal": "false"})

819

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

820

access="r")

821

def Property_dbus_property(self):

822

return dbus.Boolean(False)

823

"""

824

def decorator(func):

825

func._dbus_annotations = annotations

826

return func

827

return decorator

828

829

830

581

class DBusPropertyException(dbus.exceptions.DBusException):

831

582

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

832

583

"""

833

pass

584

def __unicode__(self):

585

return unicode(str(self))

586

834

587

835

588

class DBusPropertyAccessException(DBusPropertyException):

836

589

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

846

599

847

600

class DBusObjectWithProperties(dbus.service.Object):

848

601

"""A D-Bus object with properties.

849

602

850

603

Classes inheriting from this can use the dbus_service_property

851

604

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

852

605

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

853

606

"""

854

607

855

608

@staticmethod

856

def _is_dbus_thing(thing):

857

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

858

859

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

860

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

861

"""

862

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

863

False)

609

def _is_dbus_property(obj):

610

return getattr(obj, "_dbus_is_property", False)

864

611

865

def _get_all_dbus_things(self, thing):

612

def _get_all_dbus_properties(self):

866

613

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

867

614

"""

868

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

869

name),

870

athing.__get__(self))

871

for cls in self.__class__.__mro__

872

for name, athing in

873

inspect.getmembers(cls,

874

self._is_dbus_thing(thing)))

615

return ((prop._dbus_name, prop)

616

for name, prop in

617

inspect.getmembers(self, self._is_dbus_property))

875

618

876

619

def _get_dbus_property(self, interface_name, property_name):

877

620

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

878

621

property with the specified name and interface.

879

622

"""

880

for cls in self.__class__.__mro__:

881

for name, value in (inspect.getmembers

882

(cls,

883

self._is_dbus_thing("property"))):

884

if (value._dbus_name == property_name

885

and value._dbus_interface == interface_name):

886

return value.__get__(self)

887

623

for name in (property_name,

624

property_name + "_dbus_property"):

625

prop = getattr(self, name, None)

626

if (prop is None

627

or not self._is_dbus_property(prop)

628

or prop._dbus_name != property_name

629

or (interface_name and prop._dbus_interface

630

and interface_name != prop._dbus_interface)):

631

continue

632

return prop

888

633

# No such property

889

634

raise DBusPropertyNotFound(self.dbus_object_path + ":"

890

635

+ interface_name + "."

914

659

# The byte_arrays option is not supported yet on

915

660

# signatures other than "ay".

916

661

if prop._dbus_signature != "ay":

917

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

918

"'ay' signature {!r}"

919

.format(prop._dbus_signature))

920

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

921

for byte in value))

662

raise ValueError

663

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

664

for byte in value))

922

665

prop(value)

923

666

924

667

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

926

669

def GetAll(self, interface_name):

927

670

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

928

671

standard.

929

672

930

673

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

931

674

"""

932

properties = {}

933

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

675

all = {}

676

for name, prop in self._get_all_dbus_properties():

934

677

if (interface_name

935

678

and interface_name != prop._dbus_interface):

936

679

# Interface non-empty but did not match

940

683

continue

941

684

value = prop()

942

685

if not hasattr(value, "variant_level"):

943

properties[name] = value

686

all[name] = value

944

687

continue

945

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

946

value.variant_level+1)

947

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

948

949

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

950

def PropertiesChanged(self, interface_name, changed_properties,

951

invalidated_properties):

952

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

953

standard.

954

"""

955

pass

688

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

689

value.variant_level+1)

690

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

956

691

957

692

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

958

693

out_signature="s",

959

694

path_keyword='object_path',

960

695

connection_keyword='connection')

961

696

def Introspect(self, object_path, connection):

962

"""Overloading of standard D-Bus method.

963

964

Inserts property tags and interface annotation tags.

697

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

965

698

"""

966

699

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

967

700

connection)

974

707

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

975

708

return e

976

709

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

977

# Add property tags

978

710

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

979

711

for name, prop

980

in self._get_all_dbus_things("property")

712

in self._get_all_dbus_properties()

981

713

if prop._dbus_interface

982

714

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

983

715

if_tag.appendChild(tag)

984

# Add annotation tags

985

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

986

for tag in if_tag.getElementsByTagName(typ):

987

annots = dict()

988

for name, prop in (self.

989

_get_all_dbus_things(typ)):

990

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

991

and prop._dbus_interface

992

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

993

annots.update(getattr

994

(prop,

995

"_dbus_annotations",

996

{}))

997

for name, value in annots.items():

998

ann_tag = document.createElement(

999

"annotation")

1000

ann_tag.setAttribute("name", name)

1001

ann_tag.setAttribute("value", value)

1002

tag.appendChild(ann_tag)

1003

# Add interface annotation tags

1004

for annotation, value in dict(

1005

itertools.chain.from_iterable(

1006

annotations().items()

1007

for name, annotations in

1008

self._get_all_dbus_things("interface")

1009

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

1010

)).items():

1011

ann_tag = document.createElement("annotation")

1012

ann_tag.setAttribute("name", annotation)

1013

ann_tag.setAttribute("value", value)

1014

if_tag.appendChild(ann_tag)

1015

716

# Add the names to the return values for the

1016

717

# "org.freedesktop.DBus.Properties" methods

1017

718

if (if_tag.getAttribute("name")

1032

733

except (AttributeError, xml.dom.DOMException,

1033

734

xml.parsers.expat.ExpatError) as error:

1034

735

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

1035

exc_info=error)

736

error)

1036

737

return xmlstring

1037

738

1038

739

1039

def datetime_to_dbus(dt, variant_level=0):

1040

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

1041

if dt is None:

1042

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

1043

return dbus.String(dt.isoformat(),

1044

variant_level=variant_level)

1045

1046

1047

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1048

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

1049

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

1050

interface names according to the "alt_interface_names" mapping.

1051

Usage:

1052

1053

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

1054

"net.example.AlternateInterface"})

1055

class SampleDBusObject(dbus.service.Object):

1056

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

1057

def SampleDBusMethod():

1058

pass

1059

1060

The above "SampleDBusMethod" on "SampleDBusObject" will be

1061

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

1062

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

1063

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

1064

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

1065

1066

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

1067

(from DBusObjectWithProperties) and interfaces (from the

1068

dbus_interface_annotations decorator).

1069

"""

1070

def wrapper(cls):

1071

for orig_interface_name, alt_interface_name in (

1072

alt_interface_names.items()):

1073

attr = {}

1074

interface_names = set()

1075

# Go though all attributes of the class

1076

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

1077

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

1078

# with the wrong interface name

1079

if (not hasattr(attribute, "_dbus_interface")

1080

or not attribute._dbus_interface

1081

.startswith(orig_interface_name)):

1082

continue

1083

# Create an alternate D-Bus interface name based on

1084

# the current name

1085

alt_interface = (attribute._dbus_interface

1086

.replace(orig_interface_name,

1087

alt_interface_name))

1088

interface_names.add(alt_interface)

1089

# Is this a D-Bus signal?

1090

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

1091

# Extract the original non-method undecorated

1092

# function by black magic

1093

nonmethod_func = (dict(

1094

zip(attribute.func_code.co_freevars,

1095

attribute.__closure__))["func"]

1096

.cell_contents)

1097

# Create a new, but exactly alike, function

1098

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

1099

# with the alternate D-Bus interface name

1100

new_function = (dbus.service.signal

1101

(alt_interface,

1102

attribute._dbus_signature)

1103

(types.FunctionType(

1104

nonmethod_func.func_code,

1105

nonmethod_func.func_globals,

1106

nonmethod_func.func_name,

1107

nonmethod_func.func_defaults,

1108

nonmethod_func.func_closure)))

1109

# Copy annotations, if any

1110

try:

1111

new_function._dbus_annotations = (

1112

dict(attribute._dbus_annotations))

1113

except AttributeError:

1114

pass

1115

# Define a creator of a function to call both the

1116

# original and alternate functions, so both the

1117

# original and alternate signals gets sent when

1118

# the function is called

1119

def fixscope(func1, func2):

1120

"""This function is a scope container to pass

1121

func1 and func2 to the "call_both" function

1122

outside of its arguments"""

1123

def call_both(*args, **kwargs):

1124

"""This function will emit two D-Bus

1125

signals by calling func1 and func2"""

1126

func1(*args, **kwargs)

1127

func2(*args, **kwargs)

1128

return call_both

1129

# Create the "call_both" function and add it to

1130

# the class

1131

attr[attrname] = fixscope(attribute, new_function)

1132

# Is this a D-Bus method?

1133

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

1134

# Create a new, but exactly alike, function

1135

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

1136

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

1137

# to the class.

1138

attr[attrname] = (dbus.service.method

1139

(alt_interface,

1140

attribute._dbus_in_signature,

1141

attribute._dbus_out_signature)

1142

(types.FunctionType

1143

(attribute.func_code,

1144

attribute.func_globals,

1145

attribute.func_name,

1146

attribute.func_defaults,

1147

attribute.func_closure)))

1148

# Copy annotations, if any

1149

try:

1150

attr[attrname]._dbus_annotations = (

1151

dict(attribute._dbus_annotations))

1152

except AttributeError:

1153

pass

1154

# Is this a D-Bus property?

1155

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

1156

# Create a new, but exactly alike, function

1157

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

1158

# property with the alternate D-Bus interface

1159

# name. Add it to the class.

1160

attr[attrname] = (dbus_service_property

1161

(alt_interface,

1162

attribute._dbus_signature,

1163

attribute._dbus_access,

1164

attribute

1165

._dbus_get_args_options

1166

["byte_arrays"])

1167

(types.FunctionType

1168

(attribute.func_code,

1169

attribute.func_globals,

1170

attribute.func_name,

1171

attribute.func_defaults,

1172

attribute.func_closure)))

1173

# Copy annotations, if any

1174

try:

1175

attr[attrname]._dbus_annotations = (

1176

dict(attribute._dbus_annotations))

1177

except AttributeError:

1178

pass

1179

# Is this a D-Bus interface?

1180

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

1181

# Create a new, but exactly alike, function

1182

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

1183

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

1184

# to the class.

1185

attr[attrname] = (dbus_interface_annotations

1186

(alt_interface)

1187

(types.FunctionType

1188

(attribute.func_code,

1189

attribute.func_globals,

1190

attribute.func_name,

1191

attribute.func_defaults,

1192

attribute.func_closure)))

1193

if deprecate:

1194

# Deprecate all alternate interfaces

1195

iname="_AlternateDBusNames_interface_annotation{}"

1196

for interface_name in interface_names:

1197

@dbus_interface_annotations(interface_name)

1198

def func(self):

1199

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

1200

"true" }

1201

# Find an unused name

1202

for aname in (iname.format(i)

1203

for i in itertools.count()):

1204

if aname not in attr:

1205

attr[aname] = func

1206

break

1207

if interface_names:

1208

# Replace the class with a new subclass of it with

1209

# methods, signals, etc. as created above.

1210

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

1211

(cls,), attr)

1212

return cls

1213

return wrapper

1214

1215

1216

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

1217

"se.bsnet.fukt.Mandos"})

1218

740

class ClientDBus(Client, DBusObjectWithProperties):

1219

741

"""A Client class using D-Bus

1220

742

1226

748

runtime_expansions = (Client.runtime_expansions

1227

749

+ ("dbus_object_path",))

1228

750

1229

_interface = "se.recompile.Mandos.Client"

1230

1231

751

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

1232

752

1233

753

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

754

self._approvals_pending = 0

1234

755

self.bus = bus

1235

756

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

1236

757

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

1237

758

# the D-Bus

1238

client_object_name = str(self.name).translate(

759

client_object_name = unicode(self.name).translate(

1239

760

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

1240

761

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

1241

762

self.dbus_object_path = (dbus.ObjectPath

1242

763

("/clients/" + client_object_name))

1243

764

DBusObjectWithProperties.__init__(self, self.bus,

1244

765

self.dbus_object_path)

1245

1246

def notifychangeproperty(transform_func,

1247

dbus_name, type_func=lambda x: x,

1248

variant_level=1, invalidate_only=False,

1249

_interface=_interface):

1250

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

1251

its changes to DBus.

1252

1253

transform_fun: Function that takes a value and a variant_level

1254

and transforms it to a D-Bus type.

1255

dbus_name: D-Bus name of the variable

1256

type_func: Function that transform the value before sending it

1257

to the D-Bus. Default: no transform

1258

variant_level: D-Bus variant level. Default: 1

1259

"""

1260

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

1261

def setter(self, value):

1262

if hasattr(self, "dbus_object_path"):

1263

if (not hasattr(self, attrname) or

1264

type_func(getattr(self, attrname, None))

1265

!= type_func(value)):

1266

if invalidate_only:

1267

self.PropertiesChanged(_interface,

1268

dbus.Dictionary(),

1269

dbus.Array

1270

((dbus_name,)))

1271

else:

1272

dbus_value = transform_func(type_func(value),

1273

variant_level

1274

=variant_level)

1275

self.PropertyChanged(dbus.String(dbus_name),

1276

dbus_value)

1277

self.PropertiesChanged(_interface,

1278

dbus.Dictionary({

1279

dbus.String(dbus_name):

1280

dbus_value }), dbus.Array())

1281

setattr(self, attrname, value)

1282

1283

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

1284

1285

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1286

approvals_pending = notifychangeproperty(dbus.Boolean,

1287

"ApprovalPending",

1288

type_func = bool)

1289

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

1290

last_enabled = notifychangeproperty(datetime_to_dbus,

1291

"LastEnabled")

1292

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

1293

type_func = lambda checker:

1294

checker is not None)

1295

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1296

"LastCheckedOK")

1297

last_checker_status = notifychangeproperty(dbus.Int16,

1298

"LastCheckerStatus")

1299

last_approval_request = notifychangeproperty(

1300

datetime_to_dbus, "LastApprovalRequest")

1301

approved_by_default = notifychangeproperty(dbus.Boolean,

1302

"ApprovedByDefault")

1303

approval_delay = notifychangeproperty(dbus.UInt64,

1304

"ApprovalDelay",

1305

type_func =

1306

lambda td: td.total_seconds()

1307

* 1000)

1308

approval_duration = notifychangeproperty(

1309

dbus.UInt64, "ApprovalDuration",

1310

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

1311

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

1312

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

1313

type_func = lambda td:

1314

td.total_seconds() * 1000)

1315

extended_timeout = notifychangeproperty(

1316

dbus.UInt64, "ExtendedTimeout",

1317

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

1318

interval = notifychangeproperty(dbus.UInt64,

1319

"Interval",

1320

type_func =

1321

lambda td: td.total_seconds()

1322

* 1000)

1323

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

1324

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

1325

invalidate_only=True)

1326

1327

del notifychangeproperty

766

767

def _get_approvals_pending(self):

768

return self._approvals_pending

769

def _set_approvals_pending(self, value):

770

old_value = self._approvals_pending

771

self._approvals_pending = value

772

bval = bool(value)

773

if (hasattr(self, "dbus_object_path")

774

and bval is not bool(old_value)):

775

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

776

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

777

dbus_bool)

778

779

approvals_pending = property(_get_approvals_pending,

780

_set_approvals_pending)

781

del _get_approvals_pending, _set_approvals_pending

782

783

@staticmethod

784

def _datetime_to_dbus(dt, variant_level=0):

785

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

786

return dbus.String(dt.isoformat(),

787

variant_level=variant_level)

788

789

def enable(self):

790

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

791

r = Client.enable(self)

792

if oldstate != self.enabled:

793

# Emit D-Bus signals

794

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

795

dbus.Boolean(True, variant_level=1))

796

self.PropertyChanged(

797

dbus.String("LastEnabled"),

798

self._datetime_to_dbus(self.last_enabled,

799

variant_level=1))

800

return r

801

802

def disable(self, quiet = False):

803

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

804

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

805

if not quiet and oldstate != self.enabled:

806

# Emit D-Bus signal

807

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

808

dbus.Boolean(False, variant_level=1))

809

return r

1328

810

1329

811

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

1330

812

try:

1339

821

*args, **kwargs):

1340

822

self.checker_callback_tag = None

1341

823

self.checker = None

824

# Emit D-Bus signal

825

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

826

dbus.Boolean(False, variant_level=1))

1342

827

if os.WIFEXITED(condition):

1343

828

exitstatus = os.WEXITSTATUS(condition)

1344

829

# Emit D-Bus signal

1354

839

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

1355

840

*args, **kwargs)

1356

841

842

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

843

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

844

# Emit D-Bus signal

845

self.PropertyChanged(

846

dbus.String("LastCheckedOK"),

847

(self._datetime_to_dbus(self.last_checked_ok,

848

variant_level=1)))

849

850

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

851

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

852

# Emit D-Bus signal

853

self.PropertyChanged(

854

dbus.String("LastApprovalRequest"),

855

(self._datetime_to_dbus(self.last_approval_request,

856

variant_level=1)))

857

return r

858

1357

859

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

1358

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

860

old_checker = self.checker

861

if self.checker is not None:

862

old_checker_pid = self.checker.pid

863

else:

864

old_checker_pid = None

1359

865

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

1360

866

# Only if new checker process was started

1361

867

if (self.checker is not None

1362

868

and old_checker_pid != self.checker.pid):

1363

869

# Emit D-Bus signal

1364

870

self.CheckerStarted(self.current_checker_command)

871

self.PropertyChanged(

872

dbus.String("CheckerRunning"),

873

dbus.Boolean(True, variant_level=1))

1365

874

return r

1366

875

876

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

877

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

878

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

879

if (old_checker is not None

880

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

881

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

882

dbus.Boolean(False, variant_level=1))

883

return r

884

1367

885

def _reset_approved(self):

1368

self.approved = None

886

self._approved = None

1369

887

return False

1370

888

1371

889

def approve(self, value=True):

1372

self.approved = value

1373

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

1374

* 1000), self._reset_approved)

1375

890

self.send_changedstate()

891

self._approved = value

892

gobject.timeout_add(self._timedelta_to_milliseconds

893

(self.approval_duration),

894

self._reset_approved)

895

1376

896

1377

897

## D-Bus methods, signals & properties

1378

1379

## Interfaces

898

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

1380

899

1381

900

## Signals

1382

901

1393

912

pass

1394

913

1395

914

# PropertyChanged - signal

1396

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

1397

915

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

1398

916

def PropertyChanged(self, property, value):

1399

917

"D-Bus signal"

1469

987

if value is None: # get

1470

988

return dbus.Boolean(self.approved_by_default)

1471

989

self.approved_by_default = bool(value)

990

# Emit D-Bus signal

991

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

992

dbus.Boolean(value, variant_level=1))

1472

993

1473

994

# ApprovalDelay - property

1474

995

@dbus_service_property(_interface, signature="t",

1475

996

access="readwrite")

1476

997

def ApprovalDelay_dbus_property(self, value=None):

1477

998

if value is None: # get

1478

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

1479

* 1000)

999

return dbus.UInt64(self.approval_delay_milliseconds())

1480

1000

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

1001

# Emit D-Bus signal

1002

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

1003

dbus.UInt64(value, variant_level=1))

1481

1004

1482

1005

# ApprovalDuration - property

1483

1006

@dbus_service_property(_interface, signature="t",

1484

1007

access="readwrite")

1485

1008

def ApprovalDuration_dbus_property(self, value=None):

1486

1009

if value is None: # get

1487

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

1488

* 1000)

1010

return dbus.UInt64(self._timedelta_to_milliseconds(

1011

self.approval_duration))

1489

1012

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

1013

# Emit D-Bus signal

1014

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

1015

dbus.UInt64(value, variant_level=1))

1490

1016

1491

1017

# Name - property

1492

1018

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

1504

1030

def Host_dbus_property(self, value=None):

1505

1031

if value is None: # get

1506

1032

return dbus.String(self.host)

1507

self.host = str(value)

1033

self.host = value

1034

# Emit D-Bus signal

1035

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

1036

dbus.String(value, variant_level=1))

1508

1037

1509

1038

# Created - property

1510

1039

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

1511

1040

def Created_dbus_property(self):

1512

return datetime_to_dbus(self.created)

1041

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

1513

1042

1514

1043

# LastEnabled - property

1515

1044

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

1516

1045

def LastEnabled_dbus_property(self):

1517

return datetime_to_dbus(self.last_enabled)

1046

if self.last_enabled is None:

1047

return dbus.String("")

1048

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

1518

1049

1519

1050

# Enabled - property

1520

1051

@dbus_service_property(_interface, signature="b",

1534

1065

if value is not None:

1535

1066

self.checked_ok()

1536

1067

return

1537

return datetime_to_dbus(self.last_checked_ok)

1538

1539

# LastCheckerStatus - property

1540

@dbus_service_property(_interface, signature="n",

1541

access="read")

1542

def LastCheckerStatus_dbus_property(self):

1543

return dbus.Int16(self.last_checker_status)

1544

1545

# Expires - property

1546

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

1547

def Expires_dbus_property(self):

1548

return datetime_to_dbus(self.expires)

1068

if self.last_checked_ok is None:

1069

return dbus.String("")

1070

return dbus.String(self._datetime_to_dbus(self

1071

.last_checked_ok))

1549

1072

1550

1073

# LastApprovalRequest - property

1551

1074

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

1552

1075

def LastApprovalRequest_dbus_property(self):

1553

return datetime_to_dbus(self.last_approval_request)

1076

if self.last_approval_request is None:

1077

return dbus.String("")

1078

return dbus.String(self.

1079

_datetime_to_dbus(self

1080

.last_approval_request))

1554

1081

1555

1082

# Timeout - property

1556

1083

@dbus_service_property(_interface, signature="t",

1557

1084

access="readwrite")

1558

1085

def Timeout_dbus_property(self, value=None):

1559

1086

if value is None: # get

1560

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

1561

old_timeout = self.timeout

1087

return dbus.UInt64(self.timeout_milliseconds())

1562

1088

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

1563

# Reschedule disabling

1564

if self.enabled:

1565

now = datetime.datetime.utcnow()

1566

self.expires += self.timeout - old_timeout

1567

if self.expires <= now:

1568

# The timeout has passed

1569

self.disable()

1570

else:

1571

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

1572

is None):

1573

return

1574

gobject.source_remove(self.disable_initiator_tag)

1575

self.disable_initiator_tag = (

1576

gobject.timeout_add(

1577

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

1578

* 1000), self.disable))

1579

1580

# ExtendedTimeout - property

1581

@dbus_service_property(_interface, signature="t",

1582

access="readwrite")

1583

def ExtendedTimeout_dbus_property(self, value=None):

1584

if value is None: # get

1585

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

1586

* 1000)

1587

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

1089

# Emit D-Bus signal

1090

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

1091

dbus.UInt64(value, variant_level=1))

1092

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

1093

return

1094

# Reschedule timeout

1095

gobject.source_remove(self.disable_initiator_tag)

1096

self.disable_initiator_tag = None

1097

time_to_die = (self.

1098

_timedelta_to_milliseconds((self

1099

.last_checked_ok

1100

+ self.timeout)

1101

- datetime.datetime

1102

.utcnow()))

1103

if time_to_die <= 0:

1104

# The timeout has passed

1105

self.disable()

1106

else:

1107

self.disable_initiator_tag = (gobject.timeout_add

1108

(time_to_die, self.disable))

1588

1109

1589

1110

# Interval - property

1590

1111

@dbus_service_property(_interface, signature="t",

1591

1112

access="readwrite")

1592

1113

def Interval_dbus_property(self, value=None):

1593

1114

if value is None: # get

1594

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

1115

return dbus.UInt64(self.interval_milliseconds())

1595

1116

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

1117

# Emit D-Bus signal

1118

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

1119

dbus.UInt64(value, variant_level=1))

1596

1120

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

1597

1121

return

1598

if self.enabled:

1599

# Reschedule checker run

1600

gobject.source_remove(self.checker_initiator_tag)

1601

self.checker_initiator_tag = (gobject.timeout_add

1602

(value, self.start_checker))

1603

self.start_checker() # Start one now, too

1604

1122

# Reschedule checker run

1123

gobject.source_remove(self.checker_initiator_tag)

1124

self.checker_initiator_tag = (gobject.timeout_add

1125

(value, self.start_checker))

1126

self.start_checker() # Start one now, too

1127

1605

1128

# Checker - property

1606

1129

@dbus_service_property(_interface, signature="s",

1607

1130

access="readwrite")

1608

1131

def Checker_dbus_property(self, value=None):

1609

1132

if value is None: # get

1610

1133

return dbus.String(self.checker_command)

1611

self.checker_command = str(value)

1134

self.checker_command = value

1135

# Emit D-Bus signal

1136

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

1137

dbus.String(self.checker_command,

1138

variant_level=1))

1612

1139

1613

1140

# CheckerRunning - property

1614

1141

@dbus_service_property(_interface, signature="b",

1630

1157

@dbus_service_property(_interface, signature="ay",

1631

1158

access="write", byte_arrays=True)

1632

1159

def Secret_dbus_property(self, value):

1633

self.secret = bytes(value)

1160

self.secret = str(value)

1634

1161

1635

1162

del _interface

1636

1163

1641

1168

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

1642

1169

if not self._pipe.recv():

1643

1170

raise KeyError()

1644

1171

1645

1172

def __getattribute__(self, name):

1646

if name == '_pipe':

1173

if(name == '_pipe'):

1647

1174

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

1648

1175

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

1649

1176

data = self._pipe.recv()

1654

1181

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

1655

1182

return self._pipe.recv()[1]

1656

1183

return func

1657

1184

1658

1185

def __setattr__(self, name, value):

1659

if name == '_pipe':

1186

if(name == '_pipe'):

1660

1187

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

1661

1188

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

1662

1189

1670

1197

def handle(self):

1671

1198

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

1672

1199

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

1673

str(self.client_address))

1200

unicode(self.client_address))

1674

1201

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

1675

1202

self.server.child_pipe.fileno())

1676

1203

1677

1204

session = (gnutls.connection

1678

1205

.ClientSession(self.request,

1679

1206

gnutls.connection

1680

1207

.X509Credentials()))

1681

1208

1682

1209

# Note: gnutls.connection.X509Credentials is really a

1683

1210

# generic GnuTLS certificate credentials object so long as

1684

1211

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

1685

1212

# here despite using OpenPGP certificates.

1686

1213

1687

1214

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

1688

1215

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

1689

1216

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

1695

1222

(gnutls.library.functions

1696

1223

.gnutls_priority_set_direct(session._c_object,

1697

1224

priority, None))

1698

1225

1699

1226

# Start communication using the Mandos protocol

1700

1227

# Get protocol number

1701

1228

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

1702

1229

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

1703

1230

try:

1704

1231

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

1705

raise RuntimeError(line)

1232

raise RuntimeError

1706

1233

except (ValueError, IndexError, RuntimeError) as error:

1707

1234

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

1708

1235

return

1709

1236

1710

1237

# Start GnuTLS connection

1711

1238

try:

1712

1239

session.handshake()

1716

1243

# established. Just abandon the request.

1717

1244

return

1718

1245

logger.debug("Handshake succeeded")

1719

1246

1720

1247

approval_required = False

1721

1248

try:

1722

1249

try:

1727

1254

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

1728

1255

return

1729

1256

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

1730

1257

1731

1258

try:

1732

1259

client = ProxyClient(child_pipe, fpr,

1733

1260

self.client_address)

1745

1272

client.name)

1746

1273

if self.server.use_dbus:

1747

1274

# Emit D-Bus signal

1748

client.Rejected("Disabled")

1275

client.Rejected("Disabled")

1749

1276

return

1750

1277

1751

if client.approved or not client.approval_delay:

1278

if client._approved or not client.approval_delay:

1752

1279

#We are approved or approval is disabled

1753

1280

break

1754

elif client.approved is None:

1281

elif client._approved is None:

1755

1282

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

1756

1283

client.name)

1757

1284

if self.server.use_dbus:

1758

1285

# Emit D-Bus signal

1759

1286

client.NeedApproval(

1760

client.approval_delay.total_seconds()

1761

* 1000, client.approved_by_default)

1287

client.approval_delay_milliseconds(),

1288

client.approved_by_default)

1762

1289

else:

1763

1290

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

1764

1291

client.name)

1768

1295

return

1769

1296

1770

1297

#wait until timeout or approved

1298

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

1771

1299

time = datetime.datetime.now()

1772

1300

client.changedstate.acquire()

1773

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

1301

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

1774

1302

client.changedstate.release()

1775

1303

time2 = datetime.datetime.now()

1776

1304

if (time2 - time) >= delay:

1792

1320

try:

1793

1321

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

1794

1322

except gnutls.errors.GNUTLSError as error:

1795

logger.warning("gnutls send failed",

1796

exc_info=error)

1323

logger.warning("gnutls send failed")

1797

1324

return

1798

1325

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

1799

1326

sent, len(client.secret)

1800

1327

- (sent_size + sent))

1801

1328

sent_size += sent

1802

1329

1803

1330

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

1804

# bump the timeout using extended_timeout

1805

client.bump_timeout(client.extended_timeout)

1331

# bump the timeout as if seen

1332

client.checked_ok()

1806

1333

if self.server.use_dbus:

1807

1334

# Emit D-Bus signal

1808

1335

client.GotSecret()

1813

1340

try:

1814

1341

session.bye()

1815

1342

except gnutls.errors.GNUTLSError as error:

1816

logger.warning("GnuTLS bye failed",

1817

exc_info=error)

1343

logger.warning("GnuTLS bye failed")

1818

1344

1819

1345

@staticmethod

1820

1346

def peer_certificate(session):

1876

1402

# Convert the buffer to a Python bytestring

1877

1403

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

1878

1404

# Convert the bytestring to hexadecimal notation

1879

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

1405

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

1880

1406

return hex_fpr

1881

1407

1882

1408

1885

1411

def sub_process_main(self, request, address):

1886

1412

try:

1887

1413

self.finish_request(request, address)

1888

except Exception:

1414

except:

1889

1415

self.handle_error(request, address)

1890

1416

self.close_request(request)

1891

1417

1892

1418

def process_request(self, request, address):

1893

1419

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

1894

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

1895

args = (request, address))

1896

proc.start()

1897

return proc

1898

1420

multiprocessing.Process(target = self.sub_process_main,

1421

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

1899

1422

1900

1423

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1901

1424

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

1905

1428

This function creates a new pipe in self.pipe

1906

1429

"""

1907

1430

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1908

1909

proc = MultiprocessingMixIn.process_request(self, request,

1910

client_address)

1431

1432

super(MultiprocessingMixInWithPipe,

1433

self).process_request(request, client_address)

1911

1434

self.child_pipe.close()

1912

self.add_pipe(parent_pipe, proc)

1913

1914

def add_pipe(self, parent_pipe, proc):

1435

self.add_pipe(parent_pipe)

1436

1437

def add_pipe(self, parent_pipe):

1915

1438

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

1916

raise NotImplementedError()

1917

1439

raise NotImplementedError

1918

1440

1919

1441

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1920

1442

socketserver.TCPServer, object):

1926

1448

use_ipv6: Boolean; to use IPv6 or not

1927

1449

"""

1928

1450

def __init__(self, server_address, RequestHandlerClass,

1929

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

1930

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

1931

creating a new one with socket.socket().

1932

"""

1451

interface=None, use_ipv6=True):

1933

1452

self.interface = interface

1934

1453

if use_ipv6:

1935

1454

self.address_family = socket.AF_INET6

1936

if socketfd is not None:

1937

# Save the file descriptor

1938

self.socketfd = socketfd

1939

# Save the original socket.socket() function

1940

self.socket_socket = socket.socket

1941

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

1942

#

1943

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

1944

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

1945

# patching socket.socket.)

1946

#

1947

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

1948

@functools.wraps(socket.socket)

1949

def socket_wrapper(*args, **kwargs):

1950

# Restore original function so subsequent calls are

1951

# not affected.

1952

socket.socket = self.socket_socket

1953

del self.socket_socket

1954

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

1955

# saved file descriptor.

1956

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

1957

# Replace socket.socket() function with wrapper

1958

socket.socket = socket_wrapper

1959

# The socketserver.TCPServer.__init__ will call

1960

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

1961

# socket_wrapper(), if socketfd was set.

1962

1455

socketserver.TCPServer.__init__(self, server_address,

1963

1456

RequestHandlerClass)

1964

1965

1457

def server_bind(self):

1966

1458

"""This overrides the normal server_bind() function

1967

1459

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

1975

1467

try:

1976

1468

self.socket.setsockopt(socket.SOL_SOCKET,

1977

1469

SO_BINDTODEVICE,

1978

(self.interface + "\0")

1979

.encode("utf-8"))

1470

str(self.interface

1471

+ '\0'))

1980

1472

except socket.error as error:

1981

if error.errno == errno.EPERM:

1982

logger.error("No permission to bind to"

1983

" interface %s", self.interface)

1984

elif error.errno == errno.ENOPROTOOPT:

1473

if error[0] == errno.EPERM:

1474

logger.error("No permission to"

1475

" bind to interface %s",

1476

self.interface)

1477

elif error[0] == errno.ENOPROTOOPT:

1985

1478

logger.error("SO_BINDTODEVICE not available;"

1986

1479

" cannot bind to interface %s",

1987

1480

self.interface)

1988

elif error.errno == errno.ENODEV:

1989

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

1990

" cannot bind", self.interface)

1991

1481

else:

1992

1482

raise

1993

1483

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

1996

1486

if self.address_family == socket.AF_INET6:

1997

1487

any_address = "::" # in6addr_any

1998

1488

else:

1999

any_address = "0.0.0.0" # INADDR_ANY

1489

any_address = socket.INADDR_ANY

2000

1490

self.server_address = (any_address,

2001

1491

self.server_address[1])

2002

1492

elif not self.server_address[1]:

2023

1513

"""

2024

1514

def __init__(self, server_address, RequestHandlerClass,

2025

1515

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

2026

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

1516

gnutls_priority=None, use_dbus=True):

2027

1517

self.enabled = False

2028

1518

self.clients = clients

2029

1519

if self.clients is None:

2030

self.clients = {}

1520

self.clients = set()

2031

1521

self.use_dbus = use_dbus

2032

1522

self.gnutls_priority = gnutls_priority

2033

1523

IPv6_TCPServer.__init__(self, server_address,

2034

1524

RequestHandlerClass,

2035

1525

interface = interface,

2036

use_ipv6 = use_ipv6,

2037

socketfd = socketfd)

1526

use_ipv6 = use_ipv6)

2038

1527

def server_activate(self):

2039

1528

if self.enabled:

2040

1529

return socketserver.TCPServer.server_activate(self)

2041

2042

1530

def enable(self):

2043

1531

self.enabled = True

2044

2045

def add_pipe(self, parent_pipe, proc):

1532

def add_pipe(self, parent_pipe):

2046

1533

# Call "handle_ipc" for both data and EOF events

2047

1534

gobject.io_add_watch(parent_pipe.fileno(),

2048

1535

gobject.IO_IN | gobject.IO_HUP,

2049

1536

functools.partial(self.handle_ipc,

2050

parent_pipe =

2051

parent_pipe,

2052

proc = proc))

2053

1537

parent_pipe = parent_pipe))

1538

2054

1539

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

2055

proc = None, client_object=None):

2056

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

2057

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

2058

# Wait for other process to exit

2059

proc.join()

1540

client_object=None):

1541

condition_names = {

1542

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

1543

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

1544

# blocking).

1545

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

1546

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

1547

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

1548

# broken, usually for pipes and

1549

# sockets).

1550

}

1551

conditions_string = ' | '.join(name

1552

for cond, name in

1553

condition_names.iteritems()

1554

if cond & condition)

1555

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

1556

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

2060

1557

return False

2061

1558

2062

1559

# Read a request from the child

2067

1564

fpr = request[1]

2068

1565

address = request[2]

2069

1566

2070

for c in self.clients.itervalues():

1567

for c in self.clients:

2071

1568

if c.fingerprint == fpr:

2072

1569

client = c

2073

1570

break

2076

1573

"dress: %s", fpr, address)

2077

1574

if self.use_dbus:

2078

1575

# Emit D-Bus signal

2079

mandos_dbus_service.ClientNotFound(fpr,

2080

address[0])

1576

mandos_dbus_service.ClientNotFound(fpr, address[0])

2081

1577

parent_pipe.send(False)

2082

1578

return False

2083

1579

2084

1580

gobject.io_add_watch(parent_pipe.fileno(),

2085

1581

gobject.IO_IN | gobject.IO_HUP,

2086

1582

functools.partial(self.handle_ipc,

2087

parent_pipe =

2088

parent_pipe,

2089

proc = proc,

2090

client_object =

2091

client))

1583

parent_pipe = parent_pipe,

1584

client_object = client))

2092

1585

parent_pipe.send(True)

2093

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

2094

# same fileno

1586

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

2095

1587

return False

2096

1588

if command == 'funcall':

2097

1589

funcname = request[1]

2098

1590

args = request[2]

2099

1591

kwargs = request[3]

2100

1592

2101

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

2102

funcname)(*args,

2103

**kwargs)))

2104

1593

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

1594

2105

1595

if command == 'getattr':

2106

1596

attrname = request[1]

2107

1597

if callable(client_object.__getattribute__(attrname)):

2108

1598

parent_pipe.send(('function',))

2109

1599

else:

2110

parent_pipe.send(('data', client_object

2111

.__getattribute__(attrname)))

1600

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

2112

1601

2113

1602

if command == 'setattr':

2114

1603

attrname = request[1]

2115

1604

value = request[2]

2116

1605

setattr(client_object, attrname, value)

2117

1606

2118

1607

return True

2119

1608

2120

1609

2121

def rfc3339_duration_to_delta(duration):

2122

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

2123

2124

>>> rfc3339_duration_to_delta("P7D")

2125

datetime.timedelta(7)

2126

>>> rfc3339_duration_to_delta("PT60S")

2127

datetime.timedelta(0, 60)

2128

>>> rfc3339_duration_to_delta("PT60M")

2129

datetime.timedelta(0, 3600)

2130

>>> rfc3339_duration_to_delta("PT24H")

2131

datetime.timedelta(1)

2132

>>> rfc3339_duration_to_delta("P1W")

2133

datetime.timedelta(7)

2134

>>> rfc3339_duration_to_delta("PT5M30S")

2135

datetime.timedelta(0, 330)

2136

>>> rfc3339_duration_to_delta("P1DT3M20S")

2137

datetime.timedelta(1, 200)

2138

"""

2139

2140

# Parsing an RFC 3339 duration with regular expressions is not

2141

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

2142

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

2143

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

2144

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

2145

# avoid excessive use of external libraries.

2146

2147

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

2148

Token = collections.namedtuple("Token",

2149

("regexp", # To match token; if

2150

# "value" is not None,

2151

# must have a "group"

2152

# containing digits

2153

"value", # datetime.timedelta or

2154

# None

2155

"followers")) # Tokens valid after

2156

# this token

2157

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

2158

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

2159

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

2160

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

2161

datetime.timedelta(seconds=1),

2162

frozenset((token_end,)))

2163

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

2164

datetime.timedelta(minutes=1),

2165

frozenset((token_second, token_end)))

2166

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

2167

datetime.timedelta(hours=1),

2168

frozenset((token_minute, token_end)))

2169

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

2170

None,

2171

frozenset((token_hour, token_minute,

2172

token_second)))

2173

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

2174

datetime.timedelta(days=1),

2175

frozenset((token_time, token_end)))

2176

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

2177

datetime.timedelta(weeks=4),

2178

frozenset((token_day, token_end)))

2179

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

2180

datetime.timedelta(weeks=52),

2181

frozenset((token_month, token_end)))

2182

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

2183

datetime.timedelta(weeks=1),

2184

frozenset((token_end,)))

2185

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

2186

frozenset((token_year, token_month,

2187

token_day, token_time,

2188

token_week)))

2189

# Define starting values

2190

value = datetime.timedelta() # Value so far

2191

found_token = None

2192

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

2193

s = duration # String left to parse

2194

# Loop until end token is found

2195

while found_token is not token_end:

2196

# Search for any currently valid tokens

2197

for token in followers:

2198

match = token.regexp.match(s)

2199

if match is not None:

2200

# Token found

2201

if token.value is not None:

2202

# Value found, parse digits

2203

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

2204

# Add to value so far

2205

value += factor * token.value

2206

# Strip token from string

2207

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

2208

# Go to found token

2209

found_token = token

2210

# Set valid next tokens

2211

followers = found_token.followers

2212

break

2213

else:

2214

# No currently valid tokens were found

2215

raise ValueError("Invalid RFC 3339 duration")

2216

# End token found

2217

return value

2218

2219

2220

1610

def string_to_delta(interval):

2221

1611

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

2222

1612

2233

1623

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

2234

1624

datetime.timedelta(0, 330)

2235

1625

"""

2236

2237

try:

2238

return rfc3339_duration_to_delta(interval)

2239

except ValueError:

2240

pass

2241

2242

1626

timevalue = datetime.timedelta(0)

2243

1627

for s in interval.split():

2244

1628

try:

2245

suffix = s[-1]

1629

suffix = unicode(s[-1])

2246

1630

value = int(s[:-1])

2247

1631

if suffix == "d":

2248

1632

delta = datetime.timedelta(value)

2255

1639

elif suffix == "w":

2256

1640

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

2257

1641

else:

2258

raise ValueError("Unknown suffix {!r}"

2259

.format(suffix))

2260

except IndexError as e:

1642

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

1643

except (ValueError, IndexError) as e:

2261

1644

raise ValueError(*(e.args))

2262

1645

timevalue += delta

2263

1646

return timevalue

2264

1647

2265

1648

1649

def if_nametoindex(interface):

1650

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

1651

1652

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

1653

global if_nametoindex

1654

try:

1655

if_nametoindex = (ctypes.cdll.LoadLibrary

1656

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

1657

.if_nametoindex)

1658

except (OSError, AttributeError):

1659

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

1660

def if_nametoindex(interface):

1661

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

1662

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

1663

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

1664

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1665

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

1666

interface))

1667

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

1668

ifreq[16:20])[0]

1669

return interface_index

1670

return if_nametoindex(interface)

1671

1672

2266

1673

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

2267

1674

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

2268

1675

2276

1683

sys.exit()

2277

1684

if not noclose:

2278

1685

# Close all standard open file descriptors

2279

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

1686

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

2280

1687

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

2281

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

2282

.format(os.devnull))

1688

raise OSError(errno.ENODEV,

1689

"%s not a character device"

1690

% os.path.devnull)

2283

1691

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

2284

1692

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

2285

1693

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

2294

1702

2295

1703

parser = argparse.ArgumentParser()

2296

1704

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

2297

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

1705

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

2298

1706

help="show version number and exit")

2299

1707

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

2300

1708

help="Bind to interface IF")

2306

1714

help="Run self-test")

2307

1715

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

2308

1716

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

2309

" to terminal", default=None)

1717

" to terminal")

2310

1718

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

2311

1719

help="Debug level for stdout output")

2312

1720

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

2319

1727

" files")

2320

1728

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

2321

1729

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

2322

" system bus interface", default=None)

1730

" system bus interface")

2323

1731

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

2324

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

2325

default=None)

2326

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

2327

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

2328

" state", default=None)

2329

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

2330

help="Specify a file descriptor to a network"

2331

" socket to use instead of creating one")

2332

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

2333

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

2334

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

2335

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

2336

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

2337

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

2338

default=None)

2339

1732

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

2340

1733

options = parser.parse_args()

2341

1734

2342

1735

if options.check:

2343

1736

import doctest

2344

fail_count, test_count = doctest.testmod()

2345

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

1737

doctest.testmod()

1738

sys.exit()

2346

1739

2347

1740

# Default values for config file for server-global settings

2348

1741

server_defaults = { "interface": "",

2350

1743

"port": "",

2351

1744

"debug": "False",

2352

1745

"priority":

2353

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

1746

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

2354

1747

"servicename": "Mandos",

2355

1748

"use_dbus": "True",

2356

1749

"use_ipv6": "True",

2357

1750

"debuglevel": "",

2358

"restore": "True",

2359

"socket": "",

2360

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

2361

"foreground": "False",

2362

"zeroconf": "True",

2363

1751

}

2364

1752

2365

1753

# Parse config file for server-global settings

2370

1758

# Convert the SafeConfigParser object to a dict

2371

1759

server_settings = server_config.defaults()

2372

1760

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

2373

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

1761

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

2374

1762

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

2375

1763

option)

2376

1764

if server_settings["port"]:

2377

1765

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

2378

1766

"port")

2379

if server_settings["socket"]:

2380

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

2381

"socket")

2382

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

2383

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

2384

# happen with a supplied network socket.

2385

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

2386

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

2387

["socket"])

2388

1767

del server_config

2389

1768

2390

1769

# Override the settings from the config file with command line

2391

1770

# options, if set.

2392

1771

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

2393

1772

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

2394

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

2395

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

1773

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

2396

1774

value = getattr(options, option)

2397

1775

if value is not None:

2398

1776

server_settings[option] = value

2399

1777

del options

2400

1778

# Force all strings to be unicode

2401

1779

for option in server_settings.keys():

2402

if isinstance(server_settings[option], bytes):

2403

server_settings[option] = (server_settings[option]

2404

.decode("utf-8"))

2405

# Force all boolean options to be boolean

2406

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

2407

"foreground", "zeroconf"):

2408

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

2409

# Debug implies foreground

2410

if server_settings["debug"]:

2411

server_settings["foreground"] = True

1780

if type(server_settings[option]) is str:

1781

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

2412

1782

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

2413

1783

2414

1784

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

2415

1785

2416

if (not server_settings["zeroconf"] and

2417

not (server_settings["port"]

2418

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

2419

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

2420

" Zeroconf")

2421

2422

1786

# For convenience

2423

1787

debug = server_settings["debug"]

2424

1788

debuglevel = server_settings["debuglevel"]

2425

1789

use_dbus = server_settings["use_dbus"]

2426

1790

use_ipv6 = server_settings["use_ipv6"]

2427

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

2428

stored_state_file)

2429

foreground = server_settings["foreground"]

2430

zeroconf = server_settings["zeroconf"]

2431

2432

if debug:

2433

initlogger(debug, logging.DEBUG)

2434

else:

2435

if not debuglevel:

2436

initlogger(debug)

2437

else:

2438

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

2439

initlogger(debug, level)

2440

1791

2441

1792

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

2442

1793

syslogger.setFormatter(logging.Formatter

2443

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

2444

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

2445

.format(server_settings

2446

["servicename"])))

1794

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

1795

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

1796

% server_settings["servicename"]))

2447

1797

2448

1798

# Parse config file with clients

2449

client_config = configparser.SafeConfigParser(Client

2450

.client_defaults)

1799

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

1800

"interval": "5m",

1801

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

1802

"host": "",

1803

"approval_delay": "0s",

1804

"approval_duration": "1s",

1805

}

1806

client_config = configparser.SafeConfigParser(client_defaults)

2451

1807

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

2452

1808

"clients.conf"))

2453

1809

2454

1810

global mandos_dbus_service

2455

1811

mandos_dbus_service = None

2456

1812

2457

socketfd = None

2458

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

2459

socketfd = server_settings["socket"]

2460

1813

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

2461

1814

server_settings["port"]),

2462

1815

ClientHandler,

2465

1818

use_ipv6=use_ipv6,

2466

1819

gnutls_priority=

2467

1820

server_settings["priority"],

2468

use_dbus=use_dbus,

2469

socketfd=socketfd)

2470

if not foreground:

2471

pidfilename = "/run/mandos.pid"

2472

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

2473

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

2474

pidfile = None

1821

use_dbus=use_dbus)

1822

if not debug:

1823

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

2475

1824

try:

2476

1825

pidfile = open(pidfilename, "w")

2477

except IOError as e:

2478

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

2479

exc_info=e)

1826

except IOError:

1827

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

2480

1828

2481

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

1829

try:

1830

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

1831

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

1832

except KeyError:

2482

1833

try:

2483

uid = pwd.getpwnam(name).pw_uid

2484

gid = pwd.getpwnam(name).pw_gid

2485

break

1834

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

1835

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

2486

1836

except KeyError:

2487

continue

2488

else:

2489

uid = 65534

2490

gid = 65534

1837

try:

1838

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

1839

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

1840

except KeyError:

1841

uid = 65534

1842

gid = 65534

2491

1843

try:

2492

1844

os.setgid(gid)

2493

1845

os.setuid(uid)

2494

1846

except OSError as error:

2495

if error.errno != errno.EPERM:

2496

raise

1847

if error[0] != errno.EPERM:

1848

raise error

2497

1849

1850

if not debug and not debuglevel:

1851

syslogger.setLevel(logging.WARNING)

1852

console.setLevel(logging.WARNING)

1853

if debuglevel:

1854

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

1855

syslogger.setLevel(level)

1856

console.setLevel(level)

1857

2498

1858

if debug:

2499

1859

# Enable all possible GnuTLS debugging

2500

1860

2510

1870

.gnutls_global_set_log_function(debug_gnutls))

2511

1871

2512

1872

# Redirect stdin so all checkers get /dev/null

2513

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

1873

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

2514

1874

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

2515

1875

if null > 2:

2516

1876

os.close(null)

1877

else:

1878

# No console logging

1879

logger.removeHandler(console)

2517

1880

2518

1881

# Need to fork before connecting to D-Bus

2519

if not foreground:

1882

if not debug:

2520

1883

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

2521

1884

daemon()

2522

1885

2523

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

2524

# need to inform gobject that threads will be used.

2525

gobject.threads_init()

2526

2527

1886

global main_loop

2528

1887

# From the Avahi example code

2529

DBusGMainLoop(set_as_default=True)

1888

DBusGMainLoop(set_as_default=True )

2530

1889

main_loop = gobject.MainLoop()

2531

1890

bus = dbus.SystemBus()

2532

1891

# End of Avahi example code

2533

1892

if use_dbus:

2534

1893

try:

2535

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

1894

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

2536

1895

bus, do_not_queue=True)

2537

old_bus_name = (dbus.service.BusName

2538

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

2539

do_not_queue=True))

2540

1896

except dbus.exceptions.NameExistsException as e:

2541

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

1897

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

2542

1898

use_dbus = False

2543

1899

server_settings["use_dbus"] = False

2544

1900

tcp_server.use_dbus = False

2545

if zeroconf:

2546

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2547

service = AvahiServiceToSyslog(name =

2548

server_settings["servicename"],

2549

servicetype = "_mandos._tcp",

2550

protocol = protocol, bus = bus)

2551

if server_settings["interface"]:

2552

service.interface = (if_nametoindex

2553

(server_settings["interface"]

2554

.encode("utf-8")))

1901

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1902

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

1903

servicetype = "_mandos._tcp",

1904

protocol = protocol, bus = bus)

1905

if server_settings["interface"]:

1906

service.interface = (if_nametoindex

1907

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

2555

1908

2556

1909

global multiprocessing_manager

2557

1910

multiprocessing_manager = multiprocessing.Manager()

2559

1912

client_class = Client

2560

1913

if use_dbus:

2561

1914

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

2562

2563

client_settings = Client.config_parser(client_config)

2564

old_client_settings = {}

2565

clients_data = {}

2566

2567

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

2568

global wnull

2569

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

2570

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

2571

# mode

2572

if debug or not foreground:

2573

wnull.close()

2574

2575

# Get client data and settings from last running state.

2576

if server_settings["restore"]:

2577

try:

2578

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

2579

clients_data, old_client_settings = (pickle.load

2580

(stored_state))

2581

os.remove(stored_state_path)

2582

except IOError as e:

2583

if e.errno == errno.ENOENT:

2584

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

2585

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

2586

else:

2587

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

2588

exc_info=e)

2589

raise

2590

except EOFError as e:

2591

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

2592

"EOFError:", exc_info=e)

2593

2594

with PGPEngine() as pgp:

2595

for client_name, client in clients_data.items():

2596

# Skip removed clients

2597

if client_name not in client_settings:

2598

continue

2599

2600

# Decide which value to use after restoring saved state.

2601

# We have three different values: Old config file,

2602

# new config file, and saved state.

2603

# New config value takes precedence if it differs from old

2604

# config value, otherwise use saved state.

2605

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

2606

try:

2607

# For each value in new config, check if it

2608

# differs from the old config value (Except for

2609

# the "secret" attribute)

2610

if (name != "secret" and

2611

value != old_client_settings[client_name]

2612

[name]):

2613

client[name] = value

2614

except KeyError:

2615

pass

2616

2617

# Clients who has passed its expire date can still be

2618

# enabled if its last checker was successful. Clients

2619

# whose checker succeeded before we stored its state is

2620

# assumed to have successfully run all checkers during

2621

# downtime.

2622

if client["enabled"]:

2623

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

2624

if not client["last_checked_ok"]:

2625

logger.warning(

2626

"disabling client {} - Client never "

2627

"performed a successful checker"

2628

.format(client_name))

2629

client["enabled"] = False

2630

elif client["last_checker_status"] != 0:

2631

logger.warning(

2632

"disabling client {} - Client last"

2633

" checker failed with error code {}"

2634

.format(client_name,

2635

client["last_checker_status"]))

2636

client["enabled"] = False

2637

else:

2638

client["expires"] = (datetime.datetime

2639

.utcnow()

2640

+ client["timeout"])

2641

logger.debug("Last checker succeeded,"

2642

" keeping {} enabled"

2643

.format(client_name))

1915

def client_config_items(config, section):

1916

special_settings = {

1917

"approved_by_default":

1918

lambda: config.getboolean(section,

1919

"approved_by_default"),

1920

}

1921

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

2644

1922

try:

2645

client["secret"] = (

2646

pgp.decrypt(client["encrypted_secret"],

2647

client_settings[client_name]

2648

["secret"]))

2649

except PGPError:

2650

# If decryption fails, we use secret from new settings

2651

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

2652

.format(client_name))

2653

client["secret"] = (

2654

client_settings[client_name]["secret"])

2655

2656

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

2657

for client_name in (set(old_client_settings)

2658

- set(client_settings)):

2659

del clients_data[client_name]

2660

for client_name in (set(client_settings)

2661

- set(old_client_settings)):

2662

clients_data[client_name] = client_settings[client_name]

2663

2664

# Create all client objects

2665

for client_name, client in clients_data.items():

2666

tcp_server.clients[client_name] = client_class(

2667

name = client_name, settings = client,

2668

server_settings = server_settings)

2669

1923

yield (name, special_settings[name]())

1924

except KeyError:

1925

yield (name, value)

1926

1927

tcp_server.clients.update(set(

1928

client_class(name = section,

1929

config= dict(client_config_items(

1930

client_config, section)))

1931

for section in client_config.sections()))

2670

1932

if not tcp_server.clients:

2671

1933

logger.warning("No clients defined")

2672

2673

if not foreground:

2674

if pidfile is not None:

2675

try:

2676

with pidfile:

2677

pid = os.getpid()

2678

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

2679

except IOError:

2680

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

2681

pidfilename, pid)

2682

del pidfile

1934

1935

if not debug:

1936

try:

1937

with pidfile:

1938

pid = os.getpid()

1939

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

1940

del pidfile

1941

except IOError:

1942

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

1943

pidfilename, pid)

1944

except NameError:

1945

# "pidfile" was never created

1946

pass

2683

1947

del pidfilename

2684

1948

1949

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

1950

2685

1951

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

2686

1952

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

2687

1953

2688

1954

if use_dbus:

2689

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

2690

"se.bsnet.fukt.Mandos"})

2691

class MandosDBusService(DBusObjectWithProperties):

1955

class MandosDBusService(dbus.service.Object):

2692

1956

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

2693

1957

def __init__(self):

2694

1958

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

2695

_interface = "se.recompile.Mandos"

2696

2697

@dbus_interface_annotations(_interface)

2698

def _foo(self):

2699

return { "org.freedesktop.DBus.Property"

2700

".EmitsChangedSignal":

2701

"false"}

1959

_interface = "se.bsnet.fukt.Mandos"

2702

1960

2703

1961

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

2704

1962

def ClientAdded(self, objpath):

2719

1977

def GetAllClients(self):

2720

1978

"D-Bus method"

2721

1979

return dbus.Array(c.dbus_object_path

2722

for c in

2723

tcp_server.clients.itervalues())

1980

for c in tcp_server.clients)

2724

1981

2725

1982

@dbus.service.method(_interface,

2726

1983

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

2727

1984

def GetAllClientsWithProperties(self):

2728

1985

"D-Bus method"

2729

1986

return dbus.Dictionary(

2730

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

2731

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

1987

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

1988

for c in tcp_server.clients),

2732

1989

signature="oa{sv}")

2733

1990

2734

1991

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

2735

1992

def RemoveClient(self, object_path):

2736

1993

"D-Bus method"

2737

for c in tcp_server.clients.itervalues():

1994

for c in tcp_server.clients:

2738

1995

if c.dbus_object_path == object_path:

2739

del tcp_server.clients[c.name]

1996

tcp_server.clients.remove(c)

2740

1997

c.remove_from_connection()

2741

1998

# Don't signal anything except ClientRemoved

2742

1999

c.disable(quiet=True)

2751

2008

2752

2009

def cleanup():

2753

2010

"Cleanup function; run on exit"

2754

if zeroconf:

2755

service.cleanup()

2756

2757

multiprocessing.active_children()

2758

wnull.close()

2759

if not (tcp_server.clients or client_settings):

2760

return

2761

2762

# Store client before exiting. Secrets are encrypted with key

2763

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

2764

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

2765

clients = {}

2766

with PGPEngine() as pgp:

2767

for client in tcp_server.clients.itervalues():

2768

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

2769

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

2770

key)

2771

client_dict = {}

2772

2773

# A list of attributes that can not be pickled

2774

# + secret.

2775

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

2776

"checker", "server_settings" }

2777

for name, typ in (inspect.getmembers

2778

(dbus.service.Object)):

2779

exclude.add(name)

2780

2781

client_dict["encrypted_secret"] = (client

2782

.encrypted_secret)

2783

for attr in client.client_structure:

2784

if attr not in exclude:

2785

client_dict[attr] = getattr(client, attr)

2786

2787

clients[client.name] = client_dict

2788

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

2789

2790

try:

2791

with (tempfile.NamedTemporaryFile

2792

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

2793

dir=os.path.dirname(stored_state_path),

2794

delete=False)) as stored_state:

2795

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

2796

tempname=stored_state.name

2797

os.rename(tempname, stored_state_path)

2798

except (IOError, OSError) as e:

2799

if not debug:

2800

try:

2801

os.remove(tempname)

2802

except NameError:

2803

pass

2804

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

2805

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

2806

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

2807

else:

2808

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

2809

exc_info=e)

2810

raise

2811

2812

# Delete all clients, and settings from config

2011

service.cleanup()

2012

2813

2013

while tcp_server.clients:

2814

name, client = tcp_server.clients.popitem()

2014

client = tcp_server.clients.pop()

2815

2015

if use_dbus:

2816

2016

client.remove_from_connection()

2017

client.disable_hook = None

2817

2018

# Don't signal anything except ClientRemoved

2818

2019

client.disable(quiet=True)

2819

2020

if use_dbus:

2820

2021

# Emit D-Bus signal

2821

mandos_dbus_service.ClientRemoved(client

2822

.dbus_object_path,

2022

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2823

2023

client.name)

2824

client_settings.clear()

2825

2024

2826

2025

atexit.register(cleanup)

2827

2026

2828

for client in tcp_server.clients.itervalues():

2027

for client in tcp_server.clients:

2829

2028

if use_dbus:

2830

2029

# Emit D-Bus signal

2831

2030

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2832

# Need to initiate checking of clients

2833

if client.enabled:

2834

client.init_checker()

2031

client.enable()

2835

2032

2836

2033

tcp_server.enable()

2837

2034

tcp_server.server_activate()

2838

2035

2839

2036

# Find out what port we got

2840

if zeroconf:

2841

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

2037

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

2842

2038

if use_ipv6:

2843

2039

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

2844

" flowinfo %d, scope_id %d",

2845

*tcp_server.socket.getsockname())

2040

" flowinfo %d, scope_id %d"

2041

% tcp_server.socket.getsockname())

2846

2042

else: # IPv4

2847

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

2848

*tcp_server.socket.getsockname())

2043

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

2044

% tcp_server.socket.getsockname())

2849

2045

2850

2046

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

2851

2047

2852

2048

try:

2853

if zeroconf:

2854

# From the Avahi example code

2855

try:

2856

service.activate()

2857

except dbus.exceptions.DBusException as error:

2858

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

2859

cleanup()

2860

sys.exit(1)

2861

# End of Avahi example code

2049

# From the Avahi example code

2050

try:

2051

service.activate()

2052

except dbus.exceptions.DBusException as error:

2053

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

2054

cleanup()

2055

sys.exit(1)

2056

# End of Avahi example code

2862

2057

2863

2058

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

2864

2059

lambda *args, **kwargs:

2868

2063

logger.debug("Starting main loop")

2869

2064

main_loop.run()

2870

2065

except AvahiError as error:

2871

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

2066

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

2872

2067

cleanup()

2873

2068

sys.exit(1)

2874

2069

except KeyboardInterrupt: