/mandos/release : revision 237.11.20

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

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

65

63

import cPickle as pickle

66

64

import multiprocessing

67

65

import types

68

import binascii

69

import tempfile

70

import itertools

71

66

72

67

import dbus

73

68

import dbus.service

78

73

import ctypes.util

79

74

import xml.dom.minidom

80

75

import inspect

81

import GnuPGInterface

82

76

83

77

try:

84

78

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

88

82

except ImportError:

89

83

SO_BINDTODEVICE = None

90

84

91

version = "1.5.4"

92

stored_state_file = "clients.pickle"

85

86

version = "1.4.1"

93

87

94

88

logger = logging.getLogger()

95

89

syslogger = (logging.handlers.SysLogHandler

96

90

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

97

91

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

98

99

try:

100

if_nametoindex = (ctypes.cdll.LoadLibrary

101

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

102

.if_nametoindex)

103

except (OSError, AttributeError):

104

def if_nametoindex(interface):

105

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

106

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

107

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

108

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

109

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

110

interface))

111

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

112

ifreq[16:20])[0]

113

return interface_index

114

115

116

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

117

"""init logger and add loglevel"""

118

119

syslogger.setFormatter(logging.Formatter

120

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

121

' %(message)s'))

122

logger.addHandler(syslogger)

123

124

if debug:

125

console = logging.StreamHandler()

126

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

127

' [%(process)d]:'

128

' %(levelname)s:'

129

' %(message)s'))

130

logger.addHandler(console)

131

logger.setLevel(level)

132

133

134

class PGPError(Exception):

135

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

136

pass

137

138

139

class PGPEngine(object):

140

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

141

def __init__(self):

142

self.gnupg = GnuPGInterface.GnuPG()

143

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

144

self.gnupg = GnuPGInterface.GnuPG()

145

self.gnupg.options.meta_interactive = False

146

self.gnupg.options.homedir = self.tempdir

147

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

148

'--quiet',

149

'--no-use-agent'])

150

151

def __enter__(self):

152

return self

153

154

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

155

self._cleanup()

156

return False

157

158

def __del__(self):

159

self._cleanup()

160

161

def _cleanup(self):

162

if self.tempdir is not None:

163

# Delete contents of tempdir

164

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

165

topdown = False):

166

for filename in files:

167

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

168

for dirname in dirs:

169

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

170

# Remove tempdir

171

os.rmdir(self.tempdir)

172

self.tempdir = None

173

174

def password_encode(self, password):

175

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

176

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

177

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

178

179

def encrypt(self, data, password):

180

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

181

with open(os.devnull, "w") as devnull:

182

try:

183

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

184

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

185

attach_fhs={'stderr': devnull})

186

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

187

f.write(data)

188

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

189

ciphertext = f.read()

190

proc.wait()

191

except IOError as e:

192

raise PGPError(e)

193

self.gnupg.passphrase = None

194

return ciphertext

195

196

def decrypt(self, data, password):

197

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

198

with open(os.devnull, "w") as devnull:

199

try:

200

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

201

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

202

attach_fhs={'stderr': devnull})

203

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

204

f.write(data)

205

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

206

decrypted_plaintext = f.read()

207

proc.wait()

208

except IOError as e:

209

raise PGPError(e)

210

self.gnupg.passphrase = None

211

return decrypted_plaintext

92

syslogger.setFormatter(logging.Formatter

93

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

94

' %(message)s'))

95

logger.addHandler(syslogger)

96

97

console = logging.StreamHandler()

98

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

99

' [%(process)d]:'

100

' %(levelname)s:'

101

' %(message)s'))

102

logger.addHandler(console)

212

103

213

104

214

105

class AvahiError(Exception):

245

136

server: D-Bus Server

246

137

bus: dbus.SystemBus()

247

138

"""

248

249

139

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

250

140

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

251

141

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

264

154

self.server = None

265

155

self.bus = bus

266

156

self.entry_group_state_changed_match = None

267

268

157

def rename(self):

269

158

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

270

159

if self.rename_count >= self.max_renames:

280

169

try:

281

170

self.add()

282

171

except dbus.exceptions.DBusException as error:

283

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

172

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

284

173

self.cleanup()

285

174

os._exit(1)

286

175

self.rename_count += 1

287

288

176

def remove(self):

289

177

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

290

178

if self.entry_group_state_changed_match is not None:

292

180

self.entry_group_state_changed_match = None

293

181

if self.group is not None:

294

182

self.group.Reset()

295

296

183

def add(self):

297

184

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

298

185

self.remove()

315

202

dbus.UInt16(self.port),

316

203

avahi.string_array_to_txt_array(self.TXT))

317

204

self.group.Commit()

318

319

205

def entry_group_state_changed(self, state, error):

320

206

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

321

207

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

328

214

elif state == avahi.ENTRY_GROUP_FAILURE:

329

215

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

330

216

unicode(error))

331

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

332

.format(error))

333

217

raise AvahiGroupError("State changed: %s"

218

% unicode(error))

334

219

def cleanup(self):

335

220

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

336

221

if self.group is not None:

337

222

try:

338

223

self.group.Free()

339

224

except (dbus.exceptions.UnknownMethodException,

340

dbus.exceptions.DBusException):

225

dbus.exceptions.DBusException) as e:

341

226

pass

342

227

self.group = None

343

228

self.remove()

344

345

229

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

346

230

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

347

231

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

366

250

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

367

251

else:

368

252

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

369

370

253

def activate(self):

371

254

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

372

255

if self.server is None:

379

262

self.server_state_changed)

380

263

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

381

264

382

383

265

class AvahiServiceToSyslog(AvahiService):

384

266

def rename(self):

385

267

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

386

268

ret = AvahiService.rename(self)

387

269

syslogger.setFormatter(logging.Formatter

388

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

389

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

390

.format(self.name)))

270

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

271

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

272

% self.name))

391

273

return ret

392

274

393

394

def timedelta_to_milliseconds(td):

275

def _timedelta_to_milliseconds(td):

395

276

"Convert a datetime.timedelta() to milliseconds"

396

277

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

397

278

+ (td.seconds * 1000)

398

279

+ (td.microseconds // 1000))

399

400

280

401

281

class Client(object):

402

282

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

403

283

404

284

Attributes:

405

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

285

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

406

286

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

407

287

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

408

288

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

415

295

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

416

296

checker_initiator_tag: a gobject event source tag, or None

417

297

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

418

client_structure: Object describing what attributes a client has

419

and is used for storing the client at exit

420

298

current_checker_command: string; current running checker_command

299

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

421

300

disable_initiator_tag: a gobject event source tag, or None

422

301

enabled: bool()

423

302

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

426

305

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

427

306

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

428

307

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

429

last_checker_status: integer between 0 and 255 reflecting exit

430

status of last checker. -1 reflects crashed

431

checker, -2 means no checker completed yet.

432

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

308

last_enabled: datetime.datetime(); (UTC)

433

309

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

434

310

D-Bus identifiers

435

311

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

436

312

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

437

313

until this client is disabled

438

extended_timeout: extra long timeout when secret has been sent

314

extended_timeout: extra long timeout when password has been sent

439

315

runtime_expansions: Allowed attributes for runtime expansion.

440

316

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

441

317

disabled, or None

442

318

"""

443

319

444

320

runtime_expansions = ("approval_delay", "approval_duration",

445

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

446

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

447

"last_approval_request", "last_checked_ok",

321

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

322

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

448

323

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

449

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

450

"extended_timeout": "15m",

451

"interval": "2m",

452

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

453

"host": "",

454

"approval_delay": "0s",

455

"approval_duration": "1s",

456

"approved_by_default": "True",

457

"enabled": "True",

458

}

459

324

460

325

def timeout_milliseconds(self):

461

326

"Return the 'timeout' attribute in milliseconds"

462

return timedelta_to_milliseconds(self.timeout)

327

return _timedelta_to_milliseconds(self.timeout)

463

328

464

329

def extended_timeout_milliseconds(self):

465

330

"Return the 'extended_timeout' attribute in milliseconds"

466

return timedelta_to_milliseconds(self.extended_timeout)

331

return _timedelta_to_milliseconds(self.extended_timeout)

467

332

468

333

def interval_milliseconds(self):

469

334

"Return the 'interval' attribute in milliseconds"

470

return timedelta_to_milliseconds(self.interval)

335

return _timedelta_to_milliseconds(self.interval)

471

336

472

337

def approval_delay_milliseconds(self):

473

return timedelta_to_milliseconds(self.approval_delay)

474

475

@staticmethod

476

def config_parser(config):

477

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

478

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

479

with exceptions for any special settings as defined above.

480

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

481

value given the same arguments.

482

"""

483

settings = {}

484

for client_name in config.sections():

485

section = dict(config.items(client_name))

486

client = settings[client_name] = {}

487

488

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

489

# Reformat values from string types to Python types

490

client["approved_by_default"] = config.getboolean(

491

client_name, "approved_by_default")

492

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

493

"enabled")

494

495

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

496

.replace(" ", ""))

497

if "secret" in section:

498

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

499

elif "secfile" in section:

500

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

501

(section["secfile"])),

502

"rb") as secfile:

503

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

504

else:

505

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

506

.format(section))

507

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

508

client["extended_timeout"] = string_to_delta(

509

section["extended_timeout"])

510

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

511

client["approval_delay"] = string_to_delta(

512

section["approval_delay"])

513

client["approval_duration"] = string_to_delta(

514

section["approval_duration"])

515

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

516

client["last_approval_request"] = None

517

client["last_checked_ok"] = None

518

client["last_checker_status"] = -2

519

520

return settings

521

522

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

338

return _timedelta_to_milliseconds(self.approval_delay)

339

340

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

341

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

342

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

343

attribute."""

523

344

self.name = name

524

# adding all client settings

525

for setting, value in settings.iteritems():

526

setattr(self, setting, value)

527

528

if self.enabled:

529

if not hasattr(self, "last_enabled"):

530

self.last_enabled = datetime.datetime.utcnow()

531

if not hasattr(self, "expires"):

532

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

533

+ self.timeout)

534

else:

535

self.last_enabled = None

536

self.expires = None

537

345

if config is None:

346

config = {}

538

347

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

539

348

# Uppercase and remove spaces from fingerprint for later

540

349

# comparison purposes with return value from the fingerprint()

541

350

# function

351

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

352

.replace(" ", ""))

542

353

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

543

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

544

datetime.datetime.utcnow())

545

546

# attributes specific for this server instance

354

if "secret" in config:

355

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

356

elif "secfile" in config:

357

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

358

(config["secfile"])),

359

"rb") as secfile:

360

self.secret = secfile.read()

361

else:

362

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

363

% self.name)

364

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

365

self.created = datetime.datetime.utcnow()

366

self.enabled = False

367

self.last_approval_request = None

368

self.last_enabled = None

369

self.last_checked_ok = None

370

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

371

self.extended_timeout = string_to_delta(config

372

["extended_timeout"])

373

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

374

self.disable_hook = disable_hook

547

375

self.checker = None

548

376

self.checker_initiator_tag = None

549

377

self.disable_initiator_tag = None

378

self.expires = None

550

379

self.checker_callback_tag = None

380

self.checker_command = config["checker"]

551

381

self.current_checker_command = None

552

self.approved = None

382

self.last_connect = None

383

self._approved = None

384

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

385

True)

553

386

self.approvals_pending = 0

387

self.approval_delay = string_to_delta(

388

config["approval_delay"])

389

self.approval_duration = string_to_delta(

390

config["approval_duration"])

554

391

self.changedstate = (multiprocessing_manager

555

392

.Condition(multiprocessing_manager

556

393

.Lock()))

557

self.client_structure = [attr for attr in

558

self.__dict__.iterkeys()

559

if not attr.startswith("_")]

560

self.client_structure.append("client_structure")

561

562

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

563

lambda obj:

564

isinstance(obj,

565

property)):

566

if not name.startswith("_"):

567

self.client_structure.append(name)

568

394

569

# Send notice to process children that client state has changed

570

395

def send_changedstate(self):

571

with self.changedstate:

572

self.changedstate.notify_all()

396

self.changedstate.acquire()

397

self.changedstate.notify_all()

398

self.changedstate.release()

573

399

574

400

def enable(self):

575

401

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

576

402

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

577

403

# Already enabled

578

404

return

579

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

580

self.enabled = True

581

self.last_enabled = datetime.datetime.utcnow()

582

self.init_checker()

583

405

self.send_changedstate()

584

585

def disable(self, quiet=True):

586

"""Disable this client."""

587

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

588

return False

589

if not quiet:

590

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

591

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

592

gobject.source_remove(self.disable_initiator_tag)

593

self.disable_initiator_tag = None

594

self.expires = None

595

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

596

gobject.source_remove(self.checker_initiator_tag)

597

self.checker_initiator_tag = None

598

self.stop_checker()

599

self.enabled = False

600

if not quiet:

601

self.send_changedstate()

602

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

603

return False

604

605

def __del__(self):

606

self.disable()

607

608

def init_checker(self):

609

406

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

610

407

# and every interval from then on.

611

if self.checker_initiator_tag is not None:

612

gobject.source_remove(self.checker_initiator_tag)

613

408

self.checker_initiator_tag = (gobject.timeout_add

614

409

(self.interval_milliseconds(),

615

410

self.start_checker))

616

411

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

617

if self.disable_initiator_tag is not None:

618

gobject.source_remove(self.disable_initiator_tag)

412

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

619

413

self.disable_initiator_tag = (gobject.timeout_add

620

414

(self.timeout_milliseconds(),

621

415

self.disable))

416

self.enabled = True

417

self.last_enabled = datetime.datetime.utcnow()

622

418

# Also start a new checker *right now*.

623

419

self.start_checker()

624

420

421

def disable(self, quiet=True):

422

"""Disable this client."""

423

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

424

return False

425

if not quiet:

426

self.send_changedstate()

427

if not quiet:

428

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

429

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

430

gobject.source_remove(self.disable_initiator_tag)

431

self.disable_initiator_tag = None

432

self.expires = None

433

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

434

gobject.source_remove(self.checker_initiator_tag)

435

self.checker_initiator_tag = None

436

self.stop_checker()

437

if self.disable_hook:

438

self.disable_hook(self)

439

self.enabled = False

440

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

441

return False

442

443

def __del__(self):

444

self.disable_hook = None

445

self.disable()

446

625

447

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

626

448

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

627

449

self.checker_callback_tag = None

628

450

self.checker = None

629

451

if os.WIFEXITED(condition):

630

self.last_checker_status = os.WEXITSTATUS(condition)

631

if self.last_checker_status == 0:

452

exitstatus = os.WEXITSTATUS(condition)

453

if exitstatus == 0:

632

454

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

633

455

vars(self))

634

456

self.checked_ok()

636

458

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

637

459

vars(self))

638

460

else:

639

self.last_checker_status = -1

640

461

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

641

462

vars(self))

642

463

643

def checked_ok(self):

644

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

645

self.last_checked_ok = datetime.datetime.utcnow()

646

self.last_checker_status = 0

647

self.bump_timeout()

648

649

def bump_timeout(self, timeout=None):

650

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

464

def checked_ok(self, timeout=None):

465

"""Bump up the timeout for this client.

466

467

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

468

alive and well.

469

"""

651

470

if timeout is None:

652

471

timeout = self.timeout

472

self.last_checked_ok = datetime.datetime.utcnow()

653

473

if self.disable_initiator_tag is not None:

654

474

gobject.source_remove(self.disable_initiator_tag)

655

self.disable_initiator_tag = None

656

475

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

657

476

self.disable_initiator_tag = (gobject.timeout_add

658

(timedelta_to_milliseconds

477

(_timedelta_to_milliseconds

659

478

(timeout), self.disable))

660

479

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

661

480

668

487

If a checker already exists, leave it running and do

669

488

nothing."""

670

489

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

671

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

672

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

673

# would inevitably timeout, since no checker would get a

674

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

490

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

491

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

492

# client would inevitably timeout, since no checker would get

493

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

675

494

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

676

495

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

677

496

# should be.

691

510

self.current_checker_command)

692

511

# Start a new checker if needed

693

512

if self.checker is None:

694

# Escape attributes for the shell

695

escaped_attrs = dict(

696

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

697

for attr in

698

self.runtime_expansions)

699

513

try:

700

command = self.checker_command % escaped_attrs

701

except TypeError as error:

702

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

703

self.checker_command, exc_info=error)

704

return True # Try again later

514

# In case checker_command has exactly one % operator

515

command = self.checker_command % self.host

516

except TypeError:

517

# Escape attributes for the shell

518

escaped_attrs = dict(

519

(attr,

520

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

521

errors=

522

'replace')))

523

for attr in

524

self.runtime_expansions)

525

526

try:

527

command = self.checker_command % escaped_attrs

528

except TypeError as error:

529

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

530

' %s', self.checker_command, error)

531

return True # Try again later

705

532

self.current_checker_command = command

706

533

try:

707

534

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

713

540

self.checker = subprocess.Popen(command,

714

541

close_fds=True,

715

542

shell=True, cwd="/")

543

self.checker_callback_tag = (gobject.child_watch_add

544

(self.checker.pid,

545

self.checker_callback,

546

data=command))

547

# The checker may have completed before the gobject

548

# watch was added. Check for this.

549

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

550

if pid:

551

gobject.source_remove(self.checker_callback_tag)

552

self.checker_callback(pid, status, command)

716

553

except OSError as error:

717

logger.error("Failed to start subprocess",

718

exc_info=error)

719

self.checker_callback_tag = (gobject.child_watch_add

720

(self.checker.pid,

721

self.checker_callback,

722

data=command))

723

# The checker may have completed before the gobject

724

# watch was added. Check for this.

725

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

726

if pid:

727

gobject.source_remove(self.checker_callback_tag)

728

self.checker_callback(pid, status, command)

554

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

555

error)

729

556

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

730

557

return True

731

558

738

565

return

739

566

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

740

567

try:

741

self.checker.terminate()

568

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

742

569

#time.sleep(0.5)

743

570

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

744

# self.checker.kill()

571

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

745

572

except OSError as error:

746

573

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

747

574

raise

764

591

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

765

592

if byte_arrays and signature != "ay":

766

593

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

767

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

594

" signature %r" % signature)

768

595

def decorator(func):

769

596

func._dbus_is_property = True

770

597

func._dbus_interface = dbus_interface

778

605

return decorator

779

606

780

607

781

def dbus_interface_annotations(dbus_interface):

782

"""Decorator for marking functions returning interface annotations

783

784

Usage:

785

786

@dbus_interface_annotations("org.example.Interface")

787

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

788

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

789

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

790

"false"}

791

"""

792

def decorator(func):

793

func._dbus_is_interface = True

794

func._dbus_interface = dbus_interface

795

func._dbus_name = dbus_interface

796

return func

797

return decorator

798

799

800

def dbus_annotations(annotations):

801

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

802

Usage:

803

804

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

805

access="r")

806

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

807

"org.freedesktop.DBus.Property."

808

"EmitsChangedSignal": "false"})

809

def Property_dbus_property(self):

810

return dbus.Boolean(False)

811

"""

812

def decorator(func):

813

func._dbus_annotations = annotations

814

return func

815

return decorator

816

817

818

608

class DBusPropertyException(dbus.exceptions.DBusException):

819

609

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

820

610

"""

843

633

"""

844

634

845

635

@staticmethod

846

def _is_dbus_thing(thing):

847

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

848

849

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

850

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

851

"""

852

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

853

False)

636

def _is_dbus_property(obj):

637

return getattr(obj, "_dbus_is_property", False)

854

638

855

def _get_all_dbus_things(self, thing):

639

def _get_all_dbus_properties(self):

856

640

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

857

641

"""

858

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

859

name),

860

athing.__get__(self))

642

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

861

643

for cls in self.__class__.__mro__

862

for name, athing in

863

inspect.getmembers(cls,

864

self._is_dbus_thing(thing)))

644

for name, prop in

645

inspect.getmembers(cls, self._is_dbus_property))

865

646

866

647

def _get_dbus_property(self, interface_name, property_name):

867

648

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

869

650

"""

870

651

for cls in self.__class__.__mro__:

871

652

for name, value in (inspect.getmembers

872

(cls,

873

self._is_dbus_thing("property"))):

653

(cls, self._is_dbus_property)):

874

654

if (value._dbus_name == property_name

875

655

and value._dbus_interface == interface_name):

876

656

return value.__get__(self)

905

685

# signatures other than "ay".

906

686

if prop._dbus_signature != "ay":

907

687

raise ValueError

908

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

909

for byte in value))

688

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

689

for byte in value))

910

690

prop(value)

911

691

912

692

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

917

697

918

698

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

919

699

"""

920

properties = {}

921

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

700

all = {}

701

for name, prop in self._get_all_dbus_properties():

922

702

if (interface_name

923

703

and interface_name != prop._dbus_interface):

924

704

# Interface non-empty but did not match

928

708

continue

929

709

value = prop()

930

710

if not hasattr(value, "variant_level"):

931

properties[name] = value

711

all[name] = value

932

712

continue

933

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

934

value.variant_level+1)

935

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

713

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

714

value.variant_level+1)

715

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

936

716

937

717

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

938

718

out_signature="s",

939

719

path_keyword='object_path',

940

720

connection_keyword='connection')

941

721

def Introspect(self, object_path, connection):

942

"""Overloading of standard D-Bus method.

943

944

Inserts property tags and interface annotation tags.

722

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

945

723

"""

946

724

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

947

725

connection)

954

732

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

955

733

return e

956

734

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

957

# Add property tags

958

735

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

959

736

for name, prop

960

in self._get_all_dbus_things("property")

737

in self._get_all_dbus_properties()

961

738

if prop._dbus_interface

962

739

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

963

740

if_tag.appendChild(tag)

964

# Add annotation tags

965

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

966

for tag in if_tag.getElementsByTagName(typ):

967

annots = dict()

968

for name, prop in (self.

969

_get_all_dbus_things(typ)):

970

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

971

and prop._dbus_interface

972

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

973

annots.update(getattr

974

(prop,

975

"_dbus_annotations",

976

{}))

977

for name, value in annots.iteritems():

978

ann_tag = document.createElement(

979

"annotation")

980

ann_tag.setAttribute("name", name)

981

ann_tag.setAttribute("value", value)

982

tag.appendChild(ann_tag)

983

# Add interface annotation tags

984

for annotation, value in dict(

985

itertools.chain.from_iterable(

986

annotations().iteritems()

987

for name, annotations in

988

self._get_all_dbus_things("interface")

989

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

990

)).iteritems():

991

ann_tag = document.createElement("annotation")

992

ann_tag.setAttribute("name", annotation)

993

ann_tag.setAttribute("value", value)

994

if_tag.appendChild(ann_tag)

995

741

# Add the names to the return values for the

996

742

# "org.freedesktop.DBus.Properties" methods

997

743

if (if_tag.getAttribute("name")

1012

758

except (AttributeError, xml.dom.DOMException,

1013

759

xml.parsers.expat.ExpatError) as error:

1014

760

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

1015

exc_info=error)

761

error)

1016

762

return xmlstring

1017

763

1018

764

1023

769

return dbus.String(dt.isoformat(),

1024

770

variant_level=variant_level)

1025

771

1026

1027

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1028

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

1029

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

1030

interface names according to the "alt_interface_names" mapping.

1031

Usage:

1032

1033

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

1034

"net.example.AlternateInterface"})

1035

class SampleDBusObject(dbus.service.Object):

1036

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

1037

def SampleDBusMethod():

1038

pass

1039

1040

The above "SampleDBusMethod" on "SampleDBusObject" will be

1041

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

1042

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

1043

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

1044

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

1045

1046

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

1047

(from DBusObjectWithProperties) and interfaces (from the

1048

dbus_interface_annotations decorator).

772

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

773

.__metaclass__):

774

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

775

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

1049

776

"""

1050

def wrapper(cls):

1051

for orig_interface_name, alt_interface_name in (

1052

alt_interface_names.iteritems()):

1053

attr = {}

1054

interface_names = set()

1055

# Go though all attributes of the class

1056

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

777

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

778

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

779

# methods, signals, or properties in them

780

for base in (b for b in bases

781

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

782

# Go though all attributes of the base class

783

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

1057

784

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

1058

785

# with the wrong interface name

1059

786

if (not hasattr(attribute, "_dbus_interface")

1060

787

or not attribute._dbus_interface

1061

.startswith(orig_interface_name)):

788

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

1062

789

continue

1063

790

# Create an alternate D-Bus interface name based on

1064

791

# the current name

1065

792

alt_interface = (attribute._dbus_interface

1066

.replace(orig_interface_name,

1067

alt_interface_name))

1068

interface_names.add(alt_interface)

793

.replace("se.recompile.Mandos",

794

"se.bsnet.fukt.Mandos"))

1069

795

# Is this a D-Bus signal?

1070

796

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

1071

797

# Extract the original non-method function by

1086

812

nonmethod_func.func_name,

1087

813

nonmethod_func.func_defaults,

1088

814

nonmethod_func.func_closure)))

1089

# Copy annotations, if any

1090

try:

1091

new_function._dbus_annotations = (

1092

dict(attribute._dbus_annotations))

1093

except AttributeError:

1094

pass

1095

815

# Define a creator of a function to call both the

1096

# original and alternate functions, so both the

1097

# original and alternate signals gets sent when

1098

# the function is called

816

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

817

# signals gets sent when the function is called

1099

818

def fixscope(func1, func2):

1100

819

"""This function is a scope container to pass

1101

820

func1 and func2 to the "call_both" function

1108

827

return call_both

1109

828

# Create the "call_both" function and add it to

1110

829

# the class

1111

attr[attrname] = fixscope(attribute, new_function)

830

attr[attrname] = fixscope(attribute,

831

new_function)

1112

832

# Is this a D-Bus method?

1113

833

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

1114

834

# Create a new, but exactly alike, function

1125

845

attribute.func_name,

1126

846

attribute.func_defaults,

1127

847

attribute.func_closure)))

1128

# Copy annotations, if any

1129

try:

1130

attr[attrname]._dbus_annotations = (

1131

dict(attribute._dbus_annotations))

1132

except AttributeError:

1133

pass

1134

848

# Is this a D-Bus property?

1135

849

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

1136

850

# Create a new, but exactly alike, function

1150

864

attribute.func_name,

1151

865

attribute.func_defaults,

1152

866

attribute.func_closure)))

1153

# Copy annotations, if any

1154

try:

1155

attr[attrname]._dbus_annotations = (

1156

dict(attribute._dbus_annotations))

1157

except AttributeError:

1158

pass

1159

# Is this a D-Bus interface?

1160

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

1161

# Create a new, but exactly alike, function

1162

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

1163

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

1164

# to the class.

1165

attr[attrname] = (dbus_interface_annotations

1166

(alt_interface)

1167

(types.FunctionType

1168

(attribute.func_code,

1169

attribute.func_globals,

1170

attribute.func_name,

1171

attribute.func_defaults,

1172

attribute.func_closure)))

1173

if deprecate:

1174

# Deprecate all alternate interfaces

1175

iname="_AlternateDBusNames_interface_annotation{0}"

1176

for interface_name in interface_names:

1177

@dbus_interface_annotations(interface_name)

1178

def func(self):

1179

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

1180

"true" }

1181

# Find an unused name

1182

for aname in (iname.format(i)

1183

for i in itertools.count()):

1184

if aname not in attr:

1185

attr[aname] = func

1186

break

1187

if interface_names:

1188

# Replace the class with a new subclass of it with

1189

# methods, signals, etc. as created above.

1190

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

1191

(cls,), attr)

1192

return cls

1193

return wrapper

1194

1195

1196

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

1197

"se.bsnet.fukt.Mandos"})

867

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

868

1198

869

class ClientDBus(Client, DBusObjectWithProperties):

1199

870

"""A Client class using D-Bus

1200

871

1209

880

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

1210

881

1211

882

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

883

self._approvals_pending = 0

1212

884

self.bus = bus

1213

885

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

1214

886

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

1220

892

("/clients/" + client_object_name))

1221

893

DBusObjectWithProperties.__init__(self, self.bus,

1222

894

self.dbus_object_path)

1223

895

1224

896

def notifychangeproperty(transform_func,

1225

897

dbus_name, type_func=lambda x: x,

1226

898

variant_level=1):

1227

899

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

1228

900

its changes to DBus.

1229

901

1230

902

transform_fun: Function that takes a value and a variant_level

1231

903

and transforms it to a D-Bus type.

1232

904

dbus_name: D-Bus name of the variable

1249

921

1250

922

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

1251

923

924

1252

925

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1253

926

approvals_pending = notifychangeproperty(dbus.Boolean,

1254

927

"ApprovalPending",

1261

934

checker is not None)

1262

935

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1263

936

"LastCheckedOK")

1264

last_checker_status = notifychangeproperty(dbus.Int16,

1265

"LastCheckerStatus")

1266

937

last_approval_request = notifychangeproperty(

1267

938

datetime_to_dbus, "LastApprovalRequest")

1268

939

approved_by_default = notifychangeproperty(dbus.Boolean,

1269

940

"ApprovedByDefault")

1270

approval_delay = notifychangeproperty(dbus.UInt64,

941

approval_delay = notifychangeproperty(dbus.UInt16,

1271

942

"ApprovalDelay",

1272

943

type_func =

1273

timedelta_to_milliseconds)

944

_timedelta_to_milliseconds)

1274

945

approval_duration = notifychangeproperty(

1275

dbus.UInt64, "ApprovalDuration",

1276

type_func = timedelta_to_milliseconds)

946

dbus.UInt16, "ApprovalDuration",

947

type_func = _timedelta_to_milliseconds)

1277

948

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

1278

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

949

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

1279

950

type_func =

1280

timedelta_to_milliseconds)

951

_timedelta_to_milliseconds)

1281

952

extended_timeout = notifychangeproperty(

1282

dbus.UInt64, "ExtendedTimeout",

1283

type_func = timedelta_to_milliseconds)

1284

interval = notifychangeproperty(dbus.UInt64,

953

dbus.UInt16, "ExtendedTimeout",

954

type_func = _timedelta_to_milliseconds)

955

interval = notifychangeproperty(dbus.UInt16,

1285

956

"Interval",

1286

957

type_func =

1287

timedelta_to_milliseconds)

958

_timedelta_to_milliseconds)

1288

959

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

1289

960

1290

961

del notifychangeproperty

1332

1003

return r

1333

1004

1334

1005

def _reset_approved(self):

1335

self.approved = None

1006

self._approved = None

1336

1007

return False

1337

1008

1338

1009

def approve(self, value=True):

1339

self.approved = value

1340

gobject.timeout_add(timedelta_to_milliseconds

1010

self.send_changedstate()

1011

self._approved = value

1012

gobject.timeout_add(_timedelta_to_milliseconds

1341

1013

(self.approval_duration),

1342

1014

self._reset_approved)

1343

self.send_changedstate()

1015

1344

1016

1345

1017

## D-Bus methods, signals & properties

1346

1018

_interface = "se.recompile.Mandos.Client"

1347

1019

1348

## Interfaces

1349

1350

@dbus_interface_annotations(_interface)

1351

def _foo(self):

1352

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

1353

"false"}

1354

1355

1020

## Signals

1356

1021

1357

1022

# CheckerCompleted - signal

1456

1121

access="readwrite")

1457

1122

def ApprovalDuration_dbus_property(self, value=None):

1458

1123

if value is None: # get

1459

return dbus.UInt64(timedelta_to_milliseconds(

1124

return dbus.UInt64(_timedelta_to_milliseconds(

1460

1125

self.approval_duration))

1461

1126

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

1462

1127

1476

1141

def Host_dbus_property(self, value=None):

1477

1142

if value is None: # get

1478

1143

return dbus.String(self.host)

1479

self.host = unicode(value)

1144

self.host = value

1480

1145

1481

1146

# Created - property

1482

1147

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

1483

1148

def Created_dbus_property(self):

1484

return datetime_to_dbus(self.created)

1149

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

1485

1150

1486

1151

# LastEnabled - property

1487

1152

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

1508

1173

return

1509

1174

return datetime_to_dbus(self.last_checked_ok)

1510

1175

1511

# LastCheckerStatus - property

1512

@dbus_service_property(_interface, signature="n",

1513

access="read")

1514

def LastCheckerStatus_dbus_property(self):

1515

return dbus.Int16(self.last_checker_status)

1516

1517

1176

# Expires - property

1518

1177

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

1519

1178

def Expires_dbus_property(self):

1530

1189

def Timeout_dbus_property(self, value=None):

1531

1190

if value is None: # get

1532

1191

return dbus.UInt64(self.timeout_milliseconds())

1533

old_timeout = self.timeout

1534

1192

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

1535

# Reschedule disabling

1536

if self.enabled:

1537

now = datetime.datetime.utcnow()

1538

self.expires += self.timeout - old_timeout

1539

if self.expires <= now:

1540

# The timeout has passed

1541

self.disable()

1542

else:

1543

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

1544

is None):

1545

return

1546

gobject.source_remove(self.disable_initiator_tag)

1547

self.disable_initiator_tag = (

1548

gobject.timeout_add(

1549

timedelta_to_milliseconds(self.expires - now),

1550

self.disable))

1193

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

1194

return

1195

# Reschedule timeout

1196

gobject.source_remove(self.disable_initiator_tag)

1197

self.disable_initiator_tag = None

1198

self.expires = None

1199

time_to_die = _timedelta_to_milliseconds((self

1200

.last_checked_ok

1201

+ self.timeout)

1202

- datetime.datetime

1203

.utcnow())

1204

if time_to_die <= 0:

1205

# The timeout has passed

1206

self.disable()

1207

else:

1208

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

1209

+ datetime.timedelta(milliseconds =

1210

time_to_die))

1211

self.disable_initiator_tag = (gobject.timeout_add

1212

(time_to_die, self.disable))

1551

1213

1552

1214

# ExtendedTimeout - property

1553

1215

@dbus_service_property(_interface, signature="t",

1566

1228

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

1567

1229

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

1568

1230

return

1569

if self.enabled:

1570

# Reschedule checker run

1571

gobject.source_remove(self.checker_initiator_tag)

1572

self.checker_initiator_tag = (gobject.timeout_add

1573

(value, self.start_checker))

1574

self.start_checker() # Start one now, too

1231

# Reschedule checker run

1232

gobject.source_remove(self.checker_initiator_tag)

1233

self.checker_initiator_tag = (gobject.timeout_add

1234

(value, self.start_checker))

1235

self.start_checker() # Start one now, too

1575

1236

1576

1237

# Checker - property

1577

1238

@dbus_service_property(_interface, signature="s",

1579

1240

def Checker_dbus_property(self, value=None):

1580

1241

if value is None: # get

1581

1242

return dbus.String(self.checker_command)

1582

self.checker_command = unicode(value)

1243

self.checker_command = value

1583

1244

1584

1245

# CheckerRunning - property

1585

1246

@dbus_service_property(_interface, signature="b",

1614

1275

raise KeyError()

1615

1276

1616

1277

def __getattribute__(self, name):

1617

if name == '_pipe':

1278

if(name == '_pipe'):

1618

1279

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

1619

1280

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

1620

1281

data = self._pipe.recv()

1627

1288

return func

1628

1289

1629

1290

def __setattr__(self, name, value):

1630

if name == '_pipe':

1291

if(name == '_pipe'):

1631

1292

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

1632

1293

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

1633

1294

1295

class ClientDBusTransitional(ClientDBus):

1296

__metaclass__ = AlternateDBusNamesMetaclass

1634

1297

1635

1298

class ClientHandler(socketserver.BaseRequestHandler, object):

1636

1299

"""A class to handle client connections.

1719

1382

client.Rejected("Disabled")

1720

1383

return

1721

1384

1722

if client.approved or not client.approval_delay:

1385

if client._approved or not client.approval_delay:

1723

1386

#We are approved or approval is disabled

1724

1387

break

1725

elif client.approved is None:

1388

elif client._approved is None:

1726

1389

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

1727

1390

client.name)

1728

1391

if self.server.use_dbus:

1741

1404

#wait until timeout or approved

1742

1405

time = datetime.datetime.now()

1743

1406

client.changedstate.acquire()

1744

client.changedstate.wait(

1745

float(timedelta_to_milliseconds(delay)

1746

/ 1000))

1407

(client.changedstate.wait

1408

(float(client._timedelta_to_milliseconds(delay)

1409

/ 1000)))

1747

1410

client.changedstate.release()

1748

1411

time2 = datetime.datetime.now()

1749

1412

if (time2 - time) >= delay:

1765

1428

try:

1766

1429

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

1767

1430

except gnutls.errors.GNUTLSError as error:

1768

logger.warning("gnutls send failed",

1769

exc_info=error)

1431

logger.warning("gnutls send failed")

1770

1432

return

1771

1433

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

1772

1434

sent, len(client.secret)

1775

1437

1776

1438

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

1777

1439

# bump the timeout using extended_timeout

1778

client.bump_timeout(client.extended_timeout)

1440

client.checked_ok(client.extended_timeout)

1779

1441

if self.server.use_dbus:

1780

1442

# Emit D-Bus signal

1781

1443

client.GotSecret()

1786

1448

try:

1787

1449

session.bye()

1788

1450

except gnutls.errors.GNUTLSError as error:

1789

logger.warning("GnuTLS bye failed",

1790

exc_info=error)

1451

logger.warning("GnuTLS bye failed")

1791

1452

1792

1453

@staticmethod

1793

1454

def peer_certificate(session):

1849

1510

# Convert the buffer to a Python bytestring

1850

1511

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

1851

1512

# Convert the bytestring to hexadecimal notation

1852

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

1513

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

1853

1514

return hex_fpr

1854

1515

1855

1516

1858

1519

def sub_process_main(self, request, address):

1859

1520

try:

1860

1521

self.finish_request(request, address)

1861

except Exception:

1522

except:

1862

1523

self.handle_error(request, address)

1863

1524

self.close_request(request)

1864

1525

1865

1526

def process_request(self, request, address):

1866

1527

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

1867

1528

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

1868

args = (request, address))

1529

args = (request,

1530

address))

1869

1531

proc.start()

1870

1532

return proc

1871

1533

1921

1583

str(self.interface

1922

1584

+ '\0'))

1923

1585

except socket.error as error:

1924

if error.errno == errno.EPERM:

1586

if error[0] == errno.EPERM:

1925

1587

logger.error("No permission to"

1926

1588

" bind to interface %s",

1927

1589

self.interface)

1928

elif error.errno == errno.ENOPROTOOPT:

1590

elif error[0] == errno.ENOPROTOOPT:

1929

1591

logger.error("SO_BINDTODEVICE not available;"

1930

1592

" cannot bind to interface %s",

1931

1593

self.interface)

1932

elif error.errno == errno.ENODEV:

1933

logger.error("Interface %s does not"

1934

" exist, cannot bind",

1935

self.interface)

1936

1594

else:

1937

1595

raise

1938

1596

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

1972

1630

self.enabled = False

1973

1631

self.clients = clients

1974

1632

if self.clients is None:

1975

self.clients = {}

1633

self.clients = set()

1976

1634

self.use_dbus = use_dbus

1977

1635

self.gnutls_priority = gnutls_priority

1978

1636

IPv6_TCPServer.__init__(self, server_address,

1997

1655

1998

1656

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

1999

1657

proc = None, client_object=None):

1658

condition_names = {

1659

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

1660

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

1661

# blocking).

1662

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

1663

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

1664

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

1665

# broken, usually for pipes and

1666

# sockets).

1667

}

1668

conditions_string = ' | '.join(name

1669

for cond, name in

1670

condition_names.iteritems()

1671

if cond & condition)

2000

1672

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

2001

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

1673

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

2002

1674

# Wait for other process to exit

2003

1675

proc.join()

2004

1676

return False

2011

1683

fpr = request[1]

2012

1684

address = request[2]

2013

1685

2014

for c in self.clients.itervalues():

1686

for c in self.clients:

2015

1687

if c.fingerprint == fpr:

2016

1688

client = c

2017

1689

break

2094

1766

elif suffix == "w":

2095

1767

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

2096

1768

else:

2097

raise ValueError("Unknown suffix {0!r}"

2098

.format(suffix))

1769

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

2099

1770

except (ValueError, IndexError) as e:

2100

1771

raise ValueError(*(e.args))

2101

1772

timevalue += delta

2102

1773

return timevalue

2103

1774

2104

1775

1776

def if_nametoindex(interface):

1777

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

1778

1779

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

1780

global if_nametoindex

1781

try:

1782

if_nametoindex = (ctypes.cdll.LoadLibrary

1783

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

1784

.if_nametoindex)

1785

except (OSError, AttributeError):

1786

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

1787

def if_nametoindex(interface):

1788

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

1789

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

1790

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

1791

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1792

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

1793

interface))

1794

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

1795

ifreq[16:20])[0]

1796

return interface_index

1797

return if_nametoindex(interface)

1798

1799

2105

1800

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

2106

1801

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

2107

1802

2115

1810

sys.exit()

2116

1811

if not noclose:

2117

1812

# Close all standard open file descriptors

2118

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

1813

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

2119

1814

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

2120

1815

raise OSError(errno.ENODEV,

2121

"{0} not a character device"

2122

.format(os.devnull))

1816

"%s not a character device"

1817

% os.path.devnull)

2123

1818

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

2124

1819

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

2125

1820

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

2134

1829

2135

1830

parser = argparse.ArgumentParser()

2136

1831

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

2137

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

1832

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

2138

1833

help="show version number and exit")

2139

1834

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

2140

1835

help="Bind to interface IF")

2162

1857

" system bus interface")

2163

1858

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

2164

1859

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

2165

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

2166

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

2167

" state")

2168

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

2169

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

2170

2171

1860

options = parser.parse_args()

2172

1861

2173

1862

if options.check:

2186

1875

"use_dbus": "True",

2187

1876

"use_ipv6": "True",

2188

1877

"debuglevel": "",

2189

"restore": "True",

2190

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

2191

1878

}

2192

1879

2193

1880

# Parse config file for server-global settings

2210

1897

# options, if set.

2211

1898

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

2212

1899

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

2213

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

2214

"statedir"):

1900

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

2215

1901

value = getattr(options, option)

2216

1902

if value is not None:

2217

1903

server_settings[option] = value

2229

1915

debuglevel = server_settings["debuglevel"]

2230

1916

use_dbus = server_settings["use_dbus"]

2231

1917

use_ipv6 = server_settings["use_ipv6"]

2232

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

2233

stored_state_file)

2234

2235

if debug:

2236

initlogger(debug, logging.DEBUG)

2237

else:

2238

if not debuglevel:

2239

initlogger(debug)

2240

else:

2241

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

2242

initlogger(debug, level)

2243

1918

2244

1919

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

2245

1920

syslogger.setFormatter(logging.Formatter

2246

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

2247

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

2248

.format(server_settings

2249

["servicename"])))

1921

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

1922

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

1923

% server_settings["servicename"]))

2250

1924

2251

1925

# Parse config file with clients

2252

client_config = configparser.SafeConfigParser(Client

2253

.client_defaults)

1926

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

1927

"extended_timeout": "15m",

1928

"interval": "2m",

1929

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

1930

"host": "",

1931

"approval_delay": "0s",

1932

"approval_duration": "1s",

1933

}

1934

client_config = configparser.SafeConfigParser(client_defaults)

2254

1935

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

2255

1936

"clients.conf"))

2256

1937

2270

1951

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

2271

1952

try:

2272

1953

pidfile = open(pidfilename, "w")

2273

except IOError as e:

2274

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

2275

exc_info=e)

1954

except IOError:

1955

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

2276

1956

2277

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

1957

try:

1958

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

1959

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

1960

except KeyError:

2278

1961

try:

2279

uid = pwd.getpwnam(name).pw_uid

2280

gid = pwd.getpwnam(name).pw_gid

2281

break

1962

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

1963

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

2282

1964

except KeyError:

2283

continue

2284

else:

2285

uid = 65534

2286

gid = 65534

1965

try:

1966

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

1967

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

1968

except KeyError:

1969

uid = 65534

1970

gid = 65534

2287

1971

try:

2288

1972

os.setgid(gid)

2289

1973

os.setuid(uid)

2290

1974

except OSError as error:

2291

if error.errno != errno.EPERM:

1975

if error[0] != errno.EPERM:

2292

1976

raise error

2293

1977

1978

if not debug and not debuglevel:

1979

logger.setLevel(logging.WARNING)

1980

if debuglevel:

1981

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

1982

logger.setLevel(level)

1983

2294

1984

if debug:

1985

logger.setLevel(logging.DEBUG)

2295

1986

# Enable all possible GnuTLS debugging

2296

1987

2297

1988

# "Use a log level over 10 to enable all debugging options."

2306

1997

.gnutls_global_set_log_function(debug_gnutls))

2307

1998

2308

1999

# Redirect stdin so all checkers get /dev/null

2309

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

2000

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

2310

2001

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

2311

2002

if null > 2:

2312

2003

os.close(null)

2004

else:

2005

# No console logging

2006

logger.removeHandler(console)

2313

2007

2314

2008

# Need to fork before connecting to D-Bus

2315

2009

if not debug:

2316

2010

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

2317

2011

daemon()

2318

2012

2319

gobject.threads_init()

2320

2321

2013

global main_loop

2322

2014

# From the Avahi example code

2323

DBusGMainLoop(set_as_default=True)

2015

DBusGMainLoop(set_as_default=True )

2324

2016

main_loop = gobject.MainLoop()

2325

2017

bus = dbus.SystemBus()

2326

2018

# End of Avahi example code

2332

2024

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

2333

2025

do_not_queue=True))

2334

2026

except dbus.exceptions.NameExistsException as e:

2335

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

2027

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

2336

2028

use_dbus = False

2337

2029

server_settings["use_dbus"] = False

2338

2030

tcp_server.use_dbus = False

2350

2042

2351

2043

client_class = Client

2352

2044

if use_dbus:

2353

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

2354

2355

client_settings = Client.config_parser(client_config)

2356

old_client_settings = {}

2357

clients_data = {}

2358

2359

# Get client data and settings from last running state.

2360

if server_settings["restore"]:

2361

try:

2362

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

2363

clients_data, old_client_settings = (pickle.load

2364

(stored_state))

2365

os.remove(stored_state_path)

2366

except IOError as e:

2367

if e.errno == errno.ENOENT:

2368

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

2369

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

2370

else:

2371

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

2372

exc_info=e)

2373

raise

2374

except EOFError as e:

2375

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

2376

"EOFError:", exc_info=e)

2377

2378

with PGPEngine() as pgp:

2379

for client_name, client in clients_data.iteritems():

2380

# Decide which value to use after restoring saved state.

2381

# We have three different values: Old config file,

2382

# new config file, and saved state.

2383

# New config value takes precedence if it differs from old

2384

# config value, otherwise use saved state.

2385

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

2386

try:

2387

# For each value in new config, check if it

2388

# differs from the old config value (Except for

2389

# the "secret" attribute)

2390

if (name != "secret" and

2391

value != old_client_settings[client_name]

2392

[name]):

2393

client[name] = value

2394

except KeyError:

2395

pass

2396

2397

# Clients who has passed its expire date can still be

2398

# enabled if its last checker was successful. Clients

2399

# whose checker succeeded before we stored its state is

2400

# assumed to have successfully run all checkers during

2401

# downtime.

2402

if client["enabled"]:

2403

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

2404

if not client["last_checked_ok"]:

2405

logger.warning(

2406

"disabling client {0} - Client never "

2407

"performed a successful checker"

2408

.format(client_name))

2409

client["enabled"] = False

2410

elif client["last_checker_status"] != 0:

2411

logger.warning(

2412

"disabling client {0} - Client "

2413

"last checker failed with error code {1}"

2414

.format(client_name,

2415

client["last_checker_status"]))

2416

client["enabled"] = False

2417

else:

2418

client["expires"] = (datetime.datetime

2419

.utcnow()

2420

+ client["timeout"])

2421

logger.debug("Last checker succeeded,"

2422

" keeping {0} enabled"

2423

.format(client_name))

2045

client_class = functools.partial(ClientDBusTransitional,

2046

bus = bus)

2047

def client_config_items(config, section):

2048

special_settings = {

2049

"approved_by_default":

2050

lambda: config.getboolean(section,

2051

"approved_by_default"),

2052

}

2053

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

2424

2054

try:

2425

client["secret"] = (

2426

pgp.decrypt(client["encrypted_secret"],

2427

client_settings[client_name]

2428

["secret"]))

2429

except PGPError:

2430

# If decryption fails, we use secret from new settings

2431

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

2432

.format(client_name))

2433

client["secret"] = (

2434

client_settings[client_name]["secret"])

2435

2436

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

2437

for client_name in (set(old_client_settings)

2438

- set(client_settings)):

2439

del clients_data[client_name]

2440

for client_name in (set(client_settings)

2441

- set(old_client_settings)):

2442

clients_data[client_name] = client_settings[client_name]

2443

2444

# Create all client objects

2445

for client_name, client in clients_data.iteritems():

2446

tcp_server.clients[client_name] = client_class(

2447

name = client_name, settings = client)

2448

2055

yield (name, special_settings[name]())

2056

except KeyError:

2057

yield (name, value)

2058

2059

tcp_server.clients.update(set(

2060

client_class(name = section,

2061

config= dict(client_config_items(

2062

client_config, section)))

2063

for section in client_config.sections()))

2449

2064

if not tcp_server.clients:

2450

2065

logger.warning("No clients defined")

2451

2066

2452

2067

if not debug:

2453

2068

try:

2454

2069

with pidfile:

2462

2077

# "pidfile" was never created

2463

2078

pass

2464

2079

del pidfilename

2080

2081

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

2465

2082

2466

2083

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

2467

2084

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

2468

2085

2469

2086

if use_dbus:

2470

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

2471

"se.bsnet.fukt.Mandos"})

2472

class MandosDBusService(DBusObjectWithProperties):

2087

class MandosDBusService(dbus.service.Object):

2473

2088

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

2474

2089

def __init__(self):

2475

2090

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

2476

2091

_interface = "se.recompile.Mandos"

2477

2092

2478

@dbus_interface_annotations(_interface)

2479

def _foo(self):

2480

return { "org.freedesktop.DBus.Property"

2481

".EmitsChangedSignal":

2482

"false"}

2483

2484

2093

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

2485

2094

def ClientAdded(self, objpath):

2486

2095

"D-Bus signal"

2500

2109

def GetAllClients(self):

2501

2110

"D-Bus method"

2502

2111

return dbus.Array(c.dbus_object_path

2503

for c in

2504

tcp_server.clients.itervalues())

2112

for c in tcp_server.clients)

2505

2113

2506

2114

@dbus.service.method(_interface,

2507

2115

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

2509

2117

"D-Bus method"

2510

2118

return dbus.Dictionary(

2511

2119

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

2512

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

2120

for c in tcp_server.clients),

2513

2121

signature="oa{sv}")

2514

2122

2515

2123

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

2516

2124

def RemoveClient(self, object_path):

2517

2125

"D-Bus method"

2518

for c in tcp_server.clients.itervalues():

2126

for c in tcp_server.clients:

2519

2127

if c.dbus_object_path == object_path:

2520

del tcp_server.clients[c.name]

2128

tcp_server.clients.remove(c)

2521

2129

c.remove_from_connection()

2522

2130

# Don't signal anything except ClientRemoved

2523

2131

c.disable(quiet=True)

2528

2136

2529

2137

del _interface

2530

2138

2531

mandos_dbus_service = MandosDBusService()

2139

class MandosDBusServiceTransitional(MandosDBusService):

2140

__metaclass__ = AlternateDBusNamesMetaclass

2141

mandos_dbus_service = MandosDBusServiceTransitional()

2532

2142

2533

2143

def cleanup():

2534

2144

"Cleanup function; run on exit"

2535

2145

service.cleanup()

2536

2146

2537

2147

multiprocessing.active_children()

2538

if not (tcp_server.clients or client_settings):

2539

return

2540

2541

# Store client before exiting. Secrets are encrypted with key

2542

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

2543

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

2544

clients = {}

2545

with PGPEngine() as pgp:

2546

for client in tcp_server.clients.itervalues():

2547

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

2548

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

2549

key)

2550

client_dict = {}

2551

2552

# A list of attributes that can not be pickled

2553

# + secret.

2554

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

2555

"checker"))

2556

for name, typ in (inspect.getmembers

2557

(dbus.service.Object)):

2558

exclude.add(name)

2559

2560

client_dict["encrypted_secret"] = (client

2561

.encrypted_secret)

2562

for attr in client.client_structure:

2563

if attr not in exclude:

2564

client_dict[attr] = getattr(client, attr)

2565

2566

clients[client.name] = client_dict

2567

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

2568

2569

try:

2570

with (tempfile.NamedTemporaryFile

2571

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

2572

dir=os.path.dirname(stored_state_path),

2573

delete=False)) as stored_state:

2574

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

2575

tempname=stored_state.name

2576

os.rename(tempname, stored_state_path)

2577

except (IOError, OSError) as e:

2578

if not debug:

2579

try:

2580

os.remove(tempname)

2581

except NameError:

2582

pass

2583

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

2584

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

2585

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

2586

else:

2587

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

2588

exc_info=e)

2589

raise e

2590

2591

# Delete all clients, and settings from config

2592

2148

while tcp_server.clients:

2593

name, client = tcp_server.clients.popitem()

2149

client = tcp_server.clients.pop()

2594

2150

if use_dbus:

2595

2151

client.remove_from_connection()

2152

client.disable_hook = None

2596

2153

# Don't signal anything except ClientRemoved

2597

2154

client.disable(quiet=True)

2598

2155

if use_dbus:

2600

2157

mandos_dbus_service.ClientRemoved(client

2601

2158

.dbus_object_path,

2602

2159

client.name)

2603

client_settings.clear()

2604

2160

2605

2161

atexit.register(cleanup)

2606

2162

2607

for client in tcp_server.clients.itervalues():

2163

for client in tcp_server.clients:

2608

2164

if use_dbus:

2609

2165

# Emit D-Bus signal

2610

2166

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2611

# Need to initiate checking of clients

2612

if client.enabled:

2613

client.init_checker()

2167

client.enable()

2614

2168

2615

2169

tcp_server.enable()

2616

2170

tcp_server.server_activate()

2619

2173

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

2620

2174

if use_ipv6:

2621

2175

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

2622

" flowinfo %d, scope_id %d",

2623

*tcp_server.socket.getsockname())

2176

" flowinfo %d, scope_id %d"

2177

% tcp_server.socket.getsockname())

2624

2178

else: # IPv4

2625

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

2626

*tcp_server.socket.getsockname())

2179

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

2180

% tcp_server.socket.getsockname())

2627

2181

2628

2182

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

2629

2183

2632

2186

try:

2633

2187

service.activate()

2634

2188

except dbus.exceptions.DBusException as error:

2635

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

2189

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

2636

2190

cleanup()

2637

2191

sys.exit(1)

2638

2192

# End of Avahi example code

2645

2199

logger.debug("Starting main loop")

2646

2200

main_loop.run()

2647

2201

except AvahiError as error:

2648

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

2202

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

2649

2203

cleanup()

2650

2204

sys.exit(1)

2651

2205

except KeyboardInterrupt:

2656

2210

# Must run before the D-Bus bus name gets deregistered

2657

2211

cleanup()

2658

2212

2213

2659

2214

if __name__ == '__main__':

2660

2215

main()