/mandos/release : revision 237.7.281

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

2

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

3

#

4

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

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

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

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

869

946

value.variant_level+1)

870

947

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

871

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

956

872

957

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

873

958

out_signature="s",

874

959

path_keyword='object_path',

875

960

connection_keyword='connection')

876

961

def Introspect(self, object_path, connection):

877

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

962

"""Overloading of standard D-Bus method.

963

964

Inserts property tags and interface annotation tags.

878

965

"""

879

966

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

880

967

connection)

887

974

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

888

975

return e

889

976

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

977

# Add property tags

890

978

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

891

979

for name, prop

892

in self._get_all_dbus_properties()

980

in self._get_all_dbus_things("property")

893

981

if prop._dbus_interface

894

982

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

895

983

if_tag.appendChild(tag)

984

# Add annotation tags

985

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

986

for tag in if_tag.getElementsByTagName(typ):

987

annots = dict()

988

for name, prop in (self.

989

_get_all_dbus_things(typ)):

990

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

991

and prop._dbus_interface

992

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

993

annots.update(getattr

994

(prop,

995

"_dbus_annotations",

996

{}))

997

for name, value in annots.items():

998

ann_tag = document.createElement(

999

"annotation")

1000

ann_tag.setAttribute("name", name)

1001

ann_tag.setAttribute("value", value)

1002

tag.appendChild(ann_tag)

1003

# Add interface annotation tags

1004

for annotation, value in dict(

1005

itertools.chain.from_iterable(

1006

annotations().items()

1007

for name, annotations in

1008

self._get_all_dbus_things("interface")

1009

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

1010

)).items():

1011

ann_tag = document.createElement("annotation")

1012

ann_tag.setAttribute("name", annotation)

1013

ann_tag.setAttribute("value", value)

1014

if_tag.appendChild(ann_tag)

896

1015

# Add the names to the return values for the

897

1016

# "org.freedesktop.DBus.Properties" methods

898

1017

if (if_tag.getAttribute("name")

913

1032

except (AttributeError, xml.dom.DOMException,

914

1033

xml.parsers.expat.ExpatError) as error:

915

1034

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

916

error)

1035

exc_info=error)

917

1036

return xmlstring

918

1037

919

1038

920

def datetime_to_dbus (dt, variant_level=0):

1039

def datetime_to_dbus(dt, variant_level=0):

921

1040

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

922

1041

if dt is None:

923

1042

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

925

1044

variant_level=variant_level)

926

1045

927

1046

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.

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

932

1069

"""

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

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

940

1077

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

941

1078

# with the wrong interface name

942

1079

if (not hasattr(attribute, "_dbus_interface")

943

1080

or not attribute._dbus_interface

944

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

1081

.startswith(orig_interface_name)):

945

1082

continue

946

1083

# Create an alternate D-Bus interface name based on

947

1084

# the current name

948

1085

alt_interface = (attribute._dbus_interface

949

.replace("se.recompile.Mandos",

950

"se.bsnet.fukt.Mandos"))

1086

.replace(orig_interface_name,

1087

alt_interface_name))

1088

interface_names.add(alt_interface)

951

1089

# Is this a D-Bus signal?

952

1090

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

953

# Extract the original non-method function by

954

# black magic

1091

# Extract the original non-method undecorated

1092

# function by black magic

955

1093

nonmethod_func = (dict(

956

1094

zip(attribute.func_code.co_freevars,

957

1095

attribute.__closure__))["func"]

968

1106

nonmethod_func.func_name,

969

1107

nonmethod_func.func_defaults,

970

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

971

1115

# 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

1116

# original and alternate functions, so both the

1117

# original and alternate signals gets sent when

1118

# the function is called

974

1119

def fixscope(func1, func2):

975

1120

"""This function is a scope container to pass

976

1121

func1 and func2 to the "call_both" function

983

1128

return call_both

984

1129

# Create the "call_both" function and add it to

985

1130

# the class

986

attr[attrname] = fixscope(attribute,

987

new_function)

1131

attr[attrname] = fixscope(attribute, new_function)

988

1132

# Is this a D-Bus method?

989

1133

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

990

1134

# Create a new, but exactly alike, function

1001

1145

attribute.func_name,

1002

1146

attribute.func_defaults,

1003

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

1004

1154

# Is this a D-Bus property?

1005

1155

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

1006

1156

# Create a new, but exactly alike, function

1020

1170

attribute.func_name,

1021

1171

attribute.func_defaults,

1022

1172

attribute.func_closure)))

1023

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

1024

1025

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

1026

1218

class ClientDBus(Client, DBusObjectWithProperties):

1027

1219

"""A Client class using D-Bus

1028

1220

1034

1226

runtime_expansions = (Client.runtime_expansions

1035

1227

+ ("dbus_object_path",))

1036

1228

1229

_interface = "se.recompile.Mandos.Client"

1230

1037

1231

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

1038

1232

1039

1233

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

1040

1234

self.bus = bus

1041

1235

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

1042

self._approvals_pending = 0

1043

1044

self._approvals_pending = 0

1045

1236

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

1046

1237

# the D-Bus

1047

client_object_name = unicode(self.name).translate(

1238

client_object_name = str(self.name).translate(

1048

1239

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

1049

1240

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

1050

1241

self.dbus_object_path = (dbus.ObjectPath

1051

1242

("/clients/" + client_object_name))

1052

1243

DBusObjectWithProperties.__init__(self, self.bus,

1053

1244

self.dbus_object_path)

1054

1245

1055

1246

def notifychangeproperty(transform_func,

1056

1247

dbus_name, type_func=lambda x: x,

1057

variant_level=1):

1248

variant_level=1, invalidate_only=False,

1249

_interface=_interface):

1058

1250

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

1059

1251

its changes to DBus.

1060

1252

1065

1257

to the D-Bus. Default: no transform

1066

1258

variant_level: D-Bus variant level. Default: 1

1067

1259

"""

1068

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

1260

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

1069

1261

def setter(self, value):

1070

1262

if hasattr(self, "dbus_object_path"):

1071

1263

if (not hasattr(self, attrname) or

1072

1264

type_func(getattr(self, attrname, None))

1073

1265

!= type_func(value)):

1074

dbus_value = transform_func(type_func(value),

1075

variant_level

1076

=variant_level)

1077

self.PropertyChanged(dbus.String(dbus_name),

1078

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

1079

1281

setattr(self, attrname, value)

1080

1282

1081

1283

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

1082

1284

1083

1084

1285

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1085

1286

approvals_pending = notifychangeproperty(dbus.Boolean,

1086

1287

"ApprovalPending",

1093

1294

checker is not None)

1094

1295

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1095

1296

"LastCheckedOK")

1297

last_checker_status = notifychangeproperty(dbus.Int16,

1298

"LastCheckerStatus")

1096

1299

last_approval_request = notifychangeproperty(

1097

1300

datetime_to_dbus, "LastApprovalRequest")

1098

1301

approved_by_default = notifychangeproperty(dbus.Boolean,

1100

1303

approval_delay = notifychangeproperty(dbus.UInt64,

1101

1304

"ApprovalDelay",

1102

1305

type_func =

1103

timedelta_to_milliseconds)

1306

lambda td: td.total_seconds()

1307

* 1000)

1104

1308

approval_duration = notifychangeproperty(

1105

1309

dbus.UInt64, "ApprovalDuration",

1106

type_func = timedelta_to_milliseconds)

1310

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

1107

1311

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

1108

1312

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

1109

type_func =

1110

timedelta_to_milliseconds)

1313

type_func = lambda td:

1314

td.total_seconds() * 1000)

1111

1315

extended_timeout = notifychangeproperty(

1112

1316

dbus.UInt64, "ExtendedTimeout",

1113

type_func = timedelta_to_milliseconds)

1317

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

1114

1318

interval = notifychangeproperty(dbus.UInt64,

1115

1319

"Interval",

1116

1320

type_func =

1117

timedelta_to_milliseconds)

1321

lambda td: td.total_seconds()

1322

* 1000)

1118

1323

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

1324

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

1325

invalidate_only=True)

1119

1326

1120

1327

del notifychangeproperty

1121

1328

1148

1355

*args, **kwargs)

1149

1356

1150

1357

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

1358

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

1156

1359

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

1157

1360

# Only if new checker process was started

1158

1361

if (self.checker is not None

1166

1369

return False

1167

1370

1168

1371

def approve(self, value=True):

1169

self.send_changedstate()

1170

1372

self.approved = value

1171

gobject.timeout_add(timedelta_to_milliseconds

1172

(self.approval_duration),

1173

self._reset_approved)

1174

1373

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

1374

* 1000), self._reset_approved)

1375

self.send_changedstate()

1175

1376

1176

1377

## D-Bus methods, signals & properties

1177

_interface = "se.recompile.Mandos.Client"

1378

1379

## Interfaces

1178

1380

1179

1381

## Signals

1180

1382

1191

1393

pass

1192

1394

1193

1395

# PropertyChanged - signal

1396

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

1194

1397

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

1195

1398

def PropertyChanged(self, property, value):

1196

1399

"D-Bus signal"

1217

1420

"D-Bus signal"

1218

1421

return self.need_approval()

1219

1422

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

1423

## Methods

1229

1424

1230

1425

# Approve - method

1280

1475

access="readwrite")

1281

1476

def ApprovalDelay_dbus_property(self, value=None):

1282

1477

if value is None: # get

1283

return dbus.UInt64(self.approval_delay_milliseconds())

1478

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

1479

* 1000)

1284

1480

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

1285

1481

1286

1482

# ApprovalDuration - property

1288

1484

access="readwrite")

1289

1485

def ApprovalDuration_dbus_property(self, value=None):

1290

1486

if value is None: # get

1291

return dbus.UInt64(timedelta_to_milliseconds(

1292

self.approval_duration))

1487

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

1488

* 1000)

1293

1489

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

1294

1490

1295

1491

# Name - property

1308

1504

def Host_dbus_property(self, value=None):

1309

1505

if value is None: # get

1310

1506

return dbus.String(self.host)

1311

self.host = unicode(value)

1507

self.host = str(value)

1312

1508

1313

1509

# Created - property

1314

1510

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

1340

1536

return

1341

1537

return datetime_to_dbus(self.last_checked_ok)

1342

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

1343

1545

# Expires - property

1344

1546

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

1345

1547

def Expires_dbus_property(self):

1355

1557

access="readwrite")

1356

1558

def Timeout_dbus_property(self, value=None):

1357

1559

if value is None: # get

1358

return dbus.UInt64(self.timeout_milliseconds())

1560

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

1561

old_timeout = self.timeout

1359

1562

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

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

1380

1579

1381

1580

# ExtendedTimeout - property

1382

1581

@dbus_service_property(_interface, signature="t",

1383

1582

access="readwrite")

1384

1583

def ExtendedTimeout_dbus_property(self, value=None):

1385

1584

if value is None: # get

1386

return dbus.UInt64(self.extended_timeout_milliseconds())

1585

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

1586

* 1000)

1387

1587

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

1388

1588

1389

1589

# Interval - property

1391

1591

access="readwrite")

1392

1592

def Interval_dbus_property(self, value=None):

1393

1593

if value is None: # get

1394

return dbus.UInt64(self.interval_milliseconds())

1594

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

1395

1595

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

1396

1596

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

1397

1597

return

1408

1608

def Checker_dbus_property(self, value=None):

1409

1609

if value is None: # get

1410

1610

return dbus.String(self.checker_command)

1411

self.checker_command = unicode(value)

1611

self.checker_command = str(value)

1412

1612

1413

1613

# CheckerRunning - property

1414

1614

@dbus_service_property(_interface, signature="b",

1430

1630

@dbus_service_property(_interface, signature="ay",

1431

1631

access="write", byte_arrays=True)

1432

1632

def Secret_dbus_property(self, value):

1433

self.secret = str(value)

1633

self.secret = bytes(value)

1434

1634

1435

1635

del _interface

1436

1636

1461

1661

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

1462

1662

1463

1663

1464

class ClientDBusTransitional(ClientDBus):

1465

__metaclass__ = AlternateDBusNamesMetaclass

1466

1467

1468

1664

class ClientHandler(socketserver.BaseRequestHandler, object):

1469

1665

"""A class to handle client connections.

1470

1666

1474

1670

def handle(self):

1475

1671

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

1476

1672

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

1477

unicode(self.client_address))

1673

str(self.client_address))

1478

1674

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

1479

1675

self.server.child_pipe.fileno())

1480

1676

1506

1702

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

1507

1703

try:

1508

1704

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

1509

raise RuntimeError

1705

raise RuntimeError(line)

1510

1706

except (ValueError, IndexError, RuntimeError) as error:

1511

1707

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

1512

1708

return

1538

1734

except KeyError:

1539

1735

return

1540

1736

1541

if self.server.use_dbus:

1542

# Emit D-Bus signal

1543

client.NewRequest(str(self.client_address))

1544

1545

1737

if client.approval_delay:

1546

1738

delay = client.approval_delay

1547

1739

client.approvals_pending += 1

1565

1757

if self.server.use_dbus:

1566

1758

# Emit D-Bus signal

1567

1759

client.NeedApproval(

1568

client.approval_delay_milliseconds(),

1569

client.approved_by_default)

1760

client.approval_delay.total_seconds()

1761

* 1000, client.approved_by_default)

1570

1762

else:

1571

1763

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

1572

1764

client.name)

1578

1770

#wait until timeout or approved

1579

1771

time = datetime.datetime.now()

1580

1772

client.changedstate.acquire()

1581

(client.changedstate.wait

1582

(float(client.timedelta_to_milliseconds(delay)

1583

/ 1000)))

1773

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

1584

1774

client.changedstate.release()

1585

1775

time2 = datetime.datetime.now()

1586

1776

if (time2 - time) >= delay:

1602

1792

try:

1603

1793

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

1604

1794

except gnutls.errors.GNUTLSError as error:

1605

logger.warning("gnutls send failed")

1795

logger.warning("gnutls send failed",

1796

exc_info=error)

1606

1797

return

1607

1798

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

1608

1799

sent, len(client.secret)

1611

1802

1612

1803

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

1613

1804

# bump the timeout using extended_timeout

1614

client.checked_ok(client.extended_timeout)

1805

client.bump_timeout(client.extended_timeout)

1615

1806

if self.server.use_dbus:

1616

1807

# Emit D-Bus signal

1617

1808

client.GotSecret()

1622

1813

try:

1623

1814

session.bye()

1624

1815

except gnutls.errors.GNUTLSError as error:

1625

logger.warning("GnuTLS bye failed")

1816

logger.warning("GnuTLS bye failed",

1817

exc_info=error)

1626

1818

1627

1819

@staticmethod

1628

1820

def peer_certificate(session):

1700

1892

def process_request(self, request, address):

1701

1893

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

1702

1894

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

1703

args = (request,

1704

address))

1895

args = (request, address))

1705

1896

proc.start()

1706

1897

return proc

1707

1898

1722

1913

1723

1914

def add_pipe(self, parent_pipe, proc):

1724

1915

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

1725

raise NotImplementedError

1916

raise NotImplementedError()

1726

1917

1727

1918

1728

1919

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1735

1926

use_ipv6: Boolean; to use IPv6 or not

1736

1927

"""

1737

1928

def __init__(self, server_address, RequestHandlerClass,

1738

interface=None, use_ipv6=True):

1929

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

1930

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

1931

creating a new one with socket.socket().

1932

"""

1739

1933

self.interface = interface

1740

1934

if use_ipv6:

1741

1935

self.address_family = socket.AF_INET6

1936

if socketfd is not None:

1937

# Save the file descriptor

1938

self.socketfd = socketfd

1939

# Save the original socket.socket() function

1940

self.socket_socket = socket.socket

1941

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

1942

#

1943

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

1944

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

1945

# patching socket.socket.)

1946

#

1947

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

1948

@functools.wraps(socket.socket)

1949

def socket_wrapper(*args, **kwargs):

1950

# Restore original function so subsequent calls are

1951

# not affected.

1952

socket.socket = self.socket_socket

1953

del self.socket_socket

1954

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

1955

# saved file descriptor.

1956

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

1957

# Replace socket.socket() function with wrapper

1958

socket.socket = socket_wrapper

1959

# The socketserver.TCPServer.__init__ will call

1960

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

1961

# socket_wrapper(), if socketfd was set.

1742

1962

socketserver.TCPServer.__init__(self, server_address,

1743

1963

RequestHandlerClass)

1964

1744

1965

def server_bind(self):

1745

1966

"""This overrides the normal server_bind() function

1746

1967

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

1754

1975

try:

1755

1976

self.socket.setsockopt(socket.SOL_SOCKET,

1756

1977

SO_BINDTODEVICE,

1757

str(self.interface

1758

+ '\0'))

1978

(self.interface + "\0")

1979

.encode("utf-8"))

1759

1980

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:

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:

1765

1985

logger.error("SO_BINDTODEVICE not available;"

1766

1986

" cannot bind to interface %s",

1767

1987

self.interface)

1988

elif error.errno == errno.ENODEV:

1989

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

1990

" cannot bind", self.interface)

1768

1991

else:

1769

1992

raise

1770

1993

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

1773

1996

if self.address_family == socket.AF_INET6:

1774

1997

any_address = "::" # in6addr_any

1775

1998

else:

1776

any_address = socket.INADDR_ANY

1999

any_address = "0.0.0.0" # INADDR_ANY

1777

2000

self.server_address = (any_address,

1778

2001

self.server_address[1])

1779

2002

elif not self.server_address[1]:

1800

2023

"""

1801

2024

def __init__(self, server_address, RequestHandlerClass,

1802

2025

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

1803

gnutls_priority=None, use_dbus=True):

2026

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

1804

2027

self.enabled = False

1805

2028

self.clients = clients

1806

2029

if self.clients is None:

1810

2033

IPv6_TCPServer.__init__(self, server_address,

1811

2034

RequestHandlerClass,

1812

2035

interface = interface,

1813

use_ipv6 = use_ipv6)

2036

use_ipv6 = use_ipv6,

2037

socketfd = socketfd)

1814

2038

def server_activate(self):

1815

2039

if self.enabled:

1816

2040

return socketserver.TCPServer.server_activate(self)

1829

2053

1830

2054

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

1831

2055

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

2056

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

1847

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

2057

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

1848

2058

# Wait for other process to exit

1849

2059

proc.join()

1850

2060

return False

1908

2118

return True

1909

2119

1910

2120

2121

def rfc3339_duration_to_delta(duration):

2122

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

2123

2124

>>> rfc3339_duration_to_delta("P7D")

2125

datetime.timedelta(7)

2126

>>> rfc3339_duration_to_delta("PT60S")

2127

datetime.timedelta(0, 60)

2128

>>> rfc3339_duration_to_delta("PT60M")

2129

datetime.timedelta(0, 3600)

2130

>>> rfc3339_duration_to_delta("PT24H")

2131

datetime.timedelta(1)

2132

>>> rfc3339_duration_to_delta("P1W")

2133

datetime.timedelta(7)

2134

>>> rfc3339_duration_to_delta("PT5M30S")

2135

datetime.timedelta(0, 330)

2136

>>> rfc3339_duration_to_delta("P1DT3M20S")

2137

datetime.timedelta(1, 200)

2138

"""

2139

2140

# Parsing an RFC 3339 duration with regular expressions is not

2141

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

2142

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

2143

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

2144

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

2145

# avoid excessive use of external libraries.

2146

2147

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

2148

Token = collections.namedtuple("Token",

2149

("regexp", # To match token; if

2150

# "value" is not None,

2151

# must have a "group"

2152

# containing digits

2153

"value", # datetime.timedelta or

2154

# None

2155

"followers")) # Tokens valid after

2156

# this token

2157

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

2158

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

2159

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

2160

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

2161

datetime.timedelta(seconds=1),

2162

frozenset((token_end,)))

2163

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

2164

datetime.timedelta(minutes=1),

2165

frozenset((token_second, token_end)))

2166

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

2167

datetime.timedelta(hours=1),

2168

frozenset((token_minute, token_end)))

2169

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

2170

None,

2171

frozenset((token_hour, token_minute,

2172

token_second)))

2173

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

2174

datetime.timedelta(days=1),

2175

frozenset((token_time, token_end)))

2176

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

2177

datetime.timedelta(weeks=4),

2178

frozenset((token_day, token_end)))

2179

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

2180

datetime.timedelta(weeks=52),

2181

frozenset((token_month, token_end)))

2182

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

2183

datetime.timedelta(weeks=1),

2184

frozenset((token_end,)))

2185

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

2186

frozenset((token_year, token_month,

2187

token_day, token_time,

2188

token_week)))

2189

# Define starting values

2190

value = datetime.timedelta() # Value so far

2191

found_token = None

2192

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

2193

s = duration # String left to parse

2194

# Loop until end token is found

2195

while found_token is not token_end:

2196

# Search for any currently valid tokens

2197

for token in followers:

2198

match = token.regexp.match(s)

2199

if match is not None:

2200

# Token found

2201

if token.value is not None:

2202

# Value found, parse digits

2203

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

2204

# Add to value so far

2205

value += factor * token.value

2206

# Strip token from string

2207

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

2208

# Go to found token

2209

found_token = token

2210

# Set valid next tokens

2211

followers = found_token.followers

2212

break

2213

else:

2214

# No currently valid tokens were found

2215

raise ValueError("Invalid RFC 3339 duration")

2216

# End token found

2217

return value

2218

2219

1911

2220

def string_to_delta(interval):

1912

2221

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

1913

2222

1924

2233

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

1925

2234

datetime.timedelta(0, 330)

1926

2235

"""

2236

2237

try:

2238

return rfc3339_duration_to_delta(interval)

2239

except ValueError:

2240

pass

2241

1927

2242

timevalue = datetime.timedelta(0)

1928

2243

for s in interval.split():

1929

2244

try:

1930

suffix = unicode(s[-1])

2245

suffix = s[-1]

1931

2246

value = int(s[:-1])

1932

2247

if suffix == "d":

1933

2248

delta = datetime.timedelta(value)

1940

2255

elif suffix == "w":

1941

2256

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

1942

2257

else:

1943

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

1944

except (ValueError, IndexError) as e:

2258

raise ValueError("Unknown suffix {!r}"

2259

.format(suffix))

2260

except IndexError as e:

1945

2261

raise ValueError(*(e.args))

1946

2262

timevalue += delta

1947

2263

return timevalue

1960

2276

sys.exit()

1961

2277

if not noclose:

1962

2278

# Close all standard open file descriptors

1963

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

2279

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

1964

2280

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)

2281

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

2282

.format(os.devnull))

1968

2283

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

1969

2284

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

1970

2285

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

1979

2294

1980

2295

parser = argparse.ArgumentParser()

1981

2296

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

1982

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

2297

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

1983

2298

help="show version number and exit")

1984

2299

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

1985

2300

help="Bind to interface IF")

1991

2306

help="Run self-test")

1992

2307

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

1993

2308

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

1994

" to terminal")

2309

" to terminal", default=None)

1995

2310

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

1996

2311

help="Debug level for stdout output")

1997

2312

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

2004

2319

" files")

2005

2320

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

2006

2321

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

2007

" system bus interface")

2322

" system bus interface", default=None)

2008

2323

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

2009

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

2324

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

2325

default=None)

2010

2326

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

2011

2327

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

2012

" state")

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

2013

2332

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

2014

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)

2015

2339

2016

2340

options = parser.parse_args()

2017

2341

2018

2342

if options.check:

2019

2343

import doctest

2020

doctest.testmod()

2021

sys.exit()

2344

fail_count, test_count = doctest.testmod()

2345

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

2022

2346

2023

2347

# Default values for config file for server-global settings

2024

2348

server_defaults = { "interface": "",

2026

2350

"port": "",

2027

2351

"debug": "False",

2028

2352

"priority":

2029

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

2353

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

2030

2354

"servicename": "Mandos",

2031

2355

"use_dbus": "True",

2032

2356

"use_ipv6": "True",

2033

2357

"debuglevel": "",

2034

2358

"restore": "True",

2035

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

2359

"socket": "",

2360

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

2361

"foreground": "False",

2362

"zeroconf": "True",

2036

2363

}

2037

2364

2038

2365

# Parse config file for server-global settings

2043

2370

# Convert the SafeConfigParser object to a dict

2044

2371

server_settings = server_config.defaults()

2045

2372

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

2046

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

2373

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

2047

2374

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

2048

2375

option)

2049

2376

if server_settings["port"]:

2050

2377

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

2051

2378

"port")

2379

if server_settings["socket"]:

2380

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

2381

"socket")

2382

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

2383

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

2384

# happen with a supplied network socket.

2385

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

2386

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

2387

["socket"])

2052

2388

del server_config

2053

2389

2054

2390

# Override the settings from the config file with command line

2056

2392

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

2057

2393

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

2058

2394

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

2059

"statedir"):

2395

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

2060

2396

value = getattr(options, option)

2061

2397

if value is not None:

2062

2398

server_settings[option] = value

2063

2399

del options

2064

2400

# Force all strings to be unicode

2065

2401

for option in server_settings.keys():

2066

if type(server_settings[option]) is str:

2067

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

2402

if isinstance(server_settings[option], bytes):

2403

server_settings[option] = (server_settings[option]

2404

.decode("utf-8"))

2405

# Force all boolean options to be boolean

2406

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

2407

"foreground", "zeroconf"):

2408

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

2409

# Debug implies foreground

2410

if server_settings["debug"]:

2411

server_settings["foreground"] = True

2068

2412

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

2069

2413

2070

2414

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

2071

2415

2416

if (not server_settings["zeroconf"] and

2417

not (server_settings["port"]

2418

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

2419

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

2420

" Zeroconf")

2421

2072

2422

# For convenience

2073

2423

debug = server_settings["debug"]

2074

2424

debuglevel = server_settings["debuglevel"]

2076

2426

use_ipv6 = server_settings["use_ipv6"]

2077

2427

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

2078

2428

stored_state_file)

2429

foreground = server_settings["foreground"]

2430

zeroconf = server_settings["zeroconf"]

2079

2431

2080

2432

if debug:

2081

initlogger(logging.DEBUG)

2433

initlogger(debug, logging.DEBUG)

2082

2434

else:

2083

2435

if not debuglevel:

2084

initlogger()

2436

initlogger(debug)

2085

2437

else:

2086

2438

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

2087

initlogger(level)

2439

initlogger(debug, level)

2088

2440

2089

2441

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

2090

2442

syslogger.setFormatter(logging.Formatter

2091

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

2092

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

2093

% server_settings["servicename"]))

2443

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

2444

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

2445

.format(server_settings

2446

["servicename"])))

2094

2447

2095

2448

# Parse config file with clients

2096

client_config = configparser.SafeConfigParser(Client.client_defaults)

2449

client_config = configparser.SafeConfigParser(Client

2450

.client_defaults)

2097

2451

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

2098

2452

"clients.conf"))

2099

2453

2100

2454

global mandos_dbus_service

2101

2455

mandos_dbus_service = None

2102

2456

2457

socketfd = None

2458

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

2459

socketfd = server_settings["socket"]

2103

2460

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

2104

2461

server_settings["port"]),

2105

2462

ClientHandler,

2108

2465

use_ipv6=use_ipv6,

2109

2466

gnutls_priority=

2110

2467

server_settings["priority"],

2111

use_dbus=use_dbus)

2112

if not debug:

2113

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

2468

use_dbus=use_dbus,

2469

socketfd=socketfd)

2470

if not foreground:

2471

pidfilename = "/run/mandos.pid"

2472

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

2473

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

2474

pidfile = None

2114

2475

try:

2115

2476

pidfile = open(pidfilename, "w")

2116

except IOError:

2117

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

2477

except IOError as e:

2478

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

2479

exc_info=e)

2118

2480

2119

try:

2120

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

2121

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

2122

except KeyError:

2481

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

2123

2482

try:

2124

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

2125

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

2483

uid = pwd.getpwnam(name).pw_uid

2484

gid = pwd.getpwnam(name).pw_gid

2485

break

2126

2486

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

2487

continue

2488

else:

2489

uid = 65534

2490

gid = 65534

2133

2491

try:

2134

2492

os.setgid(gid)

2135

2493

os.setuid(uid)

2136

2494

except OSError as error:

2137

if error[0] != errno.EPERM:

2138

raise error

2495

if error.errno != errno.EPERM:

2496

raise

2139

2497

2140

2498

if debug:

2141

2499

# Enable all possible GnuTLS debugging

2152

2510

.gnutls_global_set_log_function(debug_gnutls))

2153

2511

2154

2512

# Redirect stdin so all checkers get /dev/null

2155

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

2513

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

2156

2514

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

2157

2515

if null > 2:

2158

2516

os.close(null)

2159

else:

2160

# No console logging

2161

logger.removeHandler(console)

2162

2517

2163

2518

# Need to fork before connecting to D-Bus

2164

if not debug:

2519

if not foreground:

2165

2520

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

2166

2521

daemon()

2167

2522

2523

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

2524

# need to inform gobject that threads will be used.

2525

gobject.threads_init()

2526

2168

2527

global main_loop

2169

2528

# From the Avahi example code

2170

DBusGMainLoop(set_as_default=True )

2529

DBusGMainLoop(set_as_default=True)

2171

2530

main_loop = gobject.MainLoop()

2172

2531

bus = dbus.SystemBus()

2173

2532

# End of Avahi example code

2179

2538

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

2180

2539

do_not_queue=True))

2181

2540

except dbus.exceptions.NameExistsException as e:

2182

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

2541

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

2183

2542

use_dbus = False

2184

2543

server_settings["use_dbus"] = False

2185

2544

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

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

2194

2555

2195

2556

global multiprocessing_manager

2196

2557

multiprocessing_manager = multiprocessing.Manager()

2197

2558

2198

2559

client_class = Client

2199

2560

if use_dbus:

2200

client_class = functools.partial(ClientDBusTransitional,

2201

bus = bus)

2561

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

2202

2562

2203

2563

client_settings = Client.config_parser(client_config)

2204

2564

old_client_settings = {}

2205

2565

clients_data = {}

2206

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

2207

2575

# Get client data and settings from last running state.

2208

2576

if server_settings["restore"]:

2209

2577

try:

2212

2580

(stored_state))

2213

2581

os.remove(stored_state_path)

2214

2582

except IOError as e:

2215

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

2216

.format(e))

2217

if e.errno != errno.ENOENT:

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)

2218

2589

raise

2590

except EOFError as e:

2591

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

2592

"EOFError:", exc_info=e)

2219

2593

2220

2594

with PGPEngine() as pgp:

2221

for client_name, client in clients_data.iteritems():

2595

for client_name, client in clients_data.items():

2596

# Skip removed clients

2597

if client_name not in client_settings:

2598

continue

2599

2222

2600

# Decide which value to use after restoring saved state.

2223

2601

# We have three different values: Old config file,

2224

2602

# new config file, and saved state.

2238

2616

2239

2617

# Clients who has passed its expire date can still be

2240

2618

# 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.

2619

# whose checker succeeded before we stored its state is

2620

# assumed to have successfully run all checkers during

2621

# downtime.

2243

2622

if client["enabled"]:

2244

2623

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

2245

2624

if not client["last_checked_ok"]:

2246

2625

logger.warning(

2247

"disabling client {0} - Client never "

2248

"performed a successfull checker"

2249

.format(client["name"]))

2626

"disabling client {} - Client never "

2627

"performed a successful checker"

2628

.format(client_name))

2250

2629

client["enabled"] = False

2251

2630

elif client["last_checker_status"] != 0:

2252

2631

logger.warning(

2253

"disabling client {0} - Client "

2254

"last checker failed with error code {1}"

2255

.format(client["name"],

2632

"disabling client {} - Client last"

2633

" checker failed with error code {}"

2634

.format(client_name,

2256

2635

client["last_checker_status"]))

2257

2636

client["enabled"] = False

2258

2637

else:

2259

2638

client["expires"] = (datetime.datetime

2260

2639

.utcnow()

2261

2640

+ client["timeout"])

2262

2641

logger.debug("Last checker succeeded,"

2642

" keeping {} enabled"

2643

.format(client_name))

2263

2644

try:

2264

2645

client["secret"] = (

2265

2646

pgp.decrypt(client["encrypted_secret"],

2267

2648

["secret"]))

2268

2649

except PGPError:

2269

2650

# If decryption fails, we use secret from new settings

2270

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

2651

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

2271

2652

.format(client_name))

2272

2653

client["secret"] = (

2273

2654

client_settings[client_name]["secret"])

2274

2275

2655

2276

2656

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

2277

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

2657

for client_name in (set(old_client_settings)

2658

- set(client_settings)):

2278

2659

del clients_data[client_name]

2279

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

2660

for client_name in (set(client_settings)

2661

- set(old_client_settings)):

2280

2662

clients_data[client_name] = client_settings[client_name]

2281

2282

# Create clients all clients

2283

for client_name, client in clients_data.iteritems():

2663

2664

# Create all client objects

2665

for client_name, client in clients_data.items():

2284

2666

tcp_server.clients[client_name] = client_class(

2285

name = client_name, settings = client)

2667

name = client_name, settings = client,

2668

server_settings = server_settings)

2286

2669

2287

2670

if not tcp_server.clients:

2288

2671

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

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

2302

2683

del pidfilename

2303

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

2304

2684

2305

2685

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

2306

2686

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

2307

2687

2308

2688

if use_dbus:

2309

class MandosDBusService(dbus.service.Object):

2689

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

2690

"se.bsnet.fukt.Mandos"})

2691

class MandosDBusService(DBusObjectWithProperties):

2310

2692

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

2311

2693

def __init__(self):

2312

2694

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

2313

2695

_interface = "se.recompile.Mandos"

2314

2696

2697

@dbus_interface_annotations(_interface)

2698

def _foo(self):

2699

return { "org.freedesktop.DBus.Property"

2700

".EmitsChangedSignal":

2701

"false"}

2702

2315

2703

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

2316

2704

def ClientAdded(self, objpath):

2317

2705

"D-Bus signal"

2339

2727

def GetAllClientsWithProperties(self):

2340

2728

"D-Bus method"

2341

2729

return dbus.Dictionary(

2342

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

2343

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

2730

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

2731

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

2344

2732

signature="oa{sv}")

2345

2733

2346

2734

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

2359

2747

2360

2748

del _interface

2361

2749

2362

class MandosDBusServiceTransitional(MandosDBusService):

2363

__metaclass__ = AlternateDBusNamesMetaclass

2364

mandos_dbus_service = MandosDBusServiceTransitional()

2750

mandos_dbus_service = MandosDBusService()

2365

2751

2366

2752

def cleanup():

2367

2753

"Cleanup function; run on exit"

2368

service.cleanup()

2754

if zeroconf:

2755

service.cleanup()

2369

2756

2370

2757

multiprocessing.active_children()

2758

wnull.close()

2371

2759

if not (tcp_server.clients or client_settings):

2372

2760

return

2373

2761

2384

2772

2385

2773

# A list of attributes that can not be pickled

2386

2774

# + secret.

2387

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

2388

"checker"))

2775

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

2776

"checker", "server_settings" }

2389

2777

for name, typ in (inspect.getmembers

2390

2778

(dbus.service.Object)):

2391

2779

exclude.add(name)

2400

2788

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

2401

2789

2402

2790

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:

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:

2406

2795

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

2796

tempname=stored_state.name

2797

os.rename(tempname, stored_state_path)

2407

2798

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

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)

2411

2810

raise

2412

2811

2413

2812

# Delete all clients, and settings from config

2438

2837

tcp_server.server_activate()

2439

2838

2440

2839

# Find out what port we got

2441

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

2840

if zeroconf:

2841

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

2442

2842

if use_ipv6:

2443

2843

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

2444

" flowinfo %d, scope_id %d"

2445

% tcp_server.socket.getsockname())

2844

" flowinfo %d, scope_id %d",

2845

*tcp_server.socket.getsockname())

2446

2846

else: # IPv4

2447

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

2448

% tcp_server.socket.getsockname())

2847

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

2848

*tcp_server.socket.getsockname())

2449

2849

2450

2850

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

2451

2851

2452

2852

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

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

2461

2862

2462

2863

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

2463

2864

lambda *args, **kwargs:

2467

2868

logger.debug("Starting main loop")

2468

2869

main_loop.run()

2469

2870

except AvahiError as error:

2470

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

2871

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

2471

2872

cleanup()

2472

2873

sys.exit(1)

2473

2874

except KeyboardInterrupt: