/mandos/trunk : revision 505.1.14

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

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

85

86

version = "1.4.0"

87

88

#logger = logging.getLogger('mandos')

89

logger = logging.Logger('mandos')

95

90

syslogger = (logging.handlers.SysLogHandler

96

91

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

97

92

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

212

93

syslogger.setFormatter(logging.Formatter

94

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

95

' %(message)s'))

96

logger.addHandler(syslogger)

97

98

console = logging.StreamHandler()

99

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

100

' %(levelname)s:'

101

' %(message)s'))

102

logger.addHandler(console)

213

103

214

104

class AvahiError(Exception):

215

105

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

245

135

server: D-Bus Server

246

136

bus: dbus.SystemBus()

247

137

"""

248

249

138

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

250

139

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

251

140

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

264

153

self.server = None

265

154

self.bus = bus

266

155

self.entry_group_state_changed_match = None

267

268

156

def rename(self):

269

157

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

270

158

if self.rename_count >= self.max_renames:

276

164

.GetAlternativeServiceName(self.name))

277

165

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

278

166

self.name)

167

syslogger.setFormatter(logging.Formatter

168

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

169

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

170

% self.name))

279

171

self.remove()

280

172

try:

281

173

self.add()

282

174

except dbus.exceptions.DBusException as error:

283

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

175

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

284

176

self.cleanup()

285

177

os._exit(1)

286

178

self.rename_count += 1

287

288

179

def remove(self):

289

180

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

290

181

if self.entry_group_state_changed_match is not None:

292

183

self.entry_group_state_changed_match = None

293

184

if self.group is not None:

294

185

self.group.Reset()

295

296

186

def add(self):

297

187

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

298

188

self.remove()

303

193

avahi.DBUS_INTERFACE_ENTRY_GROUP)

304

194

self.entry_group_state_changed_match = (

305

195

self.group.connect_to_signal(

306

'StateChanged', self.entry_group_state_changed))

196

'StateChanged', self .entry_group_state_changed))

307

197

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

308

198

self.name, self.type)

309

199

self.group.AddService(

315

205

dbus.UInt16(self.port),

316

206

avahi.string_array_to_txt_array(self.TXT))

317

207

self.group.Commit()

318

319

208

def entry_group_state_changed(self, state, error):

320

209

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

321

210

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

328

217

elif state == avahi.ENTRY_GROUP_FAILURE:

329

218

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

330

219

unicode(error))

331

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

332

.format(error))

333

220

raise AvahiGroupError("State changed: %s"

221

% unicode(error))

334

222

def cleanup(self):

335

223

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

336

224

if self.group is not None:

337

225

try:

338

226

self.group.Free()

339

227

except (dbus.exceptions.UnknownMethodException,

340

dbus.exceptions.DBusException):

228

dbus.exceptions.DBusException) as e:

341

229

pass

342

230

self.group = None

343

231

self.remove()

344

345

232

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

346

233

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

347

234

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

366

253

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

367

254

else:

368

255

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

369

370

256

def activate(self):

371

257

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

372

258

if self.server is None:

380

266

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

381

267

382

268

383

class AvahiServiceToSyslog(AvahiService):

384

def rename(self):

385

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

386

ret = AvahiService.rename(self)

387

syslogger.setFormatter(logging.Formatter

388

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

389

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

390

.format(self.name)))

391

return ret

392

393

394

def timedelta_to_milliseconds(td):

269

def _timedelta_to_milliseconds(td):

395

270

"Convert a datetime.timedelta() to milliseconds"

396

271

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

397

272

+ (td.seconds * 1000)

398

273

+ (td.microseconds // 1000))

399

400

274

401

275

class Client(object):

402

276

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

403

277

404

278

Attributes:

405

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

279

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

406

280

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

407

281

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

408

282

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

415

289

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

416

290

checker_initiator_tag: a gobject event source tag, or None

417

291

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

292

current_checker_command: string; current running checker_command

293

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

421

294

disable_initiator_tag: a gobject event source tag, or None

422

295

enabled: bool()

423

296

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

426

299

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

427

300

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

428

301

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

302

last_enabled: datetime.datetime(); (UTC)

433

303

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

434

304

D-Bus identifiers

435

305

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

436

306

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

437

307

until this client is disabled

438

extended_timeout: extra long timeout when secret has been sent

308

extended_timeout: extra long timeout when password has been sent

439

309

runtime_expansions: Allowed attributes for runtime expansion.

440

310

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

441

311

disabled, or None

445

315

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

446

316

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

447

317

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

448

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

449

"extended_timeout": "15m",

450

"interval": "2m",

451

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

452

"host": "",

453

"approval_delay": "0s",

454

"approval_duration": "1s",

455

"approved_by_default": "True",

456

"enabled": "True",

457

}

458

318

459

319

def timeout_milliseconds(self):

460

320

"Return the 'timeout' attribute in milliseconds"

461

return timedelta_to_milliseconds(self.timeout)

321

return _timedelta_to_milliseconds(self.timeout)

462

322

463

323

def extended_timeout_milliseconds(self):

464

324

"Return the 'extended_timeout' attribute in milliseconds"

465

return timedelta_to_milliseconds(self.extended_timeout)

325

return _timedelta_to_milliseconds(self.extended_timeout)

466

326

467

327

def interval_milliseconds(self):

468

328

"Return the 'interval' attribute in milliseconds"

469

return timedelta_to_milliseconds(self.interval)

329

return _timedelta_to_milliseconds(self.interval)

470

330

471

331

def approval_delay_milliseconds(self):

472

return timedelta_to_milliseconds(self.approval_delay)

473

474

@staticmethod

475

def config_parser(config):

476

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

477

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

478

with exceptions for any special settings as defined above.

479

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

480

value given the same arguments.

481

"""

482

settings = {}

483

for client_name in config.sections():

484

section = dict(config.items(client_name))

485

client = settings[client_name] = {}

486

487

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

488

# Reformat values from string types to Python types

489

client["approved_by_default"] = config.getboolean(

490

client_name, "approved_by_default")

491

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

492

"enabled")

493

494

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

495

.replace(" ", ""))

496

if "secret" in section:

497

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

498

elif "secfile" in section:

499

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

500

(section["secfile"])),

501

"rb") as secfile:

502

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

503

else:

504

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

505

.format(section))

506

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

507

client["extended_timeout"] = string_to_delta(

508

section["extended_timeout"])

509

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

510

client["approval_delay"] = string_to_delta(

511

section["approval_delay"])

512

client["approval_duration"] = string_to_delta(

513

section["approval_duration"])

514

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

515

client["last_approval_request"] = None

516

client["last_checked_ok"] = None

517

client["last_checker_status"] = -2

518

519

return settings

520

521

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

332

return _timedelta_to_milliseconds(self.approval_delay)

333

334

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

335

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

336

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

337

attribute."""

522

338

self.name = name

523

# adding all client settings

524

for setting, value in settings.iteritems():

525

setattr(self, setting, value)

526

527

if self.enabled:

528

if not hasattr(self, "last_enabled"):

529

self.last_enabled = datetime.datetime.utcnow()

530

if not hasattr(self, "expires"):

531

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

532

+ self.timeout)

533

else:

534

self.last_enabled = None

535

self.expires = None

536

339

if config is None:

340

config = {}

537

341

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

538

342

# Uppercase and remove spaces from fingerprint for later

539

343

# comparison purposes with return value from the fingerprint()

540

344

# function

345

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

346

.replace(" ", ""))

541

347

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

542

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

543

datetime.datetime.utcnow())

544

545

# attributes specific for this server instance

348

if "secret" in config:

349

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

350

elif "secfile" in config:

351

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

352

(config["secfile"])),

353

"rb") as secfile:

354

self.secret = secfile.read()

355

else:

356

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

357

% self.name)

358

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

359

self.created = datetime.datetime.utcnow()

360

self.enabled = False

361

self.last_approval_request = None

362

self.last_enabled = None

363

self.last_checked_ok = None

364

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

365

self.extended_timeout = string_to_delta(config

366

["extended_timeout"])

367

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

368

self.disable_hook = disable_hook

546

369

self.checker = None

547

370

self.checker_initiator_tag = None

548

371

self.disable_initiator_tag = None

372

self.expires = None

549

373

self.checker_callback_tag = None

374

self.checker_command = config["checker"]

550

375

self.current_checker_command = None

551

self.approved = None

376

self.last_connect = None

377

self._approved = None

378

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

379

True)

552

380

self.approvals_pending = 0

381

self.approval_delay = string_to_delta(

382

config["approval_delay"])

383

self.approval_duration = string_to_delta(

384

config["approval_duration"])

553

385

self.changedstate = (multiprocessing_manager

554

386

.Condition(multiprocessing_manager

555

387

.Lock()))

556

self.client_structure = [attr for attr in

557

self.__dict__.iterkeys()

558

if not attr.startswith("_")]

559

self.client_structure.append("client_structure")

560

561

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

562

lambda obj:

563

isinstance(obj,

564

property)):

565

if not name.startswith("_"):

566

self.client_structure.append(name)

567

388

568

# Send notice to process children that client state has changed

569

389

def send_changedstate(self):

570

with self.changedstate:

571

self.changedstate.notify_all()

390

self.changedstate.acquire()

391

self.changedstate.notify_all()

392

self.changedstate.release()

572

393

573

394

def enable(self):

574

395

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

575

396

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

576

397

# Already enabled

577

398

return

399

self.send_changedstate()

400

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

401

# and every interval from then on.

402

self.checker_initiator_tag = (gobject.timeout_add

403

(self.interval_milliseconds(),

404

self.start_checker))

405

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

578

406

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

407

self.disable_initiator_tag = (gobject.timeout_add

408

(self.timeout_milliseconds(),

409

self.disable))

579

410

self.enabled = True

580

411

self.last_enabled = datetime.datetime.utcnow()

581

self.init_checker()

582

self.send_changedstate()

412

# Also start a new checker *right now*.

413

self.start_checker()

583

414

584

415

def disable(self, quiet=True):

585

416

"""Disable this client."""

586

417

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

587

418

return False

588

419

if not quiet:

420

self.send_changedstate()

421

if not quiet:

589

422

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

590

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

423

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

591

424

gobject.source_remove(self.disable_initiator_tag)

592

425

self.disable_initiator_tag = None

593

426

self.expires = None

594

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

427

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

595

428

gobject.source_remove(self.checker_initiator_tag)

596

429

self.checker_initiator_tag = None

597

430

self.stop_checker()

431

if self.disable_hook:

432

self.disable_hook(self)

598

433

self.enabled = False

599

if not quiet:

600

self.send_changedstate()

601

434

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

602

435

return False

603

436

604

437

def __del__(self):

438

self.disable_hook = None

605

439

self.disable()

606

440

607

def init_checker(self):

608

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

609

# and every interval from then on.

610

if self.checker_initiator_tag is not None:

611

gobject.source_remove(self.checker_initiator_tag)

612

self.checker_initiator_tag = (gobject.timeout_add

613

(self.interval_milliseconds(),

614

self.start_checker))

615

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

616

if self.disable_initiator_tag is not None:

617

gobject.source_remove(self.disable_initiator_tag)

618

self.disable_initiator_tag = (gobject.timeout_add

619

(self.timeout_milliseconds(),

620

self.disable))

621

# Also start a new checker *right now*.

622

self.start_checker()

623

624

441

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

625

442

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

626

443

self.checker_callback_tag = None

627

444

self.checker = None

628

445

if os.WIFEXITED(condition):

629

self.last_checker_status = os.WEXITSTATUS(condition)

630

if self.last_checker_status == 0:

446

exitstatus = os.WEXITSTATUS(condition)

447

if exitstatus == 0:

631

448

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

632

449

vars(self))

633

450

self.checked_ok()

635

452

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

636

453

vars(self))

637

454

else:

638

self.last_checker_status = -1

639

455

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

640

456

vars(self))

641

457

642

def checked_ok(self):

643

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

644

self.last_checked_ok = datetime.datetime.utcnow()

645

self.last_checker_status = 0

646

self.bump_timeout()

647

648

def bump_timeout(self, timeout=None):

649

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

458

def checked_ok(self, timeout=None):

459

"""Bump up the timeout for this client.

460

461

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

462

alive and well.

463

"""

650

464

if timeout is None:

651

465

timeout = self.timeout

652

if self.disable_initiator_tag is not None:

653

gobject.source_remove(self.disable_initiator_tag)

654

self.disable_initiator_tag = None

655

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

656

self.disable_initiator_tag = (gobject.timeout_add

657

(timedelta_to_milliseconds

658

(timeout), self.disable))

659

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

466

self.last_checked_ok = datetime.datetime.utcnow()

467

gobject.source_remove(self.disable_initiator_tag)

468

self.disable_initiator_tag = (gobject.timeout_add

469

(_timedelta_to_milliseconds

470

(timeout), self.disable))

471

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

660

472

661

473

def need_approval(self):

662

474

self.last_approval_request = datetime.datetime.utcnow()

667

479

If a checker already exists, leave it running and do

668

480

nothing."""

669

481

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

670

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

671

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

672

# would inevitably timeout, since no checker would get a

673

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

482

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

483

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

484

# client would inevitably timeout, since no checker would get

485

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

674

486

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

675

487

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

676

488

# should be.

706

518

try:

707

519

command = self.checker_command % escaped_attrs

708

520

except TypeError as error:

709

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

710

self.checker_command, exc_info=error)

521

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

522

' %s', self.checker_command, error)

711

523

return True # Try again later

712

524

self.current_checker_command = command

713

525

try:

731

543

gobject.source_remove(self.checker_callback_tag)

732

544

self.checker_callback(pid, status, command)

733

545

except OSError as error:

734

logger.error("Failed to start subprocess",

735

exc_info=error)

546

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

547

error)

736

548

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

737

549

return True

738

550

745

557

return

746

558

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

747

559

try:

748

self.checker.terminate()

560

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

749

561

#time.sleep(0.5)

750

562

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

751

# self.checker.kill()

563

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

752

564

except OSError as error:

753

565

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

754

566

raise

771

583

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

772

584

if byte_arrays and signature != "ay":

773

585

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

774

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

586

" signature %r" % signature)

775

587

def decorator(func):

776

588

func._dbus_is_property = True

777

589

func._dbus_interface = dbus_interface

785

597

return decorator

786

598

787

599

788

def dbus_interface_annotations(dbus_interface):

789

"""Decorator for marking functions returning interface annotations

790

791

Usage:

792

793

@dbus_interface_annotations("org.example.Interface")

794

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

795

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

796

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

797

"false"}

798

"""

799

def decorator(func):

800

func._dbus_is_interface = True

801

func._dbus_interface = dbus_interface

802

func._dbus_name = dbus_interface

803

return func

804

return decorator

805

806

807

def dbus_annotations(annotations):

808

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

809

Usage:

810

811

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

812

access="r")

813

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

814

"org.freedesktop.DBus.Property."

815

"EmitsChangedSignal": "false"})

816

def Property_dbus_property(self):

817

return dbus.Boolean(False)

818

"""

819

def decorator(func):

820

func._dbus_annotations = annotations

821

return func

822

return decorator

823

824

825

600

class DBusPropertyException(dbus.exceptions.DBusException):

826

601

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

827

602

"""

850

625

"""

851

626

852

627

@staticmethod

853

def _is_dbus_thing(thing):

854

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

855

856

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

857

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

858

"""

859

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

860

False)

628

def _is_dbus_property(obj):

629

return getattr(obj, "_dbus_is_property", False)

861

630

862

def _get_all_dbus_things(self, thing):

631

def _get_all_dbus_properties(self):

863

632

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

864

633

"""

865

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

866

name),

867

athing.__get__(self))

634

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

868

635

for cls in self.__class__.__mro__

869

for name, athing in

870

inspect.getmembers(cls,

871

self._is_dbus_thing(thing)))

636

for name, prop in

637

inspect.getmembers(cls, self._is_dbus_property))

872

638

873

639

def _get_dbus_property(self, interface_name, property_name):

874

640

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

876

642

"""

877

643

for cls in self.__class__.__mro__:

878

644

for name, value in (inspect.getmembers

879

(cls,

880

self._is_dbus_thing("property"))):

645

(cls, self._is_dbus_property)):

881

646

if (value._dbus_name == property_name

882

647

and value._dbus_interface == interface_name):

883

648

return value.__get__(self)

912

677

# signatures other than "ay".

913

678

if prop._dbus_signature != "ay":

914

679

raise ValueError

915

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

916

for byte in value))

680

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

681

for byte in value))

917

682

prop(value)

918

683

919

684

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

924

689

925

690

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

926

691

"""

927

properties = {}

928

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

692

all = {}

693

for name, prop in self._get_all_dbus_properties():

929

694

if (interface_name

930

695

and interface_name != prop._dbus_interface):

931

696

# Interface non-empty but did not match

935

700

continue

936

701

value = prop()

937

702

if not hasattr(value, "variant_level"):

938

properties[name] = value

703

all[name] = value

939

704

continue

940

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

941

value.variant_level+1)

942

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

705

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

706

value.variant_level+1)

707

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

943

708

944

709

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

945

710

out_signature="s",

946

711

path_keyword='object_path',

947

712

connection_keyword='connection')

948

713

def Introspect(self, object_path, connection):

949

"""Overloading of standard D-Bus method.

950

951

Inserts property tags and interface annotation tags.

714

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

952

715

"""

953

716

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

954

717

connection)

961

724

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

962

725

return e

963

726

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

964

# Add property tags

965

727

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

966

728

for name, prop

967

in self._get_all_dbus_things("property")

729

in self._get_all_dbus_properties()

968

730

if prop._dbus_interface

969

731

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

970

732

if_tag.appendChild(tag)

971

# Add annotation tags

972

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

973

for tag in if_tag.getElementsByTagName(typ):

974

annots = dict()

975

for name, prop in (self.

976

_get_all_dbus_things(typ)):

977

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

978

and prop._dbus_interface

979

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

980

annots.update(getattr

981

(prop,

982

"_dbus_annotations",

983

{}))

984

for name, value in annots.iteritems():

985

ann_tag = document.createElement(

986

"annotation")

987

ann_tag.setAttribute("name", name)

988

ann_tag.setAttribute("value", value)

989

tag.appendChild(ann_tag)

990

# Add interface annotation tags

991

for annotation, value in dict(

992

itertools.chain.from_iterable(

993

annotations().iteritems()

994

for name, annotations in

995

self._get_all_dbus_things("interface")

996

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

997

)).iteritems():

998

ann_tag = document.createElement("annotation")

999

ann_tag.setAttribute("name", annotation)

1000

ann_tag.setAttribute("value", value)

1001

if_tag.appendChild(ann_tag)

1002

733

# Add the names to the return values for the

1003

734

# "org.freedesktop.DBus.Properties" methods

1004

735

if (if_tag.getAttribute("name")

1019

750

except (AttributeError, xml.dom.DOMException,

1020

751

xml.parsers.expat.ExpatError) as error:

1021

752

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

1022

exc_info=error)

753

error)

1023

754

return xmlstring

1024

755

1025

756

1030

761

return dbus.String(dt.isoformat(),

1031

762

variant_level=variant_level)

1032

763

1033

1034

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1035

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

1036

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

1037

interface names according to the "alt_interface_names" mapping.

1038

Usage:

1039

1040

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

1041

"net.example.AlternateInterface"})

1042

class SampleDBusObject(dbus.service.Object):

1043

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

1044

def SampleDBusMethod():

1045

pass

1046

1047

The above "SampleDBusMethod" on "SampleDBusObject" will be

1048

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

1049

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

1050

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

1051

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

1052

1053

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

1054

(from DBusObjectWithProperties) and interfaces (from the

1055

dbus_interface_annotations decorator).

764

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

765

.__metaclass__):

766

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

767

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

1056

768

"""

1057

def wrapper(cls):

1058

for orig_interface_name, alt_interface_name in (

1059

alt_interface_names.iteritems()):

1060

attr = {}

1061

interface_names = set()

1062

# Go though all attributes of the class

1063

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

769

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

770

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

771

# methods, signals, or properties in them

772

for base in (b for b in bases

773

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

774

# Go though all attributes of the base class

775

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

1064

776

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

1065

777

# with the wrong interface name

1066

778

if (not hasattr(attribute, "_dbus_interface")

1067

779

or not attribute._dbus_interface

1068

.startswith(orig_interface_name)):

780

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

1069

781

continue

1070

782

# Create an alternate D-Bus interface name based on

1071

783

# the current name

1072

784

alt_interface = (attribute._dbus_interface

1073

.replace(orig_interface_name,

1074

alt_interface_name))

1075

interface_names.add(alt_interface)

785

.replace("se.recompile.Mandos",

786

"se.bsnet.fukt.Mandos"))

1076

787

# Is this a D-Bus signal?

1077

788

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

1078

789

# Extract the original non-method function by

1093

804

nonmethod_func.func_name,

1094

805

nonmethod_func.func_defaults,

1095

806

nonmethod_func.func_closure)))

1096

# Copy annotations, if any

1097

try:

1098

new_function._dbus_annotations = (

1099

dict(attribute._dbus_annotations))

1100

except AttributeError:

1101

pass

1102

807

# Define a creator of a function to call both the

1103

# original and alternate functions, so both the

1104

# original and alternate signals gets sent when

1105

# the function is called

808

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

809

# signals gets sent when the function is called

1106

810

def fixscope(func1, func2):

1107

811

"""This function is a scope container to pass

1108

812

func1 and func2 to the "call_both" function

1115

819

return call_both

1116

820

# Create the "call_both" function and add it to

1117

821

# the class

1118

attr[attrname] = fixscope(attribute, new_function)

822

attr[attrname] = fixscope(attribute,

823

new_function)

1119

824

# Is this a D-Bus method?

1120

825

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

1121

826

# Create a new, but exactly alike, function

1132

837

attribute.func_name,

1133

838

attribute.func_defaults,

1134

839

attribute.func_closure)))

1135

# Copy annotations, if any

1136

try:

1137

attr[attrname]._dbus_annotations = (

1138

dict(attribute._dbus_annotations))

1139

except AttributeError:

1140

pass

1141

840

# Is this a D-Bus property?

1142

841

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

1143

842

# Create a new, but exactly alike, function

1157

856

attribute.func_name,

1158

857

attribute.func_defaults,

1159

858

attribute.func_closure)))

1160

# Copy annotations, if any

1161

try:

1162

attr[attrname]._dbus_annotations = (

1163

dict(attribute._dbus_annotations))

1164

except AttributeError:

1165

pass

1166

# Is this a D-Bus interface?

1167

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

1168

# Create a new, but exactly alike, function

1169

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

1170

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

1171

# to the class.

1172

attr[attrname] = (dbus_interface_annotations

1173

(alt_interface)

1174

(types.FunctionType

1175

(attribute.func_code,

1176

attribute.func_globals,

1177

attribute.func_name,

1178

attribute.func_defaults,

1179

attribute.func_closure)))

1180

if deprecate:

1181

# Deprecate all alternate interfaces

1182

iname="_AlternateDBusNames_interface_annotation{0}"

1183

for interface_name in interface_names:

1184

@dbus_interface_annotations(interface_name)

1185

def func(self):

1186

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

1187

"true" }

1188

# Find an unused name

1189

for aname in (iname.format(i)

1190

for i in itertools.count()):

1191

if aname not in attr:

1192

attr[aname] = func

1193

break

1194

if interface_names:

1195

# Replace the class with a new subclass of it with

1196

# methods, signals, etc. as created above.

1197

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

1198

(cls,), attr)

1199

return cls

1200

return wrapper

1201

1202

1203

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

1204

"se.bsnet.fukt.Mandos"})

859

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

860

1205

861

class ClientDBus(Client, DBusObjectWithProperties):

1206

862

"""A Client class using D-Bus

1207

863

1216

872

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

1217

873

1218

874

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

875

self._approvals_pending = 0

1219

876

self.bus = bus

1220

877

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

1221

878

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

1227

884

("/clients/" + client_object_name))

1228

885

DBusObjectWithProperties.__init__(self, self.bus,

1229

886

self.dbus_object_path)

1230

887

1231

888

def notifychangeproperty(transform_func,

1232

889

dbus_name, type_func=lambda x: x,

1233

890

variant_level=1):

1234

891

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

1235

892

its changes to DBus.

1236

1237

transform_fun: Function that takes a value and a variant_level

1238

and transforms it to a D-Bus type.

893

894

transform_fun: Function that takes a value and transforms it

895

to a D-Bus type.

1239

896

dbus_name: D-Bus name of the variable

1240

897

type_func: Function that transform the value before sending it

1241

898

to the D-Bus. Default: no transform

1248

905

type_func(getattr(self, attrname, None))

1249

906

!= type_func(value)):

1250

907

dbus_value = transform_func(type_func(value),

1251

variant_level

1252

=variant_level)

908

variant_level)

1253

909

self.PropertyChanged(dbus.String(dbus_name),

1254

910

dbus_value)

1255

911

setattr(self, attrname, value)

1256

912

1257

913

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

1258

914

915

1259

916

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1260

917

approvals_pending = notifychangeproperty(dbus.Boolean,

1261

918

"ApprovalPending",

1268

925

checker is not None)

1269

926

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1270

927

"LastCheckedOK")

1271

last_checker_status = notifychangeproperty(dbus.Int16,

1272

"LastCheckerStatus")

1273

928

last_approval_request = notifychangeproperty(

1274

929

datetime_to_dbus, "LastApprovalRequest")

1275

930

approved_by_default = notifychangeproperty(dbus.Boolean,

1276

931

"ApprovedByDefault")

1277

approval_delay = notifychangeproperty(dbus.UInt64,

932

approval_delay = notifychangeproperty(dbus.UInt16,

1278

933

"ApprovalDelay",

1279

934

type_func =

1280

timedelta_to_milliseconds)

935

_timedelta_to_milliseconds)

1281

936

approval_duration = notifychangeproperty(

1282

dbus.UInt64, "ApprovalDuration",

1283

type_func = timedelta_to_milliseconds)

937

dbus.UInt16, "ApprovalDuration",

938

type_func = _timedelta_to_milliseconds)

1284

939

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

1285

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

940

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

1286

941

type_func =

1287

timedelta_to_milliseconds)

942

_timedelta_to_milliseconds)

1288

943

extended_timeout = notifychangeproperty(

1289

dbus.UInt64, "ExtendedTimeout",

1290

type_func = timedelta_to_milliseconds)

1291

interval = notifychangeproperty(dbus.UInt64,

944

dbus.UInt16, "ExtendedTimeout",

945

type_func = _timedelta_to_milliseconds)

946

interval = notifychangeproperty(dbus.UInt16,

1292

947

"Interval",

1293

948

type_func =

1294

timedelta_to_milliseconds)

949

_timedelta_to_milliseconds)

1295

950

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

1296

951

1297

952

del notifychangeproperty

1339

994

return r

1340

995

1341

996

def _reset_approved(self):

1342

self.approved = None

997

self._approved = None

1343

998

return False

1344

999

1345

1000

def approve(self, value=True):

1346

self.approved = value

1347

gobject.timeout_add(timedelta_to_milliseconds

1001

self.send_changedstate()

1002

self._approved = value

1003

gobject.timeout_add(_timedelta_to_milliseconds

1348

1004

(self.approval_duration),

1349

1005

self._reset_approved)

1350

self.send_changedstate()

1006

1351

1007

1352

1008

## D-Bus methods, signals & properties

1353

1009

_interface = "se.recompile.Mandos.Client"

1354

1010

1355

## Interfaces

1356

1357

@dbus_interface_annotations(_interface)

1358

def _foo(self):

1359

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

1360

"false"}

1361

1362

1011

## Signals

1363

1012

1364

1013

# CheckerCompleted - signal

1463

1112

access="readwrite")

1464

1113

def ApprovalDuration_dbus_property(self, value=None):

1465

1114

if value is None: # get

1466

return dbus.UInt64(timedelta_to_milliseconds(

1115

return dbus.UInt64(_timedelta_to_milliseconds(

1467

1116

self.approval_duration))

1468

1117

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

1469

1118

1483

1132

def Host_dbus_property(self, value=None):

1484

1133

if value is None: # get

1485

1134

return dbus.String(self.host)

1486

self.host = unicode(value)

1135

self.host = value

1487

1136

1488

1137

# Created - property

1489

1138

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

1490

1139

def Created_dbus_property(self):

1491

return datetime_to_dbus(self.created)

1140

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

1492

1141

1493

1142

# LastEnabled - property

1494

1143

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

1515

1164

return

1516

1165

return datetime_to_dbus(self.last_checked_ok)

1517

1166

1518

# LastCheckerStatus - property

1519

@dbus_service_property(_interface, signature="n",

1520

access="read")

1521

def LastCheckerStatus_dbus_property(self):

1522

return dbus.Int16(self.last_checker_status)

1523

1524

1167

# Expires - property

1525

1168

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

1526

1169

def Expires_dbus_property(self):

1537

1180

def Timeout_dbus_property(self, value=None):

1538

1181

if value is None: # get

1539

1182

return dbus.UInt64(self.timeout_milliseconds())

1540

old_timeout = self.timeout

1541

1183

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

1542

# Reschedule disabling

1543

if self.enabled:

1544

now = datetime.datetime.utcnow()

1545

self.expires += self.timeout - old_timeout

1546

if self.expires <= now:

1547

# The timeout has passed

1548

self.disable()

1549

else:

1550

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

1551

is None):

1552

return

1553

gobject.source_remove(self.disable_initiator_tag)

1554

self.disable_initiator_tag = (

1555

gobject.timeout_add(

1556

timedelta_to_milliseconds(self.expires - now),

1557

self.disable))

1184

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

1185

return

1186

# Reschedule timeout

1187

gobject.source_remove(self.disable_initiator_tag)

1188

self.disable_initiator_tag = None

1189

self.expires = None

1190

time_to_die = (self.

1191

_timedelta_to_milliseconds((self

1192

.last_checked_ok

1193

+ self.timeout)

1194

- datetime.datetime

1195

.utcnow()))

1196

if time_to_die <= 0:

1197

# The timeout has passed

1198

self.disable()

1199

else:

1200

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

1201

+ datetime.timedelta(milliseconds =

1202

time_to_die))

1203

self.disable_initiator_tag = (gobject.timeout_add

1204

(time_to_die, self.disable))

1558

1205

1559

1206

# ExtendedTimeout - property

1560

1207

@dbus_service_property(_interface, signature="t",

1573

1220

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

1574

1221

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

1575

1222

return

1576

if self.enabled:

1577

# Reschedule checker run

1578

gobject.source_remove(self.checker_initiator_tag)

1579

self.checker_initiator_tag = (gobject.timeout_add

1580

(value, self.start_checker))

1581

self.start_checker() # Start one now, too

1223

# Reschedule checker run

1224

gobject.source_remove(self.checker_initiator_tag)

1225

self.checker_initiator_tag = (gobject.timeout_add

1226

(value, self.start_checker))

1227

self.start_checker() # Start one now, too

1582

1228

1583

1229

# Checker - property

1584

1230

@dbus_service_property(_interface, signature="s",

1586

1232

def Checker_dbus_property(self, value=None):

1587

1233

if value is None: # get

1588

1234

return dbus.String(self.checker_command)

1589

self.checker_command = unicode(value)

1235

self.checker_command = value

1590

1236

1591

1237

# CheckerRunning - property

1592

1238

@dbus_service_property(_interface, signature="b",

1621

1267

raise KeyError()

1622

1268

1623

1269

def __getattribute__(self, name):

1624

if name == '_pipe':

1270

if(name == '_pipe'):

1625

1271

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

1626

1272

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

1627

1273

data = self._pipe.recv()

1634

1280

return func

1635

1281

1636

1282

def __setattr__(self, name, value):

1637

if name == '_pipe':

1283

if(name == '_pipe'):

1638

1284

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

1639

1285

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

1640

1286

1287

class ClientDBusTransitional(ClientDBus):

1288

__metaclass__ = AlternateDBusNamesMetaclass

1641

1289

1642

1290

class ClientHandler(socketserver.BaseRequestHandler, object):

1643

1291

"""A class to handle client connections.

1726

1374

client.Rejected("Disabled")

1727

1375

return

1728

1376

1729

if client.approved or not client.approval_delay:

1377

if client._approved or not client.approval_delay:

1730

1378

#We are approved or approval is disabled

1731

1379

break

1732

elif client.approved is None:

1380

elif client._approved is None:

1733

1381

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

1734

1382

client.name)

1735

1383

if self.server.use_dbus:

1748

1396

#wait until timeout or approved

1749

1397

time = datetime.datetime.now()

1750

1398

client.changedstate.acquire()

1751

client.changedstate.wait(

1752

float(timedelta_to_milliseconds(delay)

1753

/ 1000))

1399

(client.changedstate.wait

1400

(float(client._timedelta_to_milliseconds(delay)

1401

/ 1000)))

1754

1402

client.changedstate.release()

1755

1403

time2 = datetime.datetime.now()

1756

1404

if (time2 - time) >= delay:

1772

1420

try:

1773

1421

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

1774

1422

except gnutls.errors.GNUTLSError as error:

1775

logger.warning("gnutls send failed",

1776

exc_info=error)

1423

logger.warning("gnutls send failed")

1777

1424

return

1778

1425

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

1779

1426

sent, len(client.secret)

1782

1429

1783

1430

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

1784

1431

# bump the timeout using extended_timeout

1785

client.bump_timeout(client.extended_timeout)

1432

client.checked_ok(client.extended_timeout)

1786

1433

if self.server.use_dbus:

1787

1434

# Emit D-Bus signal

1788

1435

client.GotSecret()

1793

1440

try:

1794

1441

session.bye()

1795

1442

except gnutls.errors.GNUTLSError as error:

1796

logger.warning("GnuTLS bye failed",

1797

exc_info=error)

1443

logger.warning("GnuTLS bye failed")

1798

1444

1799

1445

@staticmethod

1800

1446

def peer_certificate(session):

1856

1502

# Convert the buffer to a Python bytestring

1857

1503

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

1858

1504

# Convert the bytestring to hexadecimal notation

1859

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

1505

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

1860

1506

return hex_fpr

1861

1507

1862

1508

1865

1511

def sub_process_main(self, request, address):

1866

1512

try:

1867

1513

self.finish_request(request, address)

1868

except Exception:

1514

except:

1869

1515

self.handle_error(request, address)

1870

1516

self.close_request(request)

1871

1517

1872

1518

def process_request(self, request, address):

1873

1519

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

1874

1520

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

1875

args = (request, address))

1521

args = (request,

1522

address))

1876

1523

proc.start()

1877

1524

return proc

1878

1525

1928

1575

str(self.interface

1929

1576

+ '\0'))

1930

1577

except socket.error as error:

1931

if error.errno == errno.EPERM:

1578

if error[0] == errno.EPERM:

1932

1579

logger.error("No permission to"

1933

1580

" bind to interface %s",

1934

1581

self.interface)

1935

elif error.errno == errno.ENOPROTOOPT:

1582

elif error[0] == errno.ENOPROTOOPT:

1936

1583

logger.error("SO_BINDTODEVICE not available;"

1937

1584

" cannot bind to interface %s",

1938

1585

self.interface)

1939

elif error.errno == errno.ENODEV:

1940

logger.error("Interface %s does not"

1941

" exist, cannot bind",

1942

self.interface)

1943

1586

else:

1944

1587

raise

1945

1588

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

1979

1622

self.enabled = False

1980

1623

self.clients = clients

1981

1624

if self.clients is None:

1982

self.clients = {}

1625

self.clients = set()

1983

1626

self.use_dbus = use_dbus

1984

1627

self.gnutls_priority = gnutls_priority

1985

1628

IPv6_TCPServer.__init__(self, server_address,

2004

1647

2005

1648

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

2006

1649

proc = None, client_object=None):

1650

condition_names = {

1651

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

1652

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

1653

# blocking).

1654

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

1655

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

1656

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

1657

# broken, usually for pipes and

1658

# sockets).

1659

}

1660

conditions_string = ' | '.join(name

1661

for cond, name in

1662

condition_names.iteritems()

1663

if cond & condition)

2007

1664

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

2008

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

1665

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

2009

1666

# Wait for other process to exit

2010

1667

proc.join()

2011

1668

return False

2018

1675

fpr = request[1]

2019

1676

address = request[2]

2020

1677

2021

for c in self.clients.itervalues():

1678

for c in self.clients:

2022

1679

if c.fingerprint == fpr:

2023

1680

client = c

2024

1681

break

2101

1758

elif suffix == "w":

2102

1759

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

2103

1760

else:

2104

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

2105

.format(suffix))

1761

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

2106

1762

except (ValueError, IndexError) as e:

2107

1763

raise ValueError(*(e.args))

2108

1764

timevalue += delta

2109

1765

return timevalue

2110

1766

2111

1767

1768

def if_nametoindex(interface):

1769

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

1770

1771

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

1772

global if_nametoindex

1773

try:

1774

if_nametoindex = (ctypes.cdll.LoadLibrary

1775

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

1776

.if_nametoindex)

1777

except (OSError, AttributeError):

1778

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

1779

def if_nametoindex(interface):

1780

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

1781

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

1782

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

1783

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1784

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

1785

interface))

1786

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

1787

ifreq[16:20])[0]

1788

return interface_index

1789

return if_nametoindex(interface)

1790

1791

2112

1792

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

2113

1793

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

2114

1794

2122

1802

sys.exit()

2123

1803

if not noclose:

2124

1804

# Close all standard open file descriptors

2125

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

1805

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

2126

1806

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

2127

1807

raise OSError(errno.ENODEV,

2128

"{0} not a character device"

2129

.format(os.devnull))

1808

"%s not a character device"

1809

% os.path.devnull)

2130

1810

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

2131

1811

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

2132

1812

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

2141

1821

2142

1822

parser = argparse.ArgumentParser()

2143

1823

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

2144

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

1824

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

2145

1825

help="show version number and exit")

2146

1826

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

2147

1827

help="Bind to interface IF")

2169

1849

" system bus interface")

2170

1850

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

2171

1851

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

2172

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

2173

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

2174

" state")

2175

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

2176

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

2177

2178

1852

options = parser.parse_args()

2179

1853

2180

1854

if options.check:

2193

1867

"use_dbus": "True",

2194

1868

"use_ipv6": "True",

2195

1869

"debuglevel": "",

2196

"restore": "True",

2197

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

2198

1870

}

2199

1871

2200

1872

# Parse config file for server-global settings

2217

1889

# options, if set.

2218

1890

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

2219

1891

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

2220

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

2221

"statedir"):

1892

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

2222

1893

value = getattr(options, option)

2223

1894

if value is not None:

2224

1895

server_settings[option] = value

2236

1907

debuglevel = server_settings["debuglevel"]

2237

1908

use_dbus = server_settings["use_dbus"]

2238

1909

use_ipv6 = server_settings["use_ipv6"]

2239

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

2240

stored_state_file)

2241

2242

if debug:

2243

initlogger(debug, logging.DEBUG)

2244

else:

2245

if not debuglevel:

2246

initlogger(debug)

2247

else:

2248

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

2249

initlogger(debug, level)

2250

1910

2251

1911

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

2252

1912

syslogger.setFormatter(logging.Formatter

2253

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

2254

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

2255

.format(server_settings

2256

["servicename"])))

1913

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

1914

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

1915

% server_settings["servicename"]))

2257

1916

2258

1917

# Parse config file with clients

2259

client_config = configparser.SafeConfigParser(Client

2260

.client_defaults)

1918

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

1919

"extended_timeout": "15m",

1920

"interval": "2m",

1921

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

1922

"host": "",

1923

"approval_delay": "0s",

1924

"approval_duration": "1s",

1925

}

1926

client_config = configparser.SafeConfigParser(client_defaults)

2261

1927

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

2262

1928

"clients.conf"))

2263

1929

2277

1943

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

2278

1944

try:

2279

1945

pidfile = open(pidfilename, "w")

2280

except IOError as e:

2281

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

2282

exc_info=e)

1946

except IOError:

1947

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

2283

1948

2284

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

1949

try:

1950

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

1951

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

1952

except KeyError:

2285

1953

try:

2286

uid = pwd.getpwnam(name).pw_uid

2287

gid = pwd.getpwnam(name).pw_gid

2288

break

1954

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

1955

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

2289

1956

except KeyError:

2290

continue

2291

else:

2292

uid = 65534

2293

gid = 65534

1957

try:

1958

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

1959

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

1960

except KeyError:

1961

uid = 65534

1962

gid = 65534

2294

1963

try:

2295

1964

os.setgid(gid)

2296

1965

os.setuid(uid)

2298

1967

if error[0] != errno.EPERM:

2299

1968

raise error

2300

1969

1970

if not debug and not debuglevel:

1971

syslogger.setLevel(logging.WARNING)

1972

console.setLevel(logging.WARNING)

1973

if debuglevel:

1974

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

1975

syslogger.setLevel(level)

1976

console.setLevel(level)

1977

2301

1978

if debug:

2302

1979

# Enable all possible GnuTLS debugging

2303

1980

2313

1990

.gnutls_global_set_log_function(debug_gnutls))

2314

1991

2315

1992

# Redirect stdin so all checkers get /dev/null

2316

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

1993

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

2317

1994

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

2318

1995

if null > 2:

2319

1996

os.close(null)

1997

else:

1998

# No console logging

1999

logger.removeHandler(console)

2320

2000

2321

2001

# Need to fork before connecting to D-Bus

2322

2002

if not debug:

2323

2003

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

2324

2004

daemon()

2325

2005

2326

gobject.threads_init()

2327

2328

2006

global main_loop

2329

2007

# From the Avahi example code

2330

DBusGMainLoop(set_as_default=True)

2008

DBusGMainLoop(set_as_default=True )

2331

2009

main_loop = gobject.MainLoop()

2332

2010

bus = dbus.SystemBus()

2333

2011

# End of Avahi example code

2339

2017

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

2340

2018

do_not_queue=True))

2341

2019

except dbus.exceptions.NameExistsException as e:

2342

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

2020

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

2343

2021

use_dbus = False

2344

2022

server_settings["use_dbus"] = False

2345

2023

tcp_server.use_dbus = False

2346

2024

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2347

service = AvahiServiceToSyslog(name =

2348

server_settings["servicename"],

2349

servicetype = "_mandos._tcp",

2350

protocol = protocol, bus = bus)

2025

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

2026

servicetype = "_mandos._tcp",

2027

protocol = protocol, bus = bus)

2351

2028

if server_settings["interface"]:

2352

2029

service.interface = (if_nametoindex

2353

2030

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

2357

2034

2358

2035

client_class = Client

2359

2036

if use_dbus:

2360

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

2361

2362

client_settings = Client.config_parser(client_config)

2363

old_client_settings = {}

2364

clients_data = {}

2365

2366

# Get client data and settings from last running state.

2367

if server_settings["restore"]:

2368

try:

2369

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

2370

clients_data, old_client_settings = (pickle.load

2371

(stored_state))

2372

os.remove(stored_state_path)

2373

except IOError as e:

2374

if e.errno == errno.ENOENT:

2375

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

2376

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

2377

else:

2378

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

2379

exc_info=e)

2380

raise

2381

except EOFError as e:

2382

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

2383

"EOFError:", exc_info=e)

2384

2385

with PGPEngine() as pgp:

2386

for client_name, client in clients_data.iteritems():

2387

# Decide which value to use after restoring saved state.

2388

# We have three different values: Old config file,

2389

# new config file, and saved state.

2390

# New config value takes precedence if it differs from old

2391

# config value, otherwise use saved state.

2392

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

2393

try:

2394

# For each value in new config, check if it

2395

# differs from the old config value (Except for

2396

# the "secret" attribute)

2397

if (name != "secret" and

2398

value != old_client_settings[client_name]

2399

[name]):

2400

client[name] = value

2401

except KeyError:

2402

pass

2403

2404

# Clients who has passed its expire date can still be

2405

# enabled if its last checker was successful. Clients

2406

# whose checker succeeded before we stored its state is

2407

# assumed to have successfully run all checkers during

2408

# downtime.

2409

if client["enabled"]:

2410

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

2411

if not client["last_checked_ok"]:

2412

logger.warning(

2413

"disabling client {0} - Client never "

2414

"performed a successful checker"

2415

.format(client_name))

2416

client["enabled"] = False

2417

elif client["last_checker_status"] != 0:

2418

logger.warning(

2419

"disabling client {0} - Client "

2420

"last checker failed with error code {1}"

2421

.format(client_name,

2422

client["last_checker_status"]))

2423

client["enabled"] = False

2424

else:

2425

client["expires"] = (datetime.datetime

2426

.utcnow()

2427

+ client["timeout"])

2428

logger.debug("Last checker succeeded,"

2429

" keeping {0} enabled"

2430

.format(client_name))

2037

client_class = functools.partial(ClientDBusTransitional,

2038

bus = bus)

2039

def client_config_items(config, section):

2040

special_settings = {

2041

"approved_by_default":

2042

lambda: config.getboolean(section,

2043

"approved_by_default"),

2044

}

2045

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

2431

2046

try:

2432

client["secret"] = (

2433

pgp.decrypt(client["encrypted_secret"],

2434

client_settings[client_name]

2435

["secret"]))

2436

except PGPError:

2437

# If decryption fails, we use secret from new settings

2438

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

2439

.format(client_name))

2440

client["secret"] = (

2441

client_settings[client_name]["secret"])

2442

2443

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

2444

for client_name in (set(old_client_settings)

2445

- set(client_settings)):

2446

del clients_data[client_name]

2447

for client_name in (set(client_settings)

2448

- set(old_client_settings)):

2449

clients_data[client_name] = client_settings[client_name]

2450

2451

# Create all client objects

2452

for client_name, client in clients_data.iteritems():

2453

tcp_server.clients[client_name] = client_class(

2454

name = client_name, settings = client)

2455

2047

yield (name, special_settings[name]())

2048

except KeyError:

2049

yield (name, value)

2050

2051

tcp_server.clients.update(set(

2052

client_class(name = section,

2053

config= dict(client_config_items(

2054

client_config, section)))

2055

for section in client_config.sections()))

2456

2056

if not tcp_server.clients:

2457

2057

logger.warning("No clients defined")

2458

2058

2459

2059

if not debug:

2460

2060

try:

2461

2061

with pidfile:

2469

2069

# "pidfile" was never created

2470

2070

pass

2471

2071

del pidfilename

2072

2472

2073

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

2473

2074

2474

2075

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

2475

2076

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

2476

2077

2477

2078

if use_dbus:

2478

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

2479

"se.bsnet.fukt.Mandos"})

2480

class MandosDBusService(DBusObjectWithProperties):

2079

class MandosDBusService(dbus.service.Object):

2481

2080

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

2482

2081

def __init__(self):

2483

2082

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

2484

2083

_interface = "se.recompile.Mandos"

2485

2084

2486

@dbus_interface_annotations(_interface)

2487

def _foo(self):

2488

return { "org.freedesktop.DBus.Property"

2489

".EmitsChangedSignal":

2490

"false"}

2491

2492

2085

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

2493

2086

def ClientAdded(self, objpath):

2494

2087

"D-Bus signal"

2508

2101

def GetAllClients(self):

2509

2102

"D-Bus method"

2510

2103

return dbus.Array(c.dbus_object_path

2511

for c in

2512

tcp_server.clients.itervalues())

2104

for c in tcp_server.clients)

2513

2105

2514

2106

@dbus.service.method(_interface,

2515

2107

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

2517

2109

"D-Bus method"

2518

2110

return dbus.Dictionary(

2519

2111

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

2520

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

2112

for c in tcp_server.clients),

2521

2113

signature="oa{sv}")

2522

2114

2523

2115

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

2524

2116

def RemoveClient(self, object_path):

2525

2117

"D-Bus method"

2526

for c in tcp_server.clients.itervalues():

2118

for c in tcp_server.clients:

2527

2119

if c.dbus_object_path == object_path:

2528

del tcp_server.clients[c.name]

2120

tcp_server.clients.remove(c)

2529

2121

c.remove_from_connection()

2530

2122

# Don't signal anything except ClientRemoved

2531

2123

c.disable(quiet=True)

2536

2128

2537

2129

del _interface

2538

2130

2539

mandos_dbus_service = MandosDBusService()

2131

class MandosDBusServiceTransitional(MandosDBusService):

2132

__metaclass__ = AlternateDBusNamesMetaclass

2133

mandos_dbus_service = MandosDBusServiceTransitional()

2540

2134

2541

2135

def cleanup():

2542

2136

"Cleanup function; run on exit"

2543

2137

service.cleanup()

2544

2138

2545

2139

multiprocessing.active_children()

2546

if not (tcp_server.clients or client_settings):

2547

return

2548

2549

# Store client before exiting. Secrets are encrypted with key

2550

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

2551

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

2552

clients = {}

2553

with PGPEngine() as pgp:

2554

for client in tcp_server.clients.itervalues():

2555

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

2556

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

2557

key)

2558

client_dict = {}

2559

2560

# A list of attributes that can not be pickled

2561

# + secret.

2562

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

2563

"checker"))

2564

for name, typ in (inspect.getmembers

2565

(dbus.service.Object)):

2566

exclude.add(name)

2567

2568

client_dict["encrypted_secret"] = (client

2569

.encrypted_secret)

2570

for attr in client.client_structure:

2571

if attr not in exclude:

2572

client_dict[attr] = getattr(client, attr)

2573

2574

clients[client.name] = client_dict

2575

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

2576

2577

try:

2578

with (tempfile.NamedTemporaryFile

2579

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

2580

dir=os.path.dirname(stored_state_path),

2581

delete=False)) as stored_state:

2582

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

2583

tempname=stored_state.name

2584

os.rename(tempname, stored_state_path)

2585

except (IOError, OSError) as e:

2586

if not debug:

2587

try:

2588

os.remove(tempname)

2589

except NameError:

2590

pass

2591

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

2592

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

2593

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

2594

else:

2595

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

2596

exc_info=e)

2597

raise e

2598

2599

# Delete all clients, and settings from config

2600

2140

while tcp_server.clients:

2601

name, client = tcp_server.clients.popitem()

2141

client = tcp_server.clients.pop()

2602

2142

if use_dbus:

2603

2143

client.remove_from_connection()

2144

client.disable_hook = None

2604

2145

# Don't signal anything except ClientRemoved

2605

2146

client.disable(quiet=True)

2606

2147

if use_dbus:

2608

2149

mandos_dbus_service.ClientRemoved(client

2609

2150

.dbus_object_path,

2610

2151

client.name)

2611

client_settings.clear()

2612

2152

2613

2153

atexit.register(cleanup)

2614

2154

2615

for client in tcp_server.clients.itervalues():

2155

for client in tcp_server.clients:

2616

2156

if use_dbus:

2617

2157

# Emit D-Bus signal

2618

2158

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2619

# Need to initiate checking of clients

2620

if client.enabled:

2621

client.init_checker()

2159

client.enable()

2622

2160

2623

2161

tcp_server.enable()

2624

2162

tcp_server.server_activate()

2627

2165

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

2628

2166

if use_ipv6:

2629

2167

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

2630

" flowinfo %d, scope_id %d",

2631

*tcp_server.socket.getsockname())

2168

" flowinfo %d, scope_id %d"

2169

% tcp_server.socket.getsockname())

2632

2170

else: # IPv4

2633

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

2634

*tcp_server.socket.getsockname())

2171

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

2172

% tcp_server.socket.getsockname())

2635

2173

2636

2174

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

2637

2175

2640

2178

try:

2641

2179

service.activate()

2642

2180

except dbus.exceptions.DBusException as error:

2643

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

2181

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

2644

2182

cleanup()

2645

2183

sys.exit(1)

2646

2184

# End of Avahi example code

2653

2191

logger.debug("Starting main loop")

2654

2192

main_loop.run()

2655

2193

except AvahiError as error:

2656

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

2194

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

2657

2195

cleanup()

2658

2196

sys.exit(1)

2659

2197

except KeyboardInterrupt:

2664

2202

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

2665

2203

cleanup()

2666

2204

2205

2667

2206

if __name__ == '__main__':

2668

2207

main()