/mandos/release : revision 237.7.278

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

2

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

3

#

4

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

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

37

39

import SocketServer as socketserver

38

40

import socket

39

41

import argparse

65

67

import types

66

68

import binascii

67

69

import tempfile

70

import itertools

71

import collections

68

72

69

73

import dbus

70

74

import dbus.service

75

79

import ctypes.util

76

80

import xml.dom.minidom

77

81

import inspect

78

import GnuPGInterface

79

82

80

83

try:

81

84

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

85

88

except ImportError:

86

89

SO_BINDTODEVICE = None

87

90

88

version = "1.4.1"

91

if sys.version_info.major == 2:

92

str = unicode

93

94

version = "1.6.8"

89

95

stored_state_file = "clients.pickle"

90

96

91

97

logger = logging.getLogger()

92

syslogger = (logging.handlers.SysLogHandler

93

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

94

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

98

syslogger = None

95

99

96

100

try:

97

101

if_nametoindex = (ctypes.cdll.LoadLibrary

103

107

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

104

108

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

105

109

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

106

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

107

interface))

108

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

109

ifreq[16:20])[0]

110

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

111

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

110

112

return interface_index

111

113

112

114

113

def initlogger(level=logging.WARNING):

115

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

114

116

"""init logger and add loglevel"""

115

117

118

global syslogger

119

syslogger = (logging.handlers.SysLogHandler

120

(facility =

121

logging.handlers.SysLogHandler.LOG_DAEMON,

122

address = "/dev/log"))

116

123

syslogger.setFormatter(logging.Formatter

117

124

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

118

125

' %(message)s'))

119

126

logger.addHandler(syslogger)

120

127

121

console = logging.StreamHandler()

122

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

123

' [%(process)d]:'

124

' %(levelname)s:'

125

' %(message)s'))

126

logger.addHandler(console)

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)

127

135

logger.setLevel(level)

128

136

129

137

135

143

class PGPEngine(object):

136

144

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

137

145

def __init__(self):

138

self.gnupg = GnuPGInterface.GnuPG()

139

146

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

140

self.gnupg = GnuPGInterface.GnuPG()

141

self.gnupg.options.meta_interactive = False

142

self.gnupg.options.homedir = self.tempdir

143

self.gnupg.options.extra_args.extend(['--force-mdc',

144

'--quiet'])

147

self.gnupgargs = ['--batch',

148

'--home', self.tempdir,

149

'--force-mdc',

150

'--quiet',

151

'--no-use-agent']

145

152

146

153

def __enter__(self):

147

154

return self

148

155

149

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

156

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

150

157

self._cleanup()

151

158

return False

152

159

169

176

def password_encode(self, password):

170

177

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

171

178

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

172

return b"mandos" + binascii.hexlify(password)

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

173

186

174

187

def encrypt(self, data, password):

175

self.gnupg.passphrase = self.password_encode(password)

176

with open(os.devnull) as devnull:

177

try:

178

proc = self.gnupg.run(['--symmetric'],

179

create_fhs=['stdin', 'stdout'],

180

attach_fhs={'stderr': devnull})

181

with contextlib.closing(proc.handles['stdin']) as f:

182

f.write(data)

183

with contextlib.closing(proc.handles['stdout']) as f:

184

ciphertext = f.read()

185

proc.wait()

186

except IOError as e:

187

raise PGPError(e)

188

self.gnupg.passphrase = None

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)

189

203

return ciphertext

190

204

191

205

def decrypt(self, data, password):

192

self.gnupg.passphrase = self.password_encode(password)

193

with open(os.devnull) as devnull:

194

try:

195

proc = self.gnupg.run(['--decrypt'],

196

create_fhs=['stdin', 'stdout'],

197

attach_fhs={'stderr': devnull})

198

with contextlib.closing(proc.handles['stdin'] ) as f:

199

f.write(data)

200

with contextlib.closing(proc.handles['stdout']) as f:

201

decrypted_plaintext = f.read()

202

proc.wait()

203

except IOError as e:

204

raise PGPError(e)

205

self.gnupg.passphrase = None

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)

206

222

return decrypted_plaintext

207

223

208

224

209

210

225

class AvahiError(Exception):

211

226

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

212

227

self.value = value

213

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

214

def __unicode__(self):

215

return unicode(repr(self.value))

228

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

229

**kwargs)

216

230

217

231

class AvahiServiceError(AvahiError):

218

232

pass

229

243

Used to optionally bind to the specified interface.

230

244

name: string; Example: 'Mandos'

231

245

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

232

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

246

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

233

247

port: integer; what port to announce

234

248

TXT: list of strings; TXT record for the service

235

249

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

241

255

server: D-Bus Server

242

256

bus: dbus.SystemBus()

243

257

"""

258

244

259

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

245

260

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

246

261

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

259

274

self.server = None

260

275

self.bus = bus

261

276

self.entry_group_state_changed_match = None

277

262

278

def rename(self):

263

279

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

264

280

if self.rename_count >= self.max_renames:

266

282

" after %i retries, exiting.",

267

283

self.rename_count)

268

284

raise AvahiServiceError("Too many renames")

269

self.name = unicode(self.server

270

.GetAlternativeServiceName(self.name))

285

self.name = str(self.server

286

.GetAlternativeServiceName(self.name))

271

287

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

272

288

self.name)

273

289

self.remove()

274

290

try:

275

291

self.add()

276

292

except dbus.exceptions.DBusException as error:

277

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

293

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

278

294

self.cleanup()

279

295

os._exit(1)

280

296

self.rename_count += 1

297

281

298

def remove(self):

282

299

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

283

300

if self.entry_group_state_changed_match is not None:

285

302

self.entry_group_state_changed_match = None

286

303

if self.group is not None:

287

304

self.group.Reset()

305

288

306

def add(self):

289

307

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

290

308

self.remove()

307

325

dbus.UInt16(self.port),

308

326

avahi.string_array_to_txt_array(self.TXT))

309

327

self.group.Commit()

328

310

329

def entry_group_state_changed(self, state, error):

311

330

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

312

331

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

318

337

self.rename()

319

338

elif state == avahi.ENTRY_GROUP_FAILURE:

320

339

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

321

unicode(error))

322

raise AvahiGroupError("State changed: %s"

323

% unicode(error))

340

str(error))

341

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

342

.format(error))

343

324

344

def cleanup(self):

325

345

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

326

346

if self.group is not None:

331

351

pass

332

352

self.group = None

333

353

self.remove()

354

334

355

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

335

356

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

336

357

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

355

376

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

356

377

else:

357

378

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

379

358

380

def activate(self):

359

381

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

360

382

if self.server is None:

367

389

self.server_state_changed)

368

390

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

369

391

392

370

393

class AvahiServiceToSyslog(AvahiService):

371

394

def rename(self):

372

395

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

373

396

ret = AvahiService.rename(self)

374

397

syslogger.setFormatter(logging.Formatter

375

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

376

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

377

% self.name))

398

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

399

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

400

.format(self.name)))

378

401

return ret

379

402

380

def timedelta_to_milliseconds(td):

381

"Convert a datetime.timedelta() to milliseconds"

382

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

383

+ (td.seconds * 1000)

384

+ (td.microseconds // 1000))

385

403

386

404

class Client(object):

387

405

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

388

406

413

431

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

414

432

last_checker_status: integer between 0 and 255 reflecting exit

415

433

status of last checker. -1 reflects crashed

416

checker, or None.

434

checker, -2 means no checker completed yet.

417

435

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

418

436

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

419

437

D-Bus identifiers

420

438

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

421

439

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

422

440

until this client is disabled

423

extended_timeout: extra long timeout when password has been sent

441

extended_timeout: extra long timeout when secret has been sent

424

442

runtime_expansions: Allowed attributes for runtime expansion.

425

443

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

426

444

disabled, or None

445

server_settings: The server_settings dict from main()

427

446

"""

428

447

429

448

runtime_expansions = ("approval_delay", "approval_duration",

430

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

431

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

449

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

450

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

451

"last_approval_request", "last_checked_ok",

432

452

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

433

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

434

"extended_timeout": "15m",

435

"interval": "2m",

453

client_defaults = { "timeout": "PT5M",

454

"extended_timeout": "PT15M",

455

"interval": "PT2M",

436

456

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

437

457

"host": "",

438

"approval_delay": "0s",

439

"approval_duration": "1s",

458

"approval_delay": "PT0S",

459

"approval_duration": "PT1S",

440

460

"approved_by_default": "True",

441

461

"enabled": "True",

442

462

}

443

463

444

def timeout_milliseconds(self):

445

"Return the 'timeout' attribute in milliseconds"

446

return timedelta_to_milliseconds(self.timeout)

447

448

def extended_timeout_milliseconds(self):

449

"Return the 'extended_timeout' attribute in milliseconds"

450

return timedelta_to_milliseconds(self.extended_timeout)

451

452

def interval_milliseconds(self):

453

"Return the 'interval' attribute in milliseconds"

454

return timedelta_to_milliseconds(self.interval)

455

456

def approval_delay_milliseconds(self):

457

return timedelta_to_milliseconds(self.approval_delay)

458

459

464

@staticmethod

460

465

def config_parser(config):

461

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

466

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

462

467

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

463

with exceptions for any special settings as defined above"""

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

"""

464

472

settings = {}

465

473

for client_name in config.sections():

466

474

section = dict(config.items(client_name))

470

478

# Reformat values from string types to Python types

471

479

client["approved_by_default"] = config.getboolean(

472

480

client_name, "approved_by_default")

473

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

481

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

482

"enabled")

474

483

475

484

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

476

485

.replace(" ", ""))

482

491

"rb") as secfile:

483

492

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

484

493

else:

485

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

486

% section)

494

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

495

.format(section))

487

496

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

488

497

client["extended_timeout"] = string_to_delta(

489

498

section["extended_timeout"])

495

504

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

496

505

client["last_approval_request"] = None

497

506

client["last_checked_ok"] = None

498

client["last_checker_status"] = None

499

if client["enabled"]:

500

client["last_enabled"] = datetime.datetime.utcnow()

501

client["expires"] = (datetime.datetime.utcnow()

502

+ client["timeout"])

503

else:

504

client["last_enabled"] = None

505

client["expires"] = None

506

507

client["last_checker_status"] = -2

508

507

509

return settings

508

509

510

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

511

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

512

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

513

attribute."""

510

511

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

514

512

self.name = name

513

if server_settings is None:

514

server_settings = {}

515

self.server_settings = server_settings

515

516

# adding all client settings

516

for setting, value in settings.iteritems():

517

for setting, value in settings.items():

517

518

setattr(self, setting, value)

518

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

519

530

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

520

531

# Uppercase and remove spaces from fingerprint for later

521

532

# comparison purposes with return value from the fingerprint()

522

533

# function

523

534

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

524

self.created = settings.get("created", datetime.datetime.utcnow())

525

535

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

536

datetime.datetime.utcnow())

537

526

538

# attributes specific for this server instance

527

539

self.checker = None

528

540

self.checker_initiator_tag = None

556

568

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

557

569

# Already enabled

558

570

return

559

self.send_changedstate()

560

571

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

561

572

self.enabled = True

562

573

self.last_enabled = datetime.datetime.utcnow()

563

574

self.init_checker()

575

self.send_changedstate()

564

576

565

577

def disable(self, quiet=True):

566

578

"""Disable this client."""

567

579

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

568

580

return False

569

581

if not quiet:

570

self.send_changedstate()

571

if not quiet:

572

582

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

573

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

583

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

574

584

gobject.source_remove(self.disable_initiator_tag)

575

585

self.disable_initiator_tag = None

576

586

self.expires = None

577

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

587

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

578

588

gobject.source_remove(self.checker_initiator_tag)

579

589

self.checker_initiator_tag = None

580

590

self.stop_checker()

581

591

self.enabled = False

592

if not quiet:

593

self.send_changedstate()

582

594

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

583

595

return False

584

596

588

600

def init_checker(self):

589

601

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

590

602

# and every interval from then on.

603

if self.checker_initiator_tag is not None:

604

gobject.source_remove(self.checker_initiator_tag)

591

605

self.checker_initiator_tag = (gobject.timeout_add

592

(self.interval_milliseconds(),

606

(int(self.interval

607

.total_seconds() * 1000),

593

608

self.start_checker))

594

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)

595

612

self.disable_initiator_tag = (gobject.timeout_add

596

(self.timeout_milliseconds(),

597

self.disable))

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

598

616

# Also start a new checker *right now*.

599

617

self.start_checker()

600

618

616

634

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

617

635

vars(self))

618

636

619

def checked_ok(self, timeout=None):

620

"""Bump up the timeout for this client.

621

622

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

623

alive and well.

624

"""

637

def checked_ok(self):

638

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

639

self.last_checked_ok = datetime.datetime.utcnow()

640

self.last_checker_status = 0

641

self.bump_timeout()

642

643

def bump_timeout(self, timeout=None):

644

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

625

645

if timeout is None:

626

646

timeout = self.timeout

627

self.last_checked_ok = datetime.datetime.utcnow()

628

647

if self.disable_initiator_tag is not None:

629

648

gobject.source_remove(self.disable_initiator_tag)

649

self.disable_initiator_tag = None

630

650

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

631

651

self.disable_initiator_tag = (gobject.timeout_add

632

(timedelta_to_milliseconds

633

(timeout), self.disable))

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

634

654

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

635

655

636

656

def need_approval(self):

642

662

If a checker already exists, leave it running and do

643

663

nothing."""

644

664

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

645

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

646

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

647

# client would inevitably timeout, since no checker would get

648

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

665

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

666

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

667

# would inevitably timeout, since no checker would get a

668

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

649

669

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

650

670

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

651

671

# should be.

653

673

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

654

674

try:

655

675

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

656

except (AttributeError, OSError) as error:

657

if (isinstance(error, OSError)

658

and error.errno != errno.ECHILD):

659

raise error

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

660

681

else:

661

682

if pid:

662

683

logger.warning("Checker was a zombie")

665

686

self.current_checker_command)

666

687

# Start a new checker if needed

667

688

if self.checker is None:

689

# Escape attributes for the shell

690

escaped_attrs = { attr:

691

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

692

for attr in self.runtime_expansions }

668

693

try:

669

# In case checker_command has exactly one % operator

670

command = self.checker_command % self.host

671

except TypeError:

672

# Escape attributes for the shell

673

escaped_attrs = dict(

674

(attr,

675

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

676

errors=

677

'replace')))

678

for attr in

679

self.runtime_expansions)

680

681

try:

682

command = self.checker_command % escaped_attrs

683

except TypeError as error:

684

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

685

' %s', self.checker_command, error)

686

return True # Try again later

694

command = self.checker_command % escaped_attrs

695

except TypeError as error:

696

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

697

self.checker_command, exc_info=error)

698

return True # Try again later

687

699

self.current_checker_command = command

688

700

try:

689

701

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

692

704

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

693

705

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

694

706

# always replaced by /dev/null.)

707

# The exception is when not debugging but nevertheless

708

# running in the foreground; use the previously

709

# created wnull.

710

popen_args = {}

711

if (not self.server_settings["debug"]

712

and self.server_settings["foreground"]):

713

popen_args.update({"stdout": wnull,

714

"stderr": wnull })

695

715

self.checker = subprocess.Popen(command,

696

716

close_fds=True,

697

shell=True, cwd="/")

698

self.checker_callback_tag = (gobject.child_watch_add

699

(self.checker.pid,

700

self.checker_callback,

701

data=command))

702

# The checker may have completed before the gobject

703

# watch was added. Check for this.

717

shell=True, cwd="/",

718

**popen_args)

719

except OSError as error:

720

logger.error("Failed to start subprocess",

721

exc_info=error)

722

return True

723

self.checker_callback_tag = (gobject.child_watch_add

724

(self.checker.pid,

725

self.checker_callback,

726

data=command))

727

# The checker may have completed before the gobject

728

# watch was added. Check for this.

729

try:

704

730

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

705

if pid:

706

gobject.source_remove(self.checker_callback_tag)

707

self.checker_callback(pid, status, command)

708

731

except OSError as error:

709

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

710

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)

711

741

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

712

742

return True

713

743

720

750

return

721

751

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

722

752

try:

723

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

753

self.checker.terminate()

724

754

#time.sleep(0.5)

725

755

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

726

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

756

# self.checker.kill()

727

757

except OSError as error:

728

758

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

729

759

raise

746

776

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

747

777

if byte_arrays and signature != "ay":

748

778

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

749

" signature %r" % signature)

779

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

750

780

def decorator(func):

751

781

func._dbus_is_property = True

752

782

func._dbus_interface = dbus_interface

760

790

return decorator

761

791

762

792

793

def dbus_interface_annotations(dbus_interface):

794

"""Decorator for marking functions returning interface annotations

795

796

Usage:

797

798

@dbus_interface_annotations("org.example.Interface")

799

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

800

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

801

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

802

"false"}

803

"""

804

def decorator(func):

805

func._dbus_is_interface = True

806

func._dbus_interface = dbus_interface

807

func._dbus_name = dbus_interface

808

return func

809

return decorator

810

811

812

def dbus_annotations(annotations):

813

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

814

Usage:

815

816

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

817

access="r")

818

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

819

"org.freedesktop.DBus.Property."

820

"EmitsChangedSignal": "false"})

821

def Property_dbus_property(self):

822

return dbus.Boolean(False)

823

"""

824

def decorator(func):

825

func._dbus_annotations = annotations

826

return func

827

return decorator

828

829

763

830

class DBusPropertyException(dbus.exceptions.DBusException):

764

831

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

765

832

"""

766

def __unicode__(self):

767

return unicode(str(self))

768

833

pass

769

834

770

835

class DBusPropertyAccessException(DBusPropertyException):

771

836

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

788

853

"""

789

854

790

855

@staticmethod

791

def _is_dbus_property(obj):

792

return getattr(obj, "_dbus_is_property", False)

856

def _is_dbus_thing(thing):

857

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

858

859

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

860

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

861

"""

862

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

863

False)

793

864

794

def _get_all_dbus_properties(self):

865

def _get_all_dbus_things(self, thing):

795

866

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

796

867

"""

797

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

868

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

869

name),

870

athing.__get__(self))

798

871

for cls in self.__class__.__mro__

799

for name, prop in

800

inspect.getmembers(cls, self._is_dbus_property))

872

for name, athing in

873

inspect.getmembers(cls,

874

self._is_dbus_thing(thing)))

801

875

802

876

def _get_dbus_property(self, interface_name, property_name):

803

877

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

805

879

"""

806

880

for cls in self.__class__.__mro__:

807

881

for name, value in (inspect.getmembers

808

(cls, self._is_dbus_property)):

882

(cls,

883

self._is_dbus_thing("property"))):

809

884

if (value._dbus_name == property_name

810

885

and value._dbus_interface == interface_name):

811

886

return value.__get__(self)

839

914

# The byte_arrays option is not supported yet on

840

915

# signatures other than "ay".

841

916

if prop._dbus_signature != "ay":

842

raise ValueError

843

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

844

for byte in value))

917

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

918

"'ay' signature {!r}"

919

.format(prop._dbus_signature))

920

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

921

for byte in value))

845

922

prop(value)

846

923

847

924

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

853

930

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

854

931

"""

855

932

properties = {}

856

for name, prop in self._get_all_dbus_properties():

933

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

857

934

if (interface_name

858

935

and interface_name != prop._dbus_interface):

859

936

# Interface non-empty but did not match

874

951

path_keyword='object_path',

875

952

connection_keyword='connection')

876

953

def Introspect(self, object_path, connection):

877

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

954

"""Overloading of standard D-Bus method.

955

956

Inserts property tags and interface annotation tags.

878

957

"""

879

958

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

880

959

connection)

887

966

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

888

967

return e

889

968

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

969

# Add property tags

890

970

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

891

971

for name, prop

892

in self._get_all_dbus_properties()

972

in self._get_all_dbus_things("property")

893

973

if prop._dbus_interface

894

974

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

895

975

if_tag.appendChild(tag)

976

# Add annotation tags

977

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

978

for tag in if_tag.getElementsByTagName(typ):

979

annots = dict()

980

for name, prop in (self.

981

_get_all_dbus_things(typ)):

982

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

983

and prop._dbus_interface

984

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

985

annots.update(getattr

986

(prop,

987

"_dbus_annotations",

988

{}))

989

for name, value in annots.items():

990

ann_tag = document.createElement(

991

"annotation")

992

ann_tag.setAttribute("name", name)

993

ann_tag.setAttribute("value", value)

994

tag.appendChild(ann_tag)

995

# Add interface annotation tags

996

for annotation, value in dict(

997

itertools.chain.from_iterable(

998

annotations().items()

999

for name, annotations in

1000

self._get_all_dbus_things("interface")

1001

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

1002

)).items():

1003

ann_tag = document.createElement("annotation")

1004

ann_tag.setAttribute("name", annotation)

1005

ann_tag.setAttribute("value", value)

1006

if_tag.appendChild(ann_tag)

896

1007

# Add the names to the return values for the

897

1008

# "org.freedesktop.DBus.Properties" methods

898

1009

if (if_tag.getAttribute("name")

913

1024

except (AttributeError, xml.dom.DOMException,

914

1025

xml.parsers.expat.ExpatError) as error:

915

1026

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

916

error)

1027

exc_info=error)

917

1028

return xmlstring

918

1029

919

1030

920

def datetime_to_dbus (dt, variant_level=0):

1031

def datetime_to_dbus(dt, variant_level=0):

921

1032

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

922

1033

if dt is None:

923

1034

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

925

1036

variant_level=variant_level)

926

1037

927

1038

928

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

929

.__metaclass__):

930

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

931

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

1039

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1040

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

1041

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

1042

interface names according to the "alt_interface_names" mapping.

1043

Usage:

1044

1045

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

1046

"net.example.AlternateInterface"})

1047

class SampleDBusObject(dbus.service.Object):

1048

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

1049

def SampleDBusMethod():

1050

pass

1051

1052

The above "SampleDBusMethod" on "SampleDBusObject" will be

1053

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

1054

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

1055

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

1056

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

1057

1058

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

1059

(from DBusObjectWithProperties) and interfaces (from the

1060

dbus_interface_annotations decorator).

932

1061

"""

933

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

934

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

935

# methods, signals, or properties in them

936

for base in (b for b in bases

937

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

938

# Go though all attributes of the base class

939

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

1062

def wrapper(cls):

1063

for orig_interface_name, alt_interface_name in (

1064

alt_interface_names.items()):

1065

attr = {}

1066

interface_names = set()

1067

# Go though all attributes of the class

1068

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

940

1069

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

941

1070

# with the wrong interface name

942

1071

if (not hasattr(attribute, "_dbus_interface")

943

1072

or not attribute._dbus_interface

944

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

1073

.startswith(orig_interface_name)):

945

1074

continue

946

1075

# Create an alternate D-Bus interface name based on

947

1076

# the current name

948

1077

alt_interface = (attribute._dbus_interface

949

.replace("se.recompile.Mandos",

950

"se.bsnet.fukt.Mandos"))

1078

.replace(orig_interface_name,

1079

alt_interface_name))

1080

interface_names.add(alt_interface)

951

1081

# Is this a D-Bus signal?

952

1082

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

953

# Extract the original non-method function by

954

# black magic

1083

# Extract the original non-method undecorated

1084

# function by black magic

955

1085

nonmethod_func = (dict(

956

1086

zip(attribute.func_code.co_freevars,

957

1087

attribute.__closure__))["func"]

968

1098

nonmethod_func.func_name,

969

1099

nonmethod_func.func_defaults,

970

1100

nonmethod_func.func_closure)))

1101

# Copy annotations, if any

1102

try:

1103

new_function._dbus_annotations = (

1104

dict(attribute._dbus_annotations))

1105

except AttributeError:

1106

pass

971

1107

# Define a creator of a function to call both the

972

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

973

# signals gets sent when the function is called

1108

# original and alternate functions, so both the

1109

# original and alternate signals gets sent when

1110

# the function is called

974

1111

def fixscope(func1, func2):

975

1112

"""This function is a scope container to pass

976

1113

func1 and func2 to the "call_both" function

983

1120

return call_both

984

1121

# Create the "call_both" function and add it to

985

1122

# the class

986

attr[attrname] = fixscope(attribute,

987

new_function)

1123

attr[attrname] = fixscope(attribute, new_function)

988

1124

# Is this a D-Bus method?

989

1125

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

990

1126

# Create a new, but exactly alike, function

1001

1137

attribute.func_name,

1002

1138

attribute.func_defaults,

1003

1139

attribute.func_closure)))

1140

# Copy annotations, if any

1141

try:

1142

attr[attrname]._dbus_annotations = (

1143

dict(attribute._dbus_annotations))

1144

except AttributeError:

1145

pass

1004

1146

# Is this a D-Bus property?

1005

1147

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

1006

1148

# Create a new, but exactly alike, function

1020

1162

attribute.func_name,

1021

1163

attribute.func_defaults,

1022

1164

attribute.func_closure)))

1023

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

1024

1025

1165

# Copy annotations, if any

1166

try:

1167

attr[attrname]._dbus_annotations = (

1168

dict(attribute._dbus_annotations))

1169

except AttributeError:

1170

pass

1171

# Is this a D-Bus interface?

1172

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

1173

# Create a new, but exactly alike, function

1174

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

1175

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

1176

# to the class.

1177

attr[attrname] = (dbus_interface_annotations

1178

(alt_interface)

1179

(types.FunctionType

1180

(attribute.func_code,

1181

attribute.func_globals,

1182

attribute.func_name,

1183

attribute.func_defaults,

1184

attribute.func_closure)))

1185

if deprecate:

1186

# Deprecate all alternate interfaces

1187

iname="_AlternateDBusNames_interface_annotation{}"

1188

for interface_name in interface_names:

1189

@dbus_interface_annotations(interface_name)

1190

def func(self):

1191

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

1192

"true" }

1193

# Find an unused name

1194

for aname in (iname.format(i)

1195

for i in itertools.count()):

1196

if aname not in attr:

1197

attr[aname] = func

1198

break

1199

if interface_names:

1200

# Replace the class with a new subclass of it with

1201

# methods, signals, etc. as created above.

1202

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

1203

(cls,), attr)

1204

return cls

1205

return wrapper

1206

1207

1208

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

1209

"se.bsnet.fukt.Mandos"})

1026

1210

class ClientDBus(Client, DBusObjectWithProperties):

1027

1211

"""A Client class using D-Bus

1028

1212

1039

1223

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

1040

1224

self.bus = bus

1041

1225

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

1042

self._approvals_pending = 0

1043

1044

self._approvals_pending = 0

1045

1226

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

1046

1227

# the D-Bus

1047

client_object_name = unicode(self.name).translate(

1228

client_object_name = str(self.name).translate(

1048

1229

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

1049

1230

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

1050

1231

self.dbus_object_path = (dbus.ObjectPath

1051

1232

("/clients/" + client_object_name))

1052

1233

DBusObjectWithProperties.__init__(self, self.bus,

1053

1234

self.dbus_object_path)

1054

1235

1055

1236

def notifychangeproperty(transform_func,

1056

1237

dbus_name, type_func=lambda x: x,

1057

1238

variant_level=1):

1065

1246

to the D-Bus. Default: no transform

1066

1247

variant_level: D-Bus variant level. Default: 1

1067

1248

"""

1068

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

1249

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

1069

1250

def setter(self, value):

1070

1251

if hasattr(self, "dbus_object_path"):

1071

1252

if (not hasattr(self, attrname) or

1080

1261

1081

1262

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

1082

1263

1083

1084

1264

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1085

1265

approvals_pending = notifychangeproperty(dbus.Boolean,

1086

1266

"ApprovalPending",

1093

1273

checker is not None)

1094

1274

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1095

1275

"LastCheckedOK")

1276

last_checker_status = notifychangeproperty(dbus.Int16,

1277

"LastCheckerStatus")

1096

1278

last_approval_request = notifychangeproperty(

1097

1279

datetime_to_dbus, "LastApprovalRequest")

1098

1280

approved_by_default = notifychangeproperty(dbus.Boolean,

1100

1282

approval_delay = notifychangeproperty(dbus.UInt64,

1101

1283

"ApprovalDelay",

1102

1284

type_func =

1103

timedelta_to_milliseconds)

1285

lambda td: td.total_seconds()

1286

* 1000)

1104

1287

approval_duration = notifychangeproperty(

1105

1288

dbus.UInt64, "ApprovalDuration",

1106

type_func = timedelta_to_milliseconds)

1289

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

1107

1290

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

1108

1291

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

1109

type_func =

1110

timedelta_to_milliseconds)

1292

type_func = lambda td:

1293

td.total_seconds() * 1000)

1111

1294

extended_timeout = notifychangeproperty(

1112

1295

dbus.UInt64, "ExtendedTimeout",

1113

type_func = timedelta_to_milliseconds)

1296

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

1114

1297

interval = notifychangeproperty(dbus.UInt64,

1115

1298

"Interval",

1116

1299

type_func =

1117

timedelta_to_milliseconds)

1300

lambda td: td.total_seconds()

1301

* 1000)

1118

1302

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

1119

1303

1120

1304

del notifychangeproperty

1148

1332

*args, **kwargs)

1149

1333

1150

1334

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

1151

old_checker = self.checker

1152

if self.checker is not None:

1153

old_checker_pid = self.checker.pid

1154

else:

1155

old_checker_pid = None

1335

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

1156

1336

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

1157

1337

# Only if new checker process was started

1158

1338

if (self.checker is not None

1166

1346

return False

1167

1347

1168

1348

def approve(self, value=True):

1169

self.send_changedstate()

1170

1349

self.approved = value

1171

gobject.timeout_add(timedelta_to_milliseconds

1172

(self.approval_duration),

1173

self._reset_approved)

1174

1350

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

1351

* 1000), self._reset_approved)

1352

self.send_changedstate()

1175

1353

1176

1354

## D-Bus methods, signals & properties

1177

1355

_interface = "se.recompile.Mandos.Client"

1178

1356

1357

## Interfaces

1358

1359

@dbus_interface_annotations(_interface)

1360

def _foo(self):

1361

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

1362

"false"}

1363

1179

1364

## Signals

1180

1365

1181

1366

# CheckerCompleted - signal

1217

1402

"D-Bus signal"

1218

1403

return self.need_approval()

1219

1404

1220

# NeRwequest - signal

1221

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

1222

def NewRequest(self, ip):

1223

"""D-Bus signal

1224

Is sent after a client request a password.

1225

"""

1226

pass

1227

1228

1405

## Methods

1229

1406

1230

1407

# Approve - method

1280

1457

access="readwrite")

1281

1458

def ApprovalDelay_dbus_property(self, value=None):

1282

1459

if value is None: # get

1283

return dbus.UInt64(self.approval_delay_milliseconds())

1460

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

1461

* 1000)

1284

1462

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

1285

1463

1286

1464

# ApprovalDuration - property

1288

1466

access="readwrite")

1289

1467

def ApprovalDuration_dbus_property(self, value=None):

1290

1468

if value is None: # get

1291

return dbus.UInt64(timedelta_to_milliseconds(

1292

self.approval_duration))

1469

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

1470

* 1000)

1293

1471

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

1294

1472

1295

1473

# Name - property

1308

1486

def Host_dbus_property(self, value=None):

1309

1487

if value is None: # get

1310

1488

return dbus.String(self.host)

1311

self.host = unicode(value)

1489

self.host = str(value)

1312

1490

1313

1491

# Created - property

1314

1492

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

1340

1518

return

1341

1519

return datetime_to_dbus(self.last_checked_ok)

1342

1520

1521

# LastCheckerStatus - property

1522

@dbus_service_property(_interface, signature="n",

1523

access="read")

1524

def LastCheckerStatus_dbus_property(self):

1525

return dbus.Int16(self.last_checker_status)

1526

1343

1527

# Expires - property

1344

1528

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

1345

1529

def Expires_dbus_property(self):

1355

1539

access="readwrite")

1356

1540

def Timeout_dbus_property(self, value=None):

1357

1541

if value is None: # get

1358

return dbus.UInt64(self.timeout_milliseconds())

1542

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

1543

old_timeout = self.timeout

1359

1544

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

1360

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

1361

return

1362

# Reschedule timeout

1363

gobject.source_remove(self.disable_initiator_tag)

1364

self.disable_initiator_tag = None

1365

self.expires = None

1366

time_to_die = timedelta_to_milliseconds((self

1367

.last_checked_ok

1368

+ self.timeout)

1369

- datetime.datetime

1370

.utcnow())

1371

if time_to_die <= 0:

1372

# The timeout has passed

1373

self.disable()

1374

else:

1375

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

1376

+ datetime.timedelta(milliseconds =

1377

time_to_die))

1378

self.disable_initiator_tag = (gobject.timeout_add

1379

(time_to_die, self.disable))

1545

# Reschedule disabling

1546

if self.enabled:

1547

now = datetime.datetime.utcnow()

1548

self.expires += self.timeout - old_timeout

1549

if self.expires <= now:

1550

# The timeout has passed

1551

self.disable()

1552

else:

1553

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

1554

is None):

1555

return

1556

gobject.source_remove(self.disable_initiator_tag)

1557

self.disable_initiator_tag = (

1558

gobject.timeout_add(

1559

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

1560

* 1000), self.disable))

1380

1561

1381

1562

# ExtendedTimeout - property

1382

1563

@dbus_service_property(_interface, signature="t",

1383

1564

access="readwrite")

1384

1565

def ExtendedTimeout_dbus_property(self, value=None):

1385

1566

if value is None: # get

1386

return dbus.UInt64(self.extended_timeout_milliseconds())

1567

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

1568

* 1000)

1387

1569

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

1388

1570

1389

1571

# Interval - property

1391

1573

access="readwrite")

1392

1574

def Interval_dbus_property(self, value=None):

1393

1575

if value is None: # get

1394

return dbus.UInt64(self.interval_milliseconds())

1576

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

1395

1577

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

1396

1578

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

1397

1579

return

1408

1590

def Checker_dbus_property(self, value=None):

1409

1591

if value is None: # get

1410

1592

return dbus.String(self.checker_command)

1411

self.checker_command = unicode(value)

1593

self.checker_command = str(value)

1412

1594

1413

1595

# CheckerRunning - property

1414

1596

@dbus_service_property(_interface, signature="b",

1430

1612

@dbus_service_property(_interface, signature="ay",

1431

1613

access="write", byte_arrays=True)

1432

1614

def Secret_dbus_property(self, value):

1433

self.secret = str(value)

1615

self.secret = bytes(value)

1434

1616

1435

1617

del _interface

1436

1618

1461

1643

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

1462

1644

1463

1645

1464

class ClientDBusTransitional(ClientDBus):

1465

__metaclass__ = AlternateDBusNamesMetaclass

1466

1467

1468

1646

class ClientHandler(socketserver.BaseRequestHandler, object):

1469

1647

"""A class to handle client connections.

1470

1648

1474

1652

def handle(self):

1475

1653

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

1476

1654

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

1477

unicode(self.client_address))

1655

str(self.client_address))

1478

1656

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

1479

1657

self.server.child_pipe.fileno())

1480

1658

1506

1684

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

1507

1685

try:

1508

1686

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

1509

raise RuntimeError

1687

raise RuntimeError(line)

1510

1688

except (ValueError, IndexError, RuntimeError) as error:

1511

1689

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

1512

1690

return

1538

1716

except KeyError:

1539

1717

return

1540

1718

1541

if self.server.use_dbus:

1542

# Emit D-Bus signal

1543

client.NewRequest(str(self.client_address))

1544

1545

1719

if client.approval_delay:

1546

1720

delay = client.approval_delay

1547

1721

client.approvals_pending += 1

1565

1739

if self.server.use_dbus:

1566

1740

# Emit D-Bus signal

1567

1741

client.NeedApproval(

1568

client.approval_delay_milliseconds(),

1569

client.approved_by_default)

1742

client.approval_delay.total_seconds()

1743

* 1000, client.approved_by_default)

1570

1744

else:

1571

1745

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

1572

1746

client.name)

1578

1752

#wait until timeout or approved

1579

1753

time = datetime.datetime.now()

1580

1754

client.changedstate.acquire()

1581

(client.changedstate.wait

1582

(float(client.timedelta_to_milliseconds(delay)

1583

/ 1000)))

1755

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

1584

1756

client.changedstate.release()

1585

1757

time2 = datetime.datetime.now()

1586

1758

if (time2 - time) >= delay:

1602

1774

try:

1603

1775

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

1604

1776

except gnutls.errors.GNUTLSError as error:

1605

logger.warning("gnutls send failed")

1777

logger.warning("gnutls send failed",

1778

exc_info=error)

1606

1779

return

1607

1780

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

1608

1781

sent, len(client.secret)

1611

1784

1612

1785

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

1613

1786

# bump the timeout using extended_timeout

1614

client.checked_ok(client.extended_timeout)

1787

client.bump_timeout(client.extended_timeout)

1615

1788

if self.server.use_dbus:

1616

1789

# Emit D-Bus signal

1617

1790

client.GotSecret()

1622

1795

try:

1623

1796

session.bye()

1624

1797

except gnutls.errors.GNUTLSError as error:

1625

logger.warning("GnuTLS bye failed")

1798

logger.warning("GnuTLS bye failed",

1799

exc_info=error)

1626

1800

1627

1801

@staticmethod

1628

1802

def peer_certificate(session):

1700

1874

def process_request(self, request, address):

1701

1875

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

1702

1876

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

1703

args = (request,

1704

address))

1877

args = (request, address))

1705

1878

proc.start()

1706

1879

return proc

1707

1880

1722

1895

1723

1896

def add_pipe(self, parent_pipe, proc):

1724

1897

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

1725

raise NotImplementedError

1898

raise NotImplementedError()

1726

1899

1727

1900

1728

1901

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1735

1908

use_ipv6: Boolean; to use IPv6 or not

1736

1909

"""

1737

1910

def __init__(self, server_address, RequestHandlerClass,

1738

interface=None, use_ipv6=True):

1911

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

1912

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

1913

creating a new one with socket.socket().

1914

"""

1739

1915

self.interface = interface

1740

1916

if use_ipv6:

1741

1917

self.address_family = socket.AF_INET6

1918

if socketfd is not None:

1919

# Save the file descriptor

1920

self.socketfd = socketfd

1921

# Save the original socket.socket() function

1922

self.socket_socket = socket.socket

1923

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

1924

#

1925

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

1926

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

1927

# patching socket.socket.)

1928

#

1929

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

1930

@functools.wraps(socket.socket)

1931

def socket_wrapper(*args, **kwargs):

1932

# Restore original function so subsequent calls are

1933

# not affected.

1934

socket.socket = self.socket_socket

1935

del self.socket_socket

1936

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

1937

# saved file descriptor.

1938

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

1939

# Replace socket.socket() function with wrapper

1940

socket.socket = socket_wrapper

1941

# The socketserver.TCPServer.__init__ will call

1942

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

1943

# socket_wrapper(), if socketfd was set.

1742

1944

socketserver.TCPServer.__init__(self, server_address,

1743

1945

RequestHandlerClass)

1946

1744

1947

def server_bind(self):

1745

1948

"""This overrides the normal server_bind() function

1746

1949

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

1754

1957

try:

1755

1958

self.socket.setsockopt(socket.SOL_SOCKET,

1756

1959

SO_BINDTODEVICE,

1757

str(self.interface

1758

+ '\0'))

1960

(self.interface + "\0")

1961

.encode("utf-8"))

1759

1962

except socket.error as error:

1760

if error[0] == errno.EPERM:

1761

logger.error("No permission to"

1762

" bind to interface %s",

1763

self.interface)

1764

elif error[0] == errno.ENOPROTOOPT:

1963

if error.errno == errno.EPERM:

1964

logger.error("No permission to bind to"

1965

" interface %s", self.interface)

1966

elif error.errno == errno.ENOPROTOOPT:

1765

1967

logger.error("SO_BINDTODEVICE not available;"

1766

1968

" cannot bind to interface %s",

1767

1969

self.interface)

1970

elif error.errno == errno.ENODEV:

1971

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

1972

" cannot bind", self.interface)

1768

1973

else:

1769

1974

raise

1770

1975

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

1773

1978

if self.address_family == socket.AF_INET6:

1774

1979

any_address = "::" # in6addr_any

1775

1980

else:

1776

any_address = socket.INADDR_ANY

1981

any_address = "0.0.0.0" # INADDR_ANY

1777

1982

self.server_address = (any_address,

1778

1983

self.server_address[1])

1779

1984

elif not self.server_address[1]:

1800

2005

"""

1801

2006

def __init__(self, server_address, RequestHandlerClass,

1802

2007

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

1803

gnutls_priority=None, use_dbus=True):

2008

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

1804

2009

self.enabled = False

1805

2010

self.clients = clients

1806

2011

if self.clients is None:

1810

2015

IPv6_TCPServer.__init__(self, server_address,

1811

2016

RequestHandlerClass,

1812

2017

interface = interface,

1813

use_ipv6 = use_ipv6)

2018

use_ipv6 = use_ipv6,

2019

socketfd = socketfd)

1814

2020

def server_activate(self):

1815

2021

if self.enabled:

1816

2022

return socketserver.TCPServer.server_activate(self)

1829

2035

1830

2036

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

1831

2037

proc = None, client_object=None):

1832

condition_names = {

1833

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

1834

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

1835

# blocking).

1836

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

1837

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

1838

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

1839

# broken, usually for pipes and

1840

# sockets).

1841

}

1842

conditions_string = ' | '.join(name

1843

for cond, name in

1844

condition_names.iteritems()

1845

if cond & condition)

1846

2038

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

1847

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

2039

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

1848

2040

# Wait for other process to exit

1849

2041

proc.join()

1850

2042

return False

1908

2100

return True

1909

2101

1910

2102

2103

def rfc3339_duration_to_delta(duration):

2104

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

2105

2106

>>> rfc3339_duration_to_delta("P7D")

2107

datetime.timedelta(7)

2108

>>> rfc3339_duration_to_delta("PT60S")

2109

datetime.timedelta(0, 60)

2110

>>> rfc3339_duration_to_delta("PT60M")

2111

datetime.timedelta(0, 3600)

2112

>>> rfc3339_duration_to_delta("PT24H")

2113

datetime.timedelta(1)

2114

>>> rfc3339_duration_to_delta("P1W")

2115

datetime.timedelta(7)

2116

>>> rfc3339_duration_to_delta("PT5M30S")

2117

datetime.timedelta(0, 330)

2118

>>> rfc3339_duration_to_delta("P1DT3M20S")

2119

datetime.timedelta(1, 200)

2120

"""

2121

2122

# Parsing an RFC 3339 duration with regular expressions is not

2123

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

2124

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

2125

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

2126

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

2127

# avoid excessive use of external libraries.

2128

2129

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

2130

Token = collections.namedtuple("Token",

2131

("regexp", # To match token; if

2132

# "value" is not None,

2133

# must have a "group"

2134

# containing digits

2135

"value", # datetime.timedelta or

2136

# None

2137

"followers")) # Tokens valid after

2138

# this token

2139

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

2140

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

2141

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

2142

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

2143

datetime.timedelta(seconds=1),

2144

frozenset((token_end,)))

2145

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

2146

datetime.timedelta(minutes=1),

2147

frozenset((token_second, token_end)))

2148

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

2149

datetime.timedelta(hours=1),

2150

frozenset((token_minute, token_end)))

2151

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

2152

None,

2153

frozenset((token_hour, token_minute,

2154

token_second)))

2155

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

2156

datetime.timedelta(days=1),

2157

frozenset((token_time, token_end)))

2158

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

2159

datetime.timedelta(weeks=4),

2160

frozenset((token_day, token_end)))

2161

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

2162

datetime.timedelta(weeks=52),

2163

frozenset((token_month, token_end)))

2164

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

2165

datetime.timedelta(weeks=1),

2166

frozenset((token_end,)))

2167

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

2168

frozenset((token_year, token_month,

2169

token_day, token_time,

2170

token_week)))

2171

# Define starting values

2172

value = datetime.timedelta() # Value so far

2173

found_token = None

2174

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

2175

s = duration # String left to parse

2176

# Loop until end token is found

2177

while found_token is not token_end:

2178

# Search for any currently valid tokens

2179

for token in followers:

2180

match = token.regexp.match(s)

2181

if match is not None:

2182

# Token found

2183

if token.value is not None:

2184

# Value found, parse digits

2185

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

2186

# Add to value so far

2187

value += factor * token.value

2188

# Strip token from string

2189

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

2190

# Go to found token

2191

found_token = token

2192

# Set valid next tokens

2193

followers = found_token.followers

2194

break

2195

else:

2196

# No currently valid tokens were found

2197

raise ValueError("Invalid RFC 3339 duration")

2198

# End token found

2199

return value

2200

2201

1911

2202

def string_to_delta(interval):

1912

2203

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

1913

2204

1924

2215

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

1925

2216

datetime.timedelta(0, 330)

1926

2217

"""

2218

2219

try:

2220

return rfc3339_duration_to_delta(interval)

2221

except ValueError:

2222

pass

2223

1927

2224

timevalue = datetime.timedelta(0)

1928

2225

for s in interval.split():

1929

2226

try:

1930

suffix = unicode(s[-1])

2227

suffix = s[-1]

1931

2228

value = int(s[:-1])

1932

2229

if suffix == "d":

1933

2230

delta = datetime.timedelta(value)

1940

2237

elif suffix == "w":

1941

2238

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

1942

2239

else:

1943

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

1944

except (ValueError, IndexError) as e:

2240

raise ValueError("Unknown suffix {!r}"

2241

.format(suffix))

2242

except IndexError as e:

1945

2243

raise ValueError(*(e.args))

1946

2244

timevalue += delta

1947

2245

return timevalue

1960

2258

sys.exit()

1961

2259

if not noclose:

1962

2260

# Close all standard open file descriptors

1963

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

2261

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

1964

2262

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

1965

raise OSError(errno.ENODEV,

1966

"%s not a character device"

1967

% os.path.devnull)

2263

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

2264

.format(os.devnull))

1968

2265

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

1969

2266

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

1970

2267

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

1979

2276

1980

2277

parser = argparse.ArgumentParser()

1981

2278

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

1982

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

2279

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

1983

2280

help="show version number and exit")

1984

2281

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

1985

2282

help="Bind to interface IF")

1991

2288

help="Run self-test")

1992

2289

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

1993

2290

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

1994

" to terminal")

2291

" to terminal", default=None)

1995

2292

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

1996

2293

help="Debug level for stdout output")

1997

2294

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

2004

2301

" files")

2005

2302

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

2006

2303

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

2007

" system bus interface")

2304

" system bus interface", default=None)

2008

2305

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

2009

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

2306

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

2307

default=None)

2010

2308

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

2011

2309

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

2012

" state")

2310

" state", default=None)

2311

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

2312

help="Specify a file descriptor to a network"

2313

" socket to use instead of creating one")

2013

2314

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

2014

2315

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

2316

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

2317

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

2318

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

2319

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

2320

default=None)

2015

2321

2016

2322

options = parser.parse_args()

2017

2323

2018

2324

if options.check:

2019

2325

import doctest

2020

doctest.testmod()

2021

sys.exit()

2326

fail_count, test_count = doctest.testmod()

2327

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

2022

2328

2023

2329

# Default values for config file for server-global settings

2024

2330

server_defaults = { "interface": "",

2026

2332

"port": "",

2027

2333

"debug": "False",

2028

2334

"priority":

2029

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

2335

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

2030

2336

"servicename": "Mandos",

2031

2337

"use_dbus": "True",

2032

2338

"use_ipv6": "True",

2033

2339

"debuglevel": "",

2034

2340

"restore": "True",

2035

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

2341

"socket": "",

2342

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

2343

"foreground": "False",

2344

"zeroconf": "True",

2036

2345

}

2037

2346

2038

2347

# Parse config file for server-global settings

2043

2352

# Convert the SafeConfigParser object to a dict

2044

2353

server_settings = server_config.defaults()

2045

2354

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

2046

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

2355

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

2047

2356

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

2048

2357

option)

2049

2358

if server_settings["port"]:

2050

2359

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

2051

2360

"port")

2361

if server_settings["socket"]:

2362

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

2363

"socket")

2364

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

2365

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

2366

# happen with a supplied network socket.

2367

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

2368

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

2369

["socket"])

2052

2370

del server_config

2053

2371

2054

2372

# Override the settings from the config file with command line

2056

2374

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

2057

2375

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

2058

2376

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

2059

"statedir"):

2377

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

2060

2378

value = getattr(options, option)

2061

2379

if value is not None:

2062

2380

server_settings[option] = value

2063

2381

del options

2064

2382

# Force all strings to be unicode

2065

2383

for option in server_settings.keys():

2066

if type(server_settings[option]) is str:

2067

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

2384

if isinstance(server_settings[option], bytes):

2385

server_settings[option] = (server_settings[option]

2386

.decode("utf-8"))

2387

# Force all boolean options to be boolean

2388

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

2389

"foreground", "zeroconf"):

2390

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

2391

# Debug implies foreground

2392

if server_settings["debug"]:

2393

server_settings["foreground"] = True

2068

2394

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

2069

2395

2070

2396

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

2071

2397

2398

if (not server_settings["zeroconf"] and

2399

not (server_settings["port"]

2400

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

2401

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

2402

" Zeroconf")

2403

2072

2404

# For convenience

2073

2405

debug = server_settings["debug"]

2074

2406

debuglevel = server_settings["debuglevel"]

2076

2408

use_ipv6 = server_settings["use_ipv6"]

2077

2409

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

2078

2410

stored_state_file)

2411

foreground = server_settings["foreground"]

2412

zeroconf = server_settings["zeroconf"]

2079

2413

2080

2414

if debug:

2081

initlogger(logging.DEBUG)

2415

initlogger(debug, logging.DEBUG)

2082

2416

else:

2083

2417

if not debuglevel:

2084

initlogger()

2418

initlogger(debug)

2085

2419

else:

2086

2420

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

2087

initlogger(level)

2421

initlogger(debug, level)

2088

2422

2089

2423

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

2090

2424

syslogger.setFormatter(logging.Formatter

2091

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

2092

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

2093

% server_settings["servicename"]))

2425

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

2426

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

2427

.format(server_settings

2428

["servicename"])))

2094

2429

2095

2430

# Parse config file with clients

2096

client_config = configparser.SafeConfigParser(Client.client_defaults)

2431

client_config = configparser.SafeConfigParser(Client

2432

.client_defaults)

2097

2433

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

2098

2434

"clients.conf"))

2099

2435

2100

2436

global mandos_dbus_service

2101

2437

mandos_dbus_service = None

2102

2438

2439

socketfd = None

2440

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

2441

socketfd = server_settings["socket"]

2103

2442

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

2104

2443

server_settings["port"]),

2105

2444

ClientHandler,

2108

2447

use_ipv6=use_ipv6,

2109

2448

gnutls_priority=

2110

2449

server_settings["priority"],

2111

use_dbus=use_dbus)

2112

if not debug:

2113

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

2450

use_dbus=use_dbus,

2451

socketfd=socketfd)

2452

if not foreground:

2453

pidfilename = "/run/mandos.pid"

2454

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

2455

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

2456

pidfile = None

2114

2457

try:

2115

2458

pidfile = open(pidfilename, "w")

2116

except IOError:

2117

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

2459

except IOError as e:

2460

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

2461

exc_info=e)

2118

2462

2119

try:

2120

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

2121

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

2122

except KeyError:

2463

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

2123

2464

try:

2124

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

2125

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

2465

uid = pwd.getpwnam(name).pw_uid

2466

gid = pwd.getpwnam(name).pw_gid

2467

break

2126

2468

except KeyError:

2127

try:

2128

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

2129

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

2130

except KeyError:

2131

uid = 65534

2132

gid = 65534

2469

continue

2470

else:

2471

uid = 65534

2472

gid = 65534

2133

2473

try:

2134

2474

os.setgid(gid)

2135

2475

os.setuid(uid)

2136

2476

except OSError as error:

2137

if error[0] != errno.EPERM:

2138

raise error

2477

if error.errno != errno.EPERM:

2478

raise

2139

2479

2140

2480

if debug:

2141

2481

# Enable all possible GnuTLS debugging

2152

2492

.gnutls_global_set_log_function(debug_gnutls))

2153

2493

2154

2494

# Redirect stdin so all checkers get /dev/null

2155

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

2495

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

2156

2496

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

2157

2497

if null > 2:

2158

2498

os.close(null)

2159

else:

2160

# No console logging

2161

logger.removeHandler(console)

2162

2499

2163

2500

# Need to fork before connecting to D-Bus

2164

if not debug:

2501

if not foreground:

2165

2502

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

2166

2503

daemon()

2167

2504

2505

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

2506

# need to inform gobject that threads will be used.

2507

gobject.threads_init()

2508

2168

2509

global main_loop

2169

2510

# From the Avahi example code

2170

DBusGMainLoop(set_as_default=True )

2511

DBusGMainLoop(set_as_default=True)

2171

2512

main_loop = gobject.MainLoop()

2172

2513

bus = dbus.SystemBus()

2173

2514

# End of Avahi example code

2179

2520

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

2180

2521

do_not_queue=True))

2181

2522

except dbus.exceptions.NameExistsException as e:

2182

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

2523

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

2183

2524

use_dbus = False

2184

2525

server_settings["use_dbus"] = False

2185

2526

tcp_server.use_dbus = False

2186

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2187

service = AvahiServiceToSyslog(name =

2188

server_settings["servicename"],

2189

servicetype = "_mandos._tcp",

2190

protocol = protocol, bus = bus)

2191

if server_settings["interface"]:

2192

service.interface = (if_nametoindex

2193

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

2527

if zeroconf:

2528

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2529

service = AvahiServiceToSyslog(name =

2530

server_settings["servicename"],

2531

servicetype = "_mandos._tcp",

2532

protocol = protocol, bus = bus)

2533

if server_settings["interface"]:

2534

service.interface = (if_nametoindex

2535

(server_settings["interface"]

2536

.encode("utf-8")))

2194

2537

2195

2538

global multiprocessing_manager

2196

2539

multiprocessing_manager = multiprocessing.Manager()

2197

2540

2198

2541

client_class = Client

2199

2542

if use_dbus:

2200

client_class = functools.partial(ClientDBusTransitional,

2201

bus = bus)

2543

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

2202

2544

2203

2545

client_settings = Client.config_parser(client_config)

2204

2546

old_client_settings = {}

2205

2547

clients_data = {}

2206

2548

2549

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

2550

global wnull

2551

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

2552

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

2553

# mode

2554

if debug or not foreground:

2555

wnull.close()

2556

2207

2557

# Get client data and settings from last running state.

2208

2558

if server_settings["restore"]:

2209

2559

try:

2212

2562

(stored_state))

2213

2563

os.remove(stored_state_path)

2214

2564

except IOError as e:

2215

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

2216

.format(e))

2217

if e.errno != errno.ENOENT:

2565

if e.errno == errno.ENOENT:

2566

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

2567

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

2568

else:

2569

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

2570

exc_info=e)

2218

2571

raise

2572

except EOFError as e:

2573

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

2574

"EOFError:", exc_info=e)

2219

2575

2220

2576

with PGPEngine() as pgp:

2221

for client_name, client in clients_data.iteritems():

2577

for client_name, client in clients_data.items():

2578

# Skip removed clients

2579

if client_name not in client_settings:

2580

continue

2581

2222

2582

# Decide which value to use after restoring saved state.

2223

2583

# We have three different values: Old config file,

2224

2584

# new config file, and saved state.

2238

2598

2239

2599

# Clients who has passed its expire date can still be

2240

2600

# enabled if its last checker was successful. Clients

2241

# whose checker failed before we stored its state is

2242

# assumed to have failed all checkers during downtime.

2601

# whose checker succeeded before we stored its state is

2602

# assumed to have successfully run all checkers during

2603

# downtime.

2243

2604

if client["enabled"]:

2244

2605

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

2245

2606

if not client["last_checked_ok"]:

2246

2607

logger.warning(

2247

"disabling client {0} - Client never "

2248

"performed a successfull checker"

2249

.format(client["name"]))

2608

"disabling client {} - Client never "

2609

"performed a successful checker"

2610

.format(client_name))

2250

2611

client["enabled"] = False

2251

2612

elif client["last_checker_status"] != 0:

2252

2613

logger.warning(

2253

"disabling client {0} - Client "

2254

"last checker failed with error code {1}"

2255

.format(client["name"],

2614

"disabling client {} - Client last"

2615

" checker failed with error code {}"

2616

.format(client_name,

2256

2617

client["last_checker_status"]))

2257

2618

client["enabled"] = False

2258

2619

else:

2259

2620

client["expires"] = (datetime.datetime

2260

2621

.utcnow()

2261

2622

+ client["timeout"])

2262

2623

logger.debug("Last checker succeeded,"

2624

" keeping {} enabled"

2625

.format(client_name))

2263

2626

try:

2264

2627

client["secret"] = (

2265

2628

pgp.decrypt(client["encrypted_secret"],

2267

2630

["secret"]))

2268

2631

except PGPError:

2269

2632

# If decryption fails, we use secret from new settings

2270

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

2633

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

2271

2634

.format(client_name))

2272

2635

client["secret"] = (

2273

2636

client_settings[client_name]["secret"])

2274

2275

2637

2276

2638

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

2277

for client_name in set(old_client_settings) - set(client_settings):

2639

for client_name in (set(old_client_settings)

2640

- set(client_settings)):

2278

2641

del clients_data[client_name]

2279

for client_name in set(client_settings) - set(old_client_settings):

2642

for client_name in (set(client_settings)

2643

- set(old_client_settings)):

2280

2644

clients_data[client_name] = client_settings[client_name]

2281

2282

# Create clients all clients

2283

for client_name, client in clients_data.iteritems():

2645

2646

# Create all client objects

2647

for client_name, client in clients_data.items():

2284

2648

tcp_server.clients[client_name] = client_class(

2285

name = client_name, settings = client)

2649

name = client_name, settings = client,

2650

server_settings = server_settings)

2286

2651

2287

2652

if not tcp_server.clients:

2288

2653

logger.warning("No clients defined")

2289

2290

if not debug:

2291

try:

2292

with pidfile:

2293

pid = os.getpid()

2294

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

2295

del pidfile

2296

except IOError:

2297

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

2298

pidfilename, pid)

2299

except NameError:

2300

# "pidfile" was never created

2301

pass

2654

2655

if not foreground:

2656

if pidfile is not None:

2657

try:

2658

with pidfile:

2659

pid = os.getpid()

2660

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

2661

except IOError:

2662

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

2663

pidfilename, pid)

2664

del pidfile

2302

2665

del pidfilename

2303

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

2304

2666

2305

2667

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

2306

2668

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

2307

2669

2308

2670

if use_dbus:

2309

class MandosDBusService(dbus.service.Object):

2671

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

2672

"se.bsnet.fukt.Mandos"})

2673

class MandosDBusService(DBusObjectWithProperties):

2310

2674

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

2311

2675

def __init__(self):

2312

2676

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

2313

2677

_interface = "se.recompile.Mandos"

2314

2678

2679

@dbus_interface_annotations(_interface)

2680

def _foo(self):

2681

return { "org.freedesktop.DBus.Property"

2682

".EmitsChangedSignal":

2683

"false"}

2684

2315

2685

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

2316

2686

def ClientAdded(self, objpath):

2317

2687

"D-Bus signal"

2359

2729

2360

2730

del _interface

2361

2731

2362

class MandosDBusServiceTransitional(MandosDBusService):

2363

__metaclass__ = AlternateDBusNamesMetaclass

2364

mandos_dbus_service = MandosDBusServiceTransitional()

2732

mandos_dbus_service = MandosDBusService()

2365

2733

2366

2734

def cleanup():

2367

2735

"Cleanup function; run on exit"

2368

service.cleanup()

2736

if zeroconf:

2737

service.cleanup()

2369

2738

2370

2739

multiprocessing.active_children()

2740

wnull.close()

2371

2741

if not (tcp_server.clients or client_settings):

2372

2742

return

2373

2743

2384

2754

2385

2755

# A list of attributes that can not be pickled

2386

2756

# + secret.

2387

exclude = set(("bus", "changedstate", "secret",

2388

"checker"))

2757

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

2758

"checker", "server_settings" }

2389

2759

for name, typ in (inspect.getmembers

2390

2760

(dbus.service.Object)):

2391

2761

exclude.add(name)

2400

2770

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

2401

2771

2402

2772

try:

2403

with os.fdopen(os.open(stored_state_path,

2404

os.O_CREAT|os.O_WRONLY|os.O_TRUNC,

2405

0600), "wb") as stored_state:

2773

with (tempfile.NamedTemporaryFile

2774

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

2775

dir=os.path.dirname(stored_state_path),

2776

delete=False)) as stored_state:

2406

2777

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

2778

tempname=stored_state.name

2779

os.rename(tempname, stored_state_path)

2407

2780

except (IOError, OSError) as e:

2408

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

2409

.format(e))

2410

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

2781

if not debug:

2782

try:

2783

os.remove(tempname)

2784

except NameError:

2785

pass

2786

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

2787

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

2788

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

2789

else:

2790

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

2791

exc_info=e)

2411

2792

raise

2412

2793

2413

2794

# Delete all clients, and settings from config

2438

2819

tcp_server.server_activate()

2439

2820

2440

2821

# Find out what port we got

2441

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

2822

if zeroconf:

2823

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

2442

2824

if use_ipv6:

2443

2825

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

2444

" flowinfo %d, scope_id %d"

2445

% tcp_server.socket.getsockname())

2826

" flowinfo %d, scope_id %d",

2827

*tcp_server.socket.getsockname())

2446

2828

else: # IPv4

2447

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

2448

% tcp_server.socket.getsockname())

2829

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

2830

*tcp_server.socket.getsockname())

2449

2831

2450

2832

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

2451

2833

2452

2834

try:

2453

# From the Avahi example code

2454

try:

2455

service.activate()

2456

except dbus.exceptions.DBusException as error:

2457

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

2458

cleanup()

2459

sys.exit(1)

2460

# End of Avahi example code

2835

if zeroconf:

2836

# From the Avahi example code

2837

try:

2838

service.activate()

2839

except dbus.exceptions.DBusException as error:

2840

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

2841

cleanup()

2842

sys.exit(1)

2843

# End of Avahi example code

2461

2844

2462

2845

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

2463

2846

lambda *args, **kwargs:

2467

2850

logger.debug("Starting main loop")

2468

2851

main_loop.run()

2469

2852

except AvahiError as error:

2470

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

2853

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

2471

2854

cleanup()

2472

2855

sys.exit(1)

2473

2856

except KeyboardInterrupt: