/mandos/trunk : revision 505.3.10

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

import collections

72

66

73

67

import dbus

74

68

import dbus.service

79

73

import ctypes.util

80

74

import xml.dom.minidom

81

75

import inspect

82

import GnuPGInterface

83

76

84

77

try:

85

78

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

89

82

except ImportError:

90

83

SO_BINDTODEVICE = None

91

84

92

version = "1.6.0"

93

stored_state_file = "clients.pickle"

94

95

logger = logging.getLogger()

85

86

version = "1.4.1"

87

88

#logger = logging.getLogger('mandos')

89

logger = logging.Logger('mandos')

96

90

syslogger = (logging.handlers.SysLogHandler

97

91

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

98

92

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

99

100

try:

101

if_nametoindex = (ctypes.cdll.LoadLibrary

102

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

103

.if_nametoindex)

104

except (OSError, AttributeError):

105

def if_nametoindex(interface):

106

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

107

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

108

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

109

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

110

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

111

interface))

112

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

113

ifreq[16:20])[0]

114

return interface_index

115

116

117

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

118

"""init logger and add loglevel"""

119

120

syslogger.setFormatter(logging.Formatter

121

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

122

' %(message)s'))

123

logger.addHandler(syslogger)

124

125

if debug:

126

console = logging.StreamHandler()

127

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

128

' [%(process)d]:'

129

' %(levelname)s:'

130

' %(message)s'))

131

logger.addHandler(console)

132

logger.setLevel(level)

133

134

135

class PGPError(Exception):

136

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

137

pass

138

139

140

class PGPEngine(object):

141

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

142

def __init__(self):

143

self.gnupg = GnuPGInterface.GnuPG()

144

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

145

self.gnupg = GnuPGInterface.GnuPG()

146

self.gnupg.options.meta_interactive = False

147

self.gnupg.options.homedir = self.tempdir

148

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

149

'--quiet',

150

'--no-use-agent'])

151

152

def __enter__(self):

153

return self

154

155

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

156

self._cleanup()

157

return False

158

159

def __del__(self):

160

self._cleanup()

161

162

def _cleanup(self):

163

if self.tempdir is not None:

164

# Delete contents of tempdir

165

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

166

topdown = False):

167

for filename in files:

168

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

169

for dirname in dirs:

170

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

171

# Remove tempdir

172

os.rmdir(self.tempdir)

173

self.tempdir = None

174

175

def password_encode(self, password):

176

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

177

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

178

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

179

180

def encrypt(self, data, password):

181

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

182

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

183

try:

184

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

185

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

186

attach_fhs={'stderr': devnull})

187

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

188

f.write(data)

189

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

190

ciphertext = f.read()

191

proc.wait()

192

except IOError as e:

193

raise PGPError(e)

194

self.gnupg.passphrase = None

195

return ciphertext

196

197

def decrypt(self, data, password):

198

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

199

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

200

try:

201

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

202

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

203

attach_fhs={'stderr': devnull})

204

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

205

f.write(data)

206

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

207

decrypted_plaintext = f.read()

208

proc.wait()

209

except IOError as e:

210

raise PGPError(e)

211

self.gnupg.passphrase = None

212

return decrypted_plaintext

213

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)

214

103

215

104

class AvahiError(Exception):

216

105

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

246

135

server: D-Bus Server

247

136

bus: dbus.SystemBus()

248

137

"""

249

250

138

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

251

139

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

252

140

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

265

153

self.server = None

266

154

self.bus = bus

267

155

self.entry_group_state_changed_match = None

268

269

156

def rename(self):

270

157

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

271

158

if self.rename_count >= self.max_renames:

277

164

.GetAlternativeServiceName(self.name))

278

165

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

279

166

self.name)

167

syslogger.setFormatter(logging.Formatter

168

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

169

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

170

% self.name))

280

171

self.remove()

281

172

try:

282

173

self.add()

283

174

except dbus.exceptions.DBusException as error:

284

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

175

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

285

176

self.cleanup()

286

177

os._exit(1)

287

178

self.rename_count += 1

288

289

179

def remove(self):

290

180

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

291

181

if self.entry_group_state_changed_match is not None:

293

183

self.entry_group_state_changed_match = None

294

184

if self.group is not None:

295

185

self.group.Reset()

296

297

186

def add(self):

298

187

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

299

188

self.remove()

304

193

avahi.DBUS_INTERFACE_ENTRY_GROUP)

305

194

self.entry_group_state_changed_match = (

306

195

self.group.connect_to_signal(

307

'StateChanged', self.entry_group_state_changed))

196

'StateChanged', self .entry_group_state_changed))

308

197

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

309

198

self.name, self.type)

310

199

self.group.AddService(

316

205

dbus.UInt16(self.port),

317

206

avahi.string_array_to_txt_array(self.TXT))

318

207

self.group.Commit()

319

320

208

def entry_group_state_changed(self, state, error):

321

209

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

322

210

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

329

217

elif state == avahi.ENTRY_GROUP_FAILURE:

330

218

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

331

219

unicode(error))

332

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

333

.format(error))

334

220

raise AvahiGroupError("State changed: %s"

221

% unicode(error))

335

222

def cleanup(self):

336

223

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

337

224

if self.group is not None:

338

225

try:

339

226

self.group.Free()

340

227

except (dbus.exceptions.UnknownMethodException,

341

dbus.exceptions.DBusException):

228

dbus.exceptions.DBusException) as e:

342

229

pass

343

230

self.group = None

344

231

self.remove()

345

346

232

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

347

233

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

348

234

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

367

253

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

368

254

else:

369

255

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

370

371

256

def activate(self):

372

257

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

373

258

if self.server is None:

381

266

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

382

267

383

268

384

class AvahiServiceToSyslog(AvahiService):

385

def rename(self):

386

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

387

ret = AvahiService.rename(self)

388

syslogger.setFormatter(logging.Formatter

389

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

390

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

391

.format(self.name)))

392

return ret

393

394

395

def timedelta_to_milliseconds(td):

269

def _timedelta_to_milliseconds(td):

396

270

"Convert a datetime.timedelta() to milliseconds"

397

271

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

398

272

+ (td.seconds * 1000)

399

273

+ (td.microseconds // 1000))

400

401

274

402

275

class Client(object):

403

276

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

404

277

405

278

Attributes:

406

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

279

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

407

280

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

408

281

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

409

282

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

416

289

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

417

290

checker_initiator_tag: a gobject event source tag, or None

418

291

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

419

client_structure: Object describing what attributes a client has

420

and is used for storing the client at exit

421

292

current_checker_command: string; current running checker_command

293

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

422

294

disable_initiator_tag: a gobject event source tag, or None

423

295

enabled: bool()

424

296

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

427

299

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

428

300

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

429

301

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

430

last_checker_status: integer between 0 and 255 reflecting exit

431

status of last checker. -1 reflects crashed

432

checker, -2 means no checker completed yet.

433

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

302

last_enabled: datetime.datetime(); (UTC)

434

303

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

435

304

D-Bus identifiers

436

305

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

437

306

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

438

307

until this client is disabled

439

extended_timeout: extra long timeout when secret has been sent

308

extended_timeout: extra long timeout when password has been sent

440

309

runtime_expansions: Allowed attributes for runtime expansion.

441

310

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

442

311

disabled, or None

443

312

"""

444

313

445

314

runtime_expansions = ("approval_delay", "approval_duration",

446

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

447

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

448

"last_approval_request", "last_checked_ok",

315

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

316

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

449

317

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

450

client_defaults = { "timeout": "PT5M",

451

"extended_timeout": "PT15M",

452

"interval": "PT2M",

453

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

454

"host": "",

455

"approval_delay": "PT0S",

456

"approval_duration": "PT1S",

457

"approved_by_default": "True",

458

"enabled": "True",

459

}

460

318

461

319

def timeout_milliseconds(self):

462

320

"Return the 'timeout' attribute in milliseconds"

463

return timedelta_to_milliseconds(self.timeout)

321

return _timedelta_to_milliseconds(self.timeout)

464

322

465

323

def extended_timeout_milliseconds(self):

466

324

"Return the 'extended_timeout' attribute in milliseconds"

467

return timedelta_to_milliseconds(self.extended_timeout)

325

return _timedelta_to_milliseconds(self.extended_timeout)

468

326

469

327

def interval_milliseconds(self):

470

328

"Return the 'interval' attribute in milliseconds"

471

return timedelta_to_milliseconds(self.interval)

329

return _timedelta_to_milliseconds(self.interval)

472

330

473

331

def approval_delay_milliseconds(self):

474

return timedelta_to_milliseconds(self.approval_delay)

475

476

@staticmethod

477

def config_parser(config):

478

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

479

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

480

with exceptions for any special settings as defined above.

481

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

482

value given the same arguments.

483

"""

484

settings = {}

485

for client_name in config.sections():

486

section = dict(config.items(client_name))

487

client = settings[client_name] = {}

488

489

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

490

# Reformat values from string types to Python types

491

client["approved_by_default"] = config.getboolean(

492

client_name, "approved_by_default")

493

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

494

"enabled")

495

496

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

497

.replace(" ", ""))

498

if "secret" in section:

499

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

500

elif "secfile" in section:

501

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

502

(section["secfile"])),

503

"rb") as secfile:

504

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

505

else:

506

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

507

.format(section))

508

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

509

client["extended_timeout"] = string_to_delta(

510

section["extended_timeout"])

511

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

512

client["approval_delay"] = string_to_delta(

513

section["approval_delay"])

514

client["approval_duration"] = string_to_delta(

515

section["approval_duration"])

516

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

517

client["last_approval_request"] = None

518

client["last_checked_ok"] = None

519

client["last_checker_status"] = -2

520

521

return settings

522

523

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

524

338

self.name = name

525

# adding all client settings

526

for setting, value in settings.iteritems():

527

setattr(self, setting, value)

528

529

if self.enabled:

530

if not hasattr(self, "last_enabled"):

531

self.last_enabled = datetime.datetime.utcnow()

532

if not hasattr(self, "expires"):

533

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

534

+ self.timeout)

535

else:

536

self.last_enabled = None

537

self.expires = None

538

339

if config is None:

340

config = {}

539

341

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

540

342

# Uppercase and remove spaces from fingerprint for later

541

343

# comparison purposes with return value from the fingerprint()

542

344

# function

345

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

346

.replace(" ", ""))

543

347

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

544

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

545

datetime.datetime.utcnow())

546

547

# 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

548

369

self.checker = None

549

370

self.checker_initiator_tag = None

550

371

self.disable_initiator_tag = None

372

self.expires = None

551

373

self.checker_callback_tag = None

374

self.checker_command = config["checker"]

552

375

self.current_checker_command = None

553

self.approved = None

376

self.last_connect = None

377

self._approved = None

378

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

379

True)

554

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

555

385

self.changedstate = (multiprocessing_manager

556

386

.Condition(multiprocessing_manager

557

387

.Lock()))

558

self.client_structure = [attr for attr in

559

self.__dict__.iterkeys()

560

if not attr.startswith("_")]

561

self.client_structure.append("client_structure")

562

563

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

564

lambda obj:

565

isinstance(obj,

566

property)):

567

if not name.startswith("_"):

568

self.client_structure.append(name)

569

388

570

# Send notice to process children that client state has changed

571

389

def send_changedstate(self):

572

with self.changedstate:

573

self.changedstate.notify_all()

390

self.changedstate.acquire()

391

self.changedstate.notify_all()

392

self.changedstate.release()

574

393

575

394

def enable(self):

576

395

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

577

396

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

578

397

# Already enabled

579

398

return

580

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

581

self.enabled = True

582

self.last_enabled = datetime.datetime.utcnow()

583

self.init_checker()

584

399

self.send_changedstate()

585

586

def disable(self, quiet=True):

587

"""Disable this client."""

588

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

589

return False

590

if not quiet:

591

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

592

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

593

gobject.source_remove(self.disable_initiator_tag)

594

self.disable_initiator_tag = None

595

self.expires = None

596

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

597

gobject.source_remove(self.checker_initiator_tag)

598

self.checker_initiator_tag = None

599

self.stop_checker()

600

self.enabled = False

601

if not quiet:

602

self.send_changedstate()

603

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

604

return False

605

606

def __del__(self):

607

self.disable()

608

609

def init_checker(self):

610

400

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

611

401

# and every interval from then on.

612

if self.checker_initiator_tag is not None:

613

gobject.source_remove(self.checker_initiator_tag)

614

402

self.checker_initiator_tag = (gobject.timeout_add

615

403

(self.interval_milliseconds(),

616

404

self.start_checker))

617

405

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

618

if self.disable_initiator_tag is not None:

619

gobject.source_remove(self.disable_initiator_tag)

406

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

620

407

self.disable_initiator_tag = (gobject.timeout_add

621

408

(self.timeout_milliseconds(),

622

409

self.disable))

410

self.enabled = True

411

self.last_enabled = datetime.datetime.utcnow()

623

412

# Also start a new checker *right now*.

624

413

self.start_checker()

625

414

415

def disable(self, quiet=True):

416

"""Disable this client."""

417

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

418

return False

419

if not quiet:

420

self.send_changedstate()

421

if not quiet:

422

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

423

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

424

gobject.source_remove(self.disable_initiator_tag)

425

self.disable_initiator_tag = None

426

self.expires = None

427

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

428

gobject.source_remove(self.checker_initiator_tag)

429

self.checker_initiator_tag = None

430

self.stop_checker()

431

if self.disable_hook:

432

self.disable_hook(self)

433

self.enabled = False

434

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

435

return False

436

437

def __del__(self):

438

self.disable_hook = None

439

self.disable()

440

626

441

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

627

442

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

628

443

self.checker_callback_tag = None

629

444

self.checker = None

630

445

if os.WIFEXITED(condition):

631

self.last_checker_status = os.WEXITSTATUS(condition)

632

if self.last_checker_status == 0:

446

exitstatus = os.WEXITSTATUS(condition)

447

if exitstatus == 0:

633

448

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

634

449

vars(self))

635

450

self.checked_ok()

637

452

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

638

453

vars(self))

639

454

else:

640

self.last_checker_status = -1

641

455

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

642

456

vars(self))

643

457

644

def checked_ok(self):

645

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

646

self.last_checked_ok = datetime.datetime.utcnow()

647

self.last_checker_status = 0

648

self.bump_timeout()

649

650

def bump_timeout(self, timeout=None):

651

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

"""

652

464

if timeout is None:

653

465

timeout = self.timeout

466

self.last_checked_ok = datetime.datetime.utcnow()

654

467

if self.disable_initiator_tag is not None:

655

468

gobject.source_remove(self.disable_initiator_tag)

656

self.disable_initiator_tag = None

657

469

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

658

470

self.disable_initiator_tag = (gobject.timeout_add

659

(timedelta_to_milliseconds

471

(_timedelta_to_milliseconds

660

472

(timeout), self.disable))

661

473

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

662

474

669

481

If a checker already exists, leave it running and do

670

482

nothing."""

671

483

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

672

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

673

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

674

# would inevitably timeout, since no checker would get a

675

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

484

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

485

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

486

# client would inevitably timeout, since no checker would get

487

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

676

488

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

677

489

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

678

490

# should be.

692

504

self.current_checker_command)

693

505

# Start a new checker if needed

694

506

if self.checker is None:

695

# Escape attributes for the shell

696

escaped_attrs = dict(

697

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

698

for attr in

699

self.runtime_expansions)

700

507

try:

701

command = self.checker_command % escaped_attrs

702

except TypeError as error:

703

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

704

self.checker_command, exc_info=error)

705

return True # Try again later

508

# In case checker_command has exactly one % operator

509

command = self.checker_command % self.host

510

except TypeError:

511

# Escape attributes for the shell

512

escaped_attrs = dict(

513

(attr,

514

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

515

errors=

516

'replace')))

517

for attr in

518

self.runtime_expansions)

519

520

try:

521

command = self.checker_command % escaped_attrs

522

except TypeError as error:

523

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

524

' %s', self.checker_command, error)

525

return True # Try again later

706

526

self.current_checker_command = command

707

527

try:

708

528

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

714

534

self.checker = subprocess.Popen(command,

715

535

close_fds=True,

716

536

shell=True, cwd="/")

537

self.checker_callback_tag = (gobject.child_watch_add

538

(self.checker.pid,

539

self.checker_callback,

540

data=command))

541

# The checker may have completed before the gobject

542

# watch was added. Check for this.

543

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

544

if pid:

545

gobject.source_remove(self.checker_callback_tag)

546

self.checker_callback(pid, status, command)

717

547

except OSError as error:

718

logger.error("Failed to start subprocess",

719

exc_info=error)

720

self.checker_callback_tag = (gobject.child_watch_add

721

(self.checker.pid,

722

self.checker_callback,

723

data=command))

724

# The checker may have completed before the gobject

725

# watch was added. Check for this.

726

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

727

if pid:

728

gobject.source_remove(self.checker_callback_tag)

729

self.checker_callback(pid, status, command)

548

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

549

error)

730

550

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

731

551

return True

732

552

739

559

return

740

560

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

741

561

try:

742

self.checker.terminate()

562

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

743

563

#time.sleep(0.5)

744

564

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

745

# self.checker.kill()

565

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

746

566

except OSError as error:

747

567

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

748

568

raise

765

585

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

766

586

if byte_arrays and signature != "ay":

767

587

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

768

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

588

" signature %r" % signature)

769

589

def decorator(func):

770

590

func._dbus_is_property = True

771

591

func._dbus_interface = dbus_interface

779

599

return decorator

780

600

781

601

782

def dbus_interface_annotations(dbus_interface):

783

"""Decorator for marking functions returning interface annotations

784

785

Usage:

786

787

@dbus_interface_annotations("org.example.Interface")

788

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

789

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

790

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

791

"false"}

792

"""

793

def decorator(func):

794

func._dbus_is_interface = True

795

func._dbus_interface = dbus_interface

796

func._dbus_name = dbus_interface

797

return func

798

return decorator

799

800

801

def dbus_annotations(annotations):

802

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

803

Usage:

804

805

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

806

access="r")

807

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

808

"org.freedesktop.DBus.Property."

809

"EmitsChangedSignal": "false"})

810

def Property_dbus_property(self):

811

return dbus.Boolean(False)

812

"""

813

def decorator(func):

814

func._dbus_annotations = annotations

815

return func

816

return decorator

817

818

819

602

class DBusPropertyException(dbus.exceptions.DBusException):

820

603

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

821

604

"""

844

627

"""

845

628

846

629

@staticmethod

847

def _is_dbus_thing(thing):

848

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

849

850

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

851

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

852

"""

853

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

854

False)

630

def _is_dbus_property(obj):

631

return getattr(obj, "_dbus_is_property", False)

855

632

856

def _get_all_dbus_things(self, thing):

633

def _get_all_dbus_properties(self):

857

634

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

858

635

"""

859

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

860

name),

861

athing.__get__(self))

636

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

862

637

for cls in self.__class__.__mro__

863

for name, athing in

864

inspect.getmembers(cls,

865

self._is_dbus_thing(thing)))

638

for name, prop in

639

inspect.getmembers(cls, self._is_dbus_property))

866

640

867

641

def _get_dbus_property(self, interface_name, property_name):

868

642

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

870

644

"""

871

645

for cls in self.__class__.__mro__:

872

646

for name, value in (inspect.getmembers

873

(cls,

874

self._is_dbus_thing("property"))):

647

(cls, self._is_dbus_property)):

875

648

if (value._dbus_name == property_name

876

649

and value._dbus_interface == interface_name):

877

650

return value.__get__(self)

906

679

# signatures other than "ay".

907

680

if prop._dbus_signature != "ay":

908

681

raise ValueError

909

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

910

for byte in value))

682

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

683

for byte in value))

911

684

prop(value)

912

685

913

686

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

918

691

919

692

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

920

693

"""

921

properties = {}

922

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

694

all = {}

695

for name, prop in self._get_all_dbus_properties():

923

696

if (interface_name

924

697

and interface_name != prop._dbus_interface):

925

698

# Interface non-empty but did not match

929

702

continue

930

703

value = prop()

931

704

if not hasattr(value, "variant_level"):

932

properties[name] = value

705

all[name] = value

933

706

continue

934

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

935

value.variant_level+1)

936

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

707

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

708

value.variant_level+1)

709

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

937

710

938

711

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

939

712

out_signature="s",

940

713

path_keyword='object_path',

941

714

connection_keyword='connection')

942

715

def Introspect(self, object_path, connection):

943

"""Overloading of standard D-Bus method.

944

945

Inserts property tags and interface annotation tags.

716

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

946

717

"""

947

718

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

948

719

connection)

955

726

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

956

727

return e

957

728

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

958

# Add property tags

959

729

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

960

730

for name, prop

961

in self._get_all_dbus_things("property")

731

in self._get_all_dbus_properties()

962

732

if prop._dbus_interface

963

733

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

964

734

if_tag.appendChild(tag)

965

# Add annotation tags

966

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

967

for tag in if_tag.getElementsByTagName(typ):

968

annots = dict()

969

for name, prop in (self.

970

_get_all_dbus_things(typ)):

971

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

972

and prop._dbus_interface

973

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

974

annots.update(getattr

975

(prop,

976

"_dbus_annotations",

977

{}))

978

for name, value in annots.iteritems():

979

ann_tag = document.createElement(

980

"annotation")

981

ann_tag.setAttribute("name", name)

982

ann_tag.setAttribute("value", value)

983

tag.appendChild(ann_tag)

984

# Add interface annotation tags

985

for annotation, value in dict(

986

itertools.chain.from_iterable(

987

annotations().iteritems()

988

for name, annotations in

989

self._get_all_dbus_things("interface")

990

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

991

)).iteritems():

992

ann_tag = document.createElement("annotation")

993

ann_tag.setAttribute("name", annotation)

994

ann_tag.setAttribute("value", value)

995

if_tag.appendChild(ann_tag)

996

735

# Add the names to the return values for the

997

736

# "org.freedesktop.DBus.Properties" methods

998

737

if (if_tag.getAttribute("name")

1013

752

except (AttributeError, xml.dom.DOMException,

1014

753

xml.parsers.expat.ExpatError) as error:

1015

754

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

1016

exc_info=error)

755

error)

1017

756

return xmlstring

1018

757

1019

758

1020

def datetime_to_dbus(dt, variant_level=0):

759

def datetime_to_dbus (dt, variant_level=0):

1021

760

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

1022

761

if dt is None:

1023

762

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

1024

763

return dbus.String(dt.isoformat(),

1025

764

variant_level=variant_level)

1026

765

1027

1028

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1029

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

1030

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

1031

interface names according to the "alt_interface_names" mapping.

1032

Usage:

1033

1034

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

1035

"net.example.AlternateInterface"})

1036

class SampleDBusObject(dbus.service.Object):

1037

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

1038

def SampleDBusMethod():

1039

pass

1040

1041

The above "SampleDBusMethod" on "SampleDBusObject" will be

1042

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

1043

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

1044

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

1045

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

1046

1047

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

1048

(from DBusObjectWithProperties) and interfaces (from the

1049

dbus_interface_annotations decorator).

766

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

767

.__metaclass__):

768

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

769

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

1050

770

"""

1051

def wrapper(cls):

1052

for orig_interface_name, alt_interface_name in (

1053

alt_interface_names.iteritems()):

1054

attr = {}

1055

interface_names = set()

1056

# Go though all attributes of the class

1057

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

771

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

772

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

773

# methods, signals, or properties in them

774

for base in (b for b in bases

775

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

776

# Go though all attributes of the base class

777

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

1058

778

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

1059

779

# with the wrong interface name

1060

780

if (not hasattr(attribute, "_dbus_interface")

1061

781

or not attribute._dbus_interface

1062

.startswith(orig_interface_name)):

782

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

1063

783

continue

1064

784

# Create an alternate D-Bus interface name based on

1065

785

# the current name

1066

786

alt_interface = (attribute._dbus_interface

1067

.replace(orig_interface_name,

1068

alt_interface_name))

1069

interface_names.add(alt_interface)

787

.replace("se.recompile.Mandos",

788

"se.bsnet.fukt.Mandos"))

1070

789

# Is this a D-Bus signal?

1071

790

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

1072

791

# Extract the original non-method function by

1087

806

nonmethod_func.func_name,

1088

807

nonmethod_func.func_defaults,

1089

808

nonmethod_func.func_closure)))

1090

# Copy annotations, if any

1091

try:

1092

new_function._dbus_annotations = (

1093

dict(attribute._dbus_annotations))

1094

except AttributeError:

1095

pass

1096

809

# Define a creator of a function to call both the

1097

# original and alternate functions, so both the

1098

# original and alternate signals gets sent when

1099

# the function is called

810

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

811

# signals gets sent when the function is called

1100

812

def fixscope(func1, func2):

1101

813

"""This function is a scope container to pass

1102

814

func1 and func2 to the "call_both" function

1109

821

return call_both

1110

822

# Create the "call_both" function and add it to

1111

823

# the class

1112

attr[attrname] = fixscope(attribute, new_function)

824

attr[attrname] = fixscope(attribute,

825

new_function)

1113

826

# Is this a D-Bus method?

1114

827

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

1115

828

# Create a new, but exactly alike, function

1126

839

attribute.func_name,

1127

840

attribute.func_defaults,

1128

841

attribute.func_closure)))

1129

# Copy annotations, if any

1130

try:

1131

attr[attrname]._dbus_annotations = (

1132

dict(attribute._dbus_annotations))

1133

except AttributeError:

1134

pass

1135

842

# Is this a D-Bus property?

1136

843

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

1137

844

# Create a new, but exactly alike, function

1151

858

attribute.func_name,

1152

859

attribute.func_defaults,

1153

860

attribute.func_closure)))

1154

# Copy annotations, if any

1155

try:

1156

attr[attrname]._dbus_annotations = (

1157

dict(attribute._dbus_annotations))

1158

except AttributeError:

1159

pass

1160

# Is this a D-Bus interface?

1161

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

1162

# Create a new, but exactly alike, function

1163

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

1164

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

1165

# to the class.

1166

attr[attrname] = (dbus_interface_annotations

1167

(alt_interface)

1168

(types.FunctionType

1169

(attribute.func_code,

1170

attribute.func_globals,

1171

attribute.func_name,

1172

attribute.func_defaults,

1173

attribute.func_closure)))

1174

if deprecate:

1175

# Deprecate all alternate interfaces

1176

iname="_AlternateDBusNames_interface_annotation{0}"

1177

for interface_name in interface_names:

1178

@dbus_interface_annotations(interface_name)

1179

def func(self):

1180

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

1181

"true" }

1182

# Find an unused name

1183

for aname in (iname.format(i)

1184

for i in itertools.count()):

1185

if aname not in attr:

1186

attr[aname] = func

1187

break

1188

if interface_names:

1189

# Replace the class with a new subclass of it with

1190

# methods, signals, etc. as created above.

1191

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

1192

(cls,), attr)

1193

return cls

1194

return wrapper

1195

1196

1197

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

1198

"se.bsnet.fukt.Mandos"})

861

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

862

1199

863

class ClientDBus(Client, DBusObjectWithProperties):

1200

864

"""A Client class using D-Bus

1201

865

1210

874

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

1211

875

1212

876

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

877

self._approvals_pending = 0

1213

878

self.bus = bus

1214

879

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

1215

880

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

1221

886

("/clients/" + client_object_name))

1222

887

DBusObjectWithProperties.__init__(self, self.bus,

1223

888

self.dbus_object_path)

1224

889

1225

890

def notifychangeproperty(transform_func,

1226

891

dbus_name, type_func=lambda x: x,

1227

892

variant_level=1):

1228

893

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

1229

894

its changes to DBus.

1230

895

1231

896

transform_fun: Function that takes a value and a variant_level

1232

897

and transforms it to a D-Bus type.

1233

898

dbus_name: D-Bus name of the variable

1250

915

1251

916

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

1252

917

918

1253

919

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1254

920

approvals_pending = notifychangeproperty(dbus.Boolean,

1255

921

"ApprovalPending",

1262

928

checker is not None)

1263

929

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1264

930

"LastCheckedOK")

1265

last_checker_status = notifychangeproperty(dbus.Int16,

1266

"LastCheckerStatus")

1267

931

last_approval_request = notifychangeproperty(

1268

932

datetime_to_dbus, "LastApprovalRequest")

1269

933

approved_by_default = notifychangeproperty(dbus.Boolean,

1270

934

"ApprovedByDefault")

1271

approval_delay = notifychangeproperty(dbus.UInt64,

935

approval_delay = notifychangeproperty(dbus.UInt16,

1272

936

"ApprovalDelay",

1273

937

type_func =

1274

timedelta_to_milliseconds)

938

_timedelta_to_milliseconds)

1275

939

approval_duration = notifychangeproperty(

1276

dbus.UInt64, "ApprovalDuration",

1277

type_func = timedelta_to_milliseconds)

940

dbus.UInt16, "ApprovalDuration",

941

type_func = _timedelta_to_milliseconds)

1278

942

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

1279

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

943

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

1280

944

type_func =

1281

timedelta_to_milliseconds)

945

_timedelta_to_milliseconds)

1282

946

extended_timeout = notifychangeproperty(

1283

dbus.UInt64, "ExtendedTimeout",

1284

type_func = timedelta_to_milliseconds)

1285

interval = notifychangeproperty(dbus.UInt64,

947

dbus.UInt16, "ExtendedTimeout",

948

type_func = _timedelta_to_milliseconds)

949

interval = notifychangeproperty(dbus.UInt16,

1286

950

"Interval",

1287

951

type_func =

1288

timedelta_to_milliseconds)

952

_timedelta_to_milliseconds)

1289

953

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

1290

954

1291

955

del notifychangeproperty

1333

997

return r

1334

998

1335

999

def _reset_approved(self):

1336

self.approved = None

1000

self._approved = None

1337

1001

return False

1338

1002

1339

1003

def approve(self, value=True):

1340

self.approved = value

1341

gobject.timeout_add(timedelta_to_milliseconds

1004

self.send_changedstate()

1005

self._approved = value

1006

gobject.timeout_add(_timedelta_to_milliseconds

1342

1007

(self.approval_duration),

1343

1008

self._reset_approved)

1344

self.send_changedstate()

1009

1345

1010

1346

1011

## D-Bus methods, signals & properties

1347

1012

_interface = "se.recompile.Mandos.Client"

1348

1013

1349

## Interfaces

1350

1351

@dbus_interface_annotations(_interface)

1352

def _foo(self):

1353

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

1354

"false"}

1355

1356

1014

## Signals

1357

1015

1358

1016

# CheckerCompleted - signal

1457

1115

access="readwrite")

1458

1116

def ApprovalDuration_dbus_property(self, value=None):

1459

1117

if value is None: # get

1460

return dbus.UInt64(timedelta_to_milliseconds(

1118

return dbus.UInt64(_timedelta_to_milliseconds(

1461

1119

self.approval_duration))

1462

1120

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

1463

1121

1477

1135

def Host_dbus_property(self, value=None):

1478

1136

if value is None: # get

1479

1137

return dbus.String(self.host)

1480

self.host = unicode(value)

1138

self.host = value

1481

1139

1482

1140

# Created - property

1483

1141

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

1484

1142

def Created_dbus_property(self):

1485

return datetime_to_dbus(self.created)

1143

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

1486

1144

1487

1145

# LastEnabled - property

1488

1146

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

1509

1167

return

1510

1168

return datetime_to_dbus(self.last_checked_ok)

1511

1169

1512

# LastCheckerStatus - property

1513

@dbus_service_property(_interface, signature="n",

1514

access="read")

1515

def LastCheckerStatus_dbus_property(self):

1516

return dbus.Int16(self.last_checker_status)

1517

1518

1170

# Expires - property

1519

1171

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

1520

1172

def Expires_dbus_property(self):

1531

1183

def Timeout_dbus_property(self, value=None):

1532

1184

if value is None: # get

1533

1185

return dbus.UInt64(self.timeout_milliseconds())

1534

old_timeout = self.timeout

1535

1186

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

1536

# Reschedule disabling

1537

if self.enabled:

1538

now = datetime.datetime.utcnow()

1539

self.expires += self.timeout - old_timeout

1540

if self.expires <= now:

1541

# The timeout has passed

1542

self.disable()

1543

else:

1544

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

1545

is None):

1546

return

1547

gobject.source_remove(self.disable_initiator_tag)

1548

self.disable_initiator_tag = (

1549

gobject.timeout_add(

1550

timedelta_to_milliseconds(self.expires - now),

1551

self.disable))

1187

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

1188

return

1189

# Reschedule timeout

1190

gobject.source_remove(self.disable_initiator_tag)

1191

self.disable_initiator_tag = None

1192

self.expires = None

1193

time_to_die = _timedelta_to_milliseconds((self

1194

.last_checked_ok

1195

+ self.timeout)

1196

- datetime.datetime

1197

.utcnow())

1198

if time_to_die <= 0:

1199

# The timeout has passed

1200

self.disable()

1201

else:

1202

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

1203

+ datetime.timedelta(milliseconds =

1204

time_to_die))

1205

self.disable_initiator_tag = (gobject.timeout_add

1206

(time_to_die, self.disable))

1552

1207

1553

1208

# ExtendedTimeout - property

1554

1209

@dbus_service_property(_interface, signature="t",

1567

1222

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

1568

1223

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

1569

1224

return

1570

if self.enabled:

1571

# Reschedule checker run

1572

gobject.source_remove(self.checker_initiator_tag)

1573

self.checker_initiator_tag = (gobject.timeout_add

1574

(value, self.start_checker))

1575

self.start_checker() # Start one now, too

1225

# Reschedule checker run

1226

gobject.source_remove(self.checker_initiator_tag)

1227

self.checker_initiator_tag = (gobject.timeout_add

1228

(value, self.start_checker))

1229

self.start_checker() # Start one now, too

1576

1230

1577

1231

# Checker - property

1578

1232

@dbus_service_property(_interface, signature="s",

1580

1234

def Checker_dbus_property(self, value=None):

1581

1235

if value is None: # get

1582

1236

return dbus.String(self.checker_command)

1583

self.checker_command = unicode(value)

1237

self.checker_command = value

1584

1238

1585

1239

# CheckerRunning - property

1586

1240

@dbus_service_property(_interface, signature="b",

1615

1269

raise KeyError()

1616

1270

1617

1271

def __getattribute__(self, name):

1618

if name == '_pipe':

1272

if(name == '_pipe'):

1619

1273

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

1620

1274

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

1621

1275

data = self._pipe.recv()

1628

1282

return func

1629

1283

1630

1284

def __setattr__(self, name, value):

1631

if name == '_pipe':

1285

if(name == '_pipe'):

1632

1286

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

1633

1287

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

1634

1288

1289

class ClientDBusTransitional(ClientDBus):

1290

__metaclass__ = AlternateDBusNamesMetaclass

1635

1291

1636

1292

class ClientHandler(socketserver.BaseRequestHandler, object):

1637

1293

"""A class to handle client connections.

1720

1376

client.Rejected("Disabled")

1721

1377

return

1722

1378

1723

if client.approved or not client.approval_delay:

1379

if client._approved or not client.approval_delay:

1724

1380

#We are approved or approval is disabled

1725

1381

break

1726

elif client.approved is None:

1382

elif client._approved is None:

1727

1383

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

1728

1384

client.name)

1729

1385

if self.server.use_dbus:

1742

1398

#wait until timeout or approved

1743

1399

time = datetime.datetime.now()

1744

1400

client.changedstate.acquire()

1745

client.changedstate.wait(

1746

float(timedelta_to_milliseconds(delay)

1747

/ 1000))

1401

(client.changedstate.wait

1402

(float(client._timedelta_to_milliseconds(delay)

1403

/ 1000)))

1748

1404

client.changedstate.release()

1749

1405

time2 = datetime.datetime.now()

1750

1406

if (time2 - time) >= delay:

1766

1422

try:

1767

1423

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

1768

1424

except gnutls.errors.GNUTLSError as error:

1769

logger.warning("gnutls send failed",

1770

exc_info=error)

1425

logger.warning("gnutls send failed")

1771

1426

return

1772

1427

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

1773

1428

sent, len(client.secret)

1776

1431

1777

1432

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

1778

1433

# bump the timeout using extended_timeout

1779

client.bump_timeout(client.extended_timeout)

1434

client.checked_ok(client.extended_timeout)

1780

1435

if self.server.use_dbus:

1781

1436

# Emit D-Bus signal

1782

1437

client.GotSecret()

1787

1442

try:

1788

1443

session.bye()

1789

1444

except gnutls.errors.GNUTLSError as error:

1790

logger.warning("GnuTLS bye failed",

1791

exc_info=error)

1445

logger.warning("GnuTLS bye failed")

1792

1446

1793

1447

@staticmethod

1794

1448

def peer_certificate(session):

1850

1504

# Convert the buffer to a Python bytestring

1851

1505

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

1852

1506

# Convert the bytestring to hexadecimal notation

1853

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

1507

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

1854

1508

return hex_fpr

1855

1509

1856

1510

1859

1513

def sub_process_main(self, request, address):

1860

1514

try:

1861

1515

self.finish_request(request, address)

1862

except Exception:

1516

except:

1863

1517

self.handle_error(request, address)

1864

1518

self.close_request(request)

1865

1519

1866

1520

def process_request(self, request, address):

1867

1521

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

1868

1522

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

1869

args = (request, address))

1523

args = (request,

1524

address))

1870

1525

proc.start()

1871

1526

return proc

1872

1527

1900

1555

use_ipv6: Boolean; to use IPv6 or not

1901

1556

"""

1902

1557

def __init__(self, server_address, RequestHandlerClass,

1903

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

1904

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

1905

creating a new one with socket.socket().

1906

"""

1558

interface=None, use_ipv6=True):

1907

1559

self.interface = interface

1908

1560

if use_ipv6:

1909

1561

self.address_family = socket.AF_INET6

1910

if socketfd is not None:

1911

# Save the file descriptor

1912

self.socketfd = socketfd

1913

# Save the original socket.socket() function

1914

self.socket_socket = socket.socket

1915

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

1916

#

1917

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

1918

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

1919

# patching socket.socket.)

1920

#

1921

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

1922

@functools.wraps(socket.socket)

1923

def socket_wrapper(*args, **kwargs):

1924

# Restore original function so subsequent calls are

1925

# not affected.

1926

socket.socket = self.socket_socket

1927

del self.socket_socket

1928

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

1929

# saved file descriptor.

1930

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

1931

# Replace socket.socket() function with wrapper

1932

socket.socket = socket_wrapper

1933

# The socketserver.TCPServer.__init__ will call

1934

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

1935

# socket_wrapper(), if socketfd was set.

1936

1562

socketserver.TCPServer.__init__(self, server_address,

1937

1563

RequestHandlerClass)

1938

1939

1564

def server_bind(self):

1940

1565

"""This overrides the normal server_bind() function

1941

1566

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

1949

1574

try:

1950

1575

self.socket.setsockopt(socket.SOL_SOCKET,

1951

1576

SO_BINDTODEVICE,

1952

str(self.interface + '\0'))

1577

str(self.interface

1578

+ '\0'))

1953

1579

except socket.error as error:

1954

if error.errno == errno.EPERM:

1955

logger.error("No permission to bind to"

1956

" interface %s", self.interface)

1957

elif error.errno == errno.ENOPROTOOPT:

1580

if error[0] == errno.EPERM:

1581

logger.error("No permission to"

1582

" bind to interface %s",

1583

self.interface)

1584

elif error[0] == errno.ENOPROTOOPT:

1958

1585

logger.error("SO_BINDTODEVICE not available;"

1959

1586

" cannot bind to interface %s",

1960

1587

self.interface)

1961

elif error.errno == errno.ENODEV:

1962

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

1963

" cannot bind", self.interface)

1964

1588

else:

1965

1589

raise

1966

1590

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

1996

1620

"""

1997

1621

def __init__(self, server_address, RequestHandlerClass,

1998

1622

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

1999

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

1623

gnutls_priority=None, use_dbus=True):

2000

1624

self.enabled = False

2001

1625

self.clients = clients

2002

1626

if self.clients is None:

2003

self.clients = {}

1627

self.clients = set()

2004

1628

self.use_dbus = use_dbus

2005

1629

self.gnutls_priority = gnutls_priority

2006

1630

IPv6_TCPServer.__init__(self, server_address,

2007

1631

RequestHandlerClass,

2008

1632

interface = interface,

2009

use_ipv6 = use_ipv6,

2010

socketfd = socketfd)

1633

use_ipv6 = use_ipv6)

2011

1634

def server_activate(self):

2012

1635

if self.enabled:

2013

1636

return socketserver.TCPServer.server_activate(self)

2026

1649

2027

1650

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

2028

1651

proc = None, client_object=None):

1652

condition_names = {

1653

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

1654

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

1655

# blocking).

1656

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

1657

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

1658

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

1659

# broken, usually for pipes and

1660

# sockets).

1661

}

1662

conditions_string = ' | '.join(name

1663

for cond, name in

1664

condition_names.iteritems()

1665

if cond & condition)

2029

1666

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

2030

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

1667

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

2031

1668

# Wait for other process to exit

2032

1669

proc.join()

2033

1670

return False

2040

1677

fpr = request[1]

2041

1678

address = request[2]

2042

1679

2043

for c in self.clients.itervalues():

1680

for c in self.clients:

2044

1681

if c.fingerprint == fpr:

2045

1682

client = c

2046

1683

break

2091

1728

return True

2092

1729

2093

1730

2094

def rfc3339_duration_to_delta(duration):

2095

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

2096

2097

>>> rfc3339_duration_to_delta("P7D")

2098

datetime.timedelta(7)

2099

>>> rfc3339_duration_to_delta("PT60S")

2100

datetime.timedelta(0, 60)

2101

>>> rfc3339_duration_to_delta("PT60M")

2102

datetime.timedelta(0, 3600)

2103

>>> rfc3339_duration_to_delta("PT24H")

2104

datetime.timedelta(1)

2105

>>> rfc3339_duration_to_delta("P1W")

2106

datetime.timedelta(7)

2107

>>> rfc3339_duration_to_delta("PT5M30S")

2108

datetime.timedelta(0, 330)

2109

>>> rfc3339_duration_to_delta("P1DT3M20S")

2110

datetime.timedelta(1, 200)

2111

"""

2112

2113

# Parsing an RFC 3339 duration with regular expressions is not

2114

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

2115

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

2116

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

2117

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

2118

# avoid excessive use of external libraries.

2119

2120

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

2121

Token = collections.namedtuple("Token",

2122

("regexp", # To match token; if

2123

# "value" is not None,

2124

# must have a "group"

2125

# containing digits

2126

"value", # datetime.timedelta or

2127

# None

2128

"followers")) # Tokens valid after

2129

# this token

2130

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

2131

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

2132

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

2133

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

2134

datetime.timedelta(seconds=1),

2135

frozenset((token_end,)))

2136

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

2137

datetime.timedelta(minutes=1),

2138

frozenset((token_second, token_end)))

2139

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

2140

datetime.timedelta(hours=1),

2141

frozenset((token_minute, token_end)))

2142

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

2143

None,

2144

frozenset((token_hour, token_minute,

2145

token_second)))

2146

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

2147

datetime.timedelta(days=1),

2148

frozenset((token_time, token_end)))

2149

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

2150

datetime.timedelta(weeks=4),

2151

frozenset((token_day, token_end)))

2152

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

2153

datetime.timedelta(weeks=52),

2154

frozenset((token_month, token_end)))

2155

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

2156

datetime.timedelta(weeks=1),

2157

frozenset((token_end,)))

2158

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

2159

frozenset((token_year, token_month,

2160

token_day, token_time,

2161

token_week))),

2162

# Define starting values

2163

value = datetime.timedelta() # Value so far

2164

found_token = None

2165

followers = frozenset(token_duration,) # Following valid tokens

2166

s = duration # String left to parse

2167

# Loop until end token is found

2168

while found_token is not token_end:

2169

# Search for any currently valid tokens

2170

for token in followers:

2171

match = token.regexp.match(s)

2172

if match is not None:

2173

# Token found

2174

if token.value is not None:

2175

# Value found, parse digits

2176

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

2177

# Add to value so far

2178

value += factor * token.value

2179

# Strip token from string

2180

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

2181

# Go to found token

2182

found_token = token

2183

# Set valid next tokens

2184

followers = found_token.followers

2185

break

2186

else:

2187

# No currently valid tokens were found

2188

raise ValueError("Invalid RFC 3339 duration")

2189

# End token found

2190

return value

2191

2192

2193

1731

def string_to_delta(interval):

2194

1732

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

2195

1733

2206

1744

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

2207

1745

datetime.timedelta(0, 330)

2208

1746

"""

2209

2210

try:

2211

return rfc3339_duration_to_delta(interval)

2212

except ValueError:

2213

pass

2214

2215

1747

timevalue = datetime.timedelta(0)

2216

1748

for s in interval.split():

2217

1749

try:

2228

1760

elif suffix == "w":

2229

1761

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

2230

1762

else:

2231

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

2232

.format(suffix))

1763

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

2233

1764

except (ValueError, IndexError) as e:

2234

1765

raise ValueError(*(e.args))

2235

1766

timevalue += delta

2236

1767

return timevalue

2237

1768

2238

1769

1770

def if_nametoindex(interface):

1771

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

1772

1773

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

1774

global if_nametoindex

1775

try:

1776

if_nametoindex = (ctypes.cdll.LoadLibrary

1777

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

1778

.if_nametoindex)

1779

except (OSError, AttributeError):

1780

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

1781

def if_nametoindex(interface):

1782

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

1783

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

1784

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

1785

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1786

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

1787

interface))

1788

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

1789

ifreq[16:20])[0]

1790

return interface_index

1791

return if_nametoindex(interface)

1792

1793

2239

1794

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

2240

1795

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

2241

1796

2249

1804

sys.exit()

2250

1805

if not noclose:

2251

1806

# Close all standard open file descriptors

2252

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

1807

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

2253

1808

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

2254

1809

raise OSError(errno.ENODEV,

2255

"{0} not a character device"

2256

.format(os.devnull))

1810

"%s not a character device"

1811

% os.path.devnull)

2257

1812

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

2258

1813

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

2259

1814

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

2268

1823

2269

1824

parser = argparse.ArgumentParser()

2270

1825

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

2271

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

1826

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

2272

1827

help="show version number and exit")

2273

1828

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

2274

1829

help="Bind to interface IF")

2296

1851

" system bus interface")

2297

1852

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

2298

1853

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

2299

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

2300

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

2301

" state")

2302

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

2303

help="Specify a file descriptor to a network"

2304

" socket to use instead of creating one")

2305

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

2306

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

2307

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

2308

help="Run in foreground")

2309

2310

1854

options = parser.parse_args()

2311

1855

2312

1856

if options.check:

2325

1869

"use_dbus": "True",

2326

1870

"use_ipv6": "True",

2327

1871

"debuglevel": "",

2328

"restore": "True",

2329

"socket": "",

2330

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

2331

"foreground": "False",

2332

1872

}

2333

1873

2334

1874

# Parse config file for server-global settings

2339

1879

# Convert the SafeConfigParser object to a dict

2340

1880

server_settings = server_config.defaults()

2341

1881

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

2342

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

1882

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

2343

1883

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

2344

1884

option)

2345

1885

if server_settings["port"]:

2346

1886

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

2347

1887

"port")

2348

if server_settings["socket"]:

2349

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

2350

"socket")

2351

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

2352

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

2353

# happen with a supplied network socket.

2354

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

2355

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

2356

["socket"])

2357

1888

del server_config

2358

1889

2359

1890

# Override the settings from the config file with command line

2360

1891

# options, if set.

2361

1892

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

2362

1893

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

2363

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

2364

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

1894

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

2365

1895

value = getattr(options, option)

2366

1896

if value is not None:

2367

1897

server_settings[option] = value

2370

1900

for option in server_settings.keys():

2371

1901

if type(server_settings[option]) is str:

2372

1902

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

2373

# Debug implies foreground

2374

if server_settings["debug"]:

2375

server_settings["foreground"] = True

2376

1903

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

2377

1904

2378

1905

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

2382

1909

debuglevel = server_settings["debuglevel"]

2383

1910

use_dbus = server_settings["use_dbus"]

2384

1911

use_ipv6 = server_settings["use_ipv6"]

2385

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

2386

stored_state_file)

2387

foreground = server_settings["foreground"]

2388

2389

if debug:

2390

initlogger(debug, logging.DEBUG)

2391

else:

2392

if not debuglevel:

2393

initlogger(debug)

2394

else:

2395

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

2396

initlogger(debug, level)

2397

1912

2398

1913

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

2399

1914

syslogger.setFormatter(logging.Formatter

2400

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

2401

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

2402

.format(server_settings

2403

["servicename"])))

1915

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

1916

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

1917

% server_settings["servicename"]))

2404

1918

2405

1919

# Parse config file with clients

2406

client_config = configparser.SafeConfigParser(Client

2407

.client_defaults)

1920

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

1921

"extended_timeout": "15m",

1922

"interval": "2m",

1923

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

1924

"host": "",

1925

"approval_delay": "0s",

1926

"approval_duration": "1s",

1927

}

1928

client_config = configparser.SafeConfigParser(client_defaults)

2408

1929

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

2409

1930

"clients.conf"))

2410

1931

2419

1940

use_ipv6=use_ipv6,

2420

1941

gnutls_priority=

2421

1942

server_settings["priority"],

2422

use_dbus=use_dbus,

2423

socketfd=(server_settings["socket"]

2424

or None))

2425

if not foreground:

1943

use_dbus=use_dbus)

1944

if not debug:

2426

1945

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

2427

pidfile = None

2428

1946

try:

2429

1947

pidfile = open(pidfilename, "w")

2430

except IOError as e:

2431

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

2432

exc_info=e)

1948

except IOError:

1949

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

2433

1950

2434

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

1951

try:

1952

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

1953

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

1954

except KeyError:

2435

1955

try:

2436

uid = pwd.getpwnam(name).pw_uid

2437

gid = pwd.getpwnam(name).pw_gid

2438

break

1956

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

1957

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

2439

1958

except KeyError:

2440

continue

2441

else:

2442

uid = 65534

2443

gid = 65534

1959

try:

1960

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

1961

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

1962

except KeyError:

1963

uid = 65534

1964

gid = 65534

2444

1965

try:

2445

1966

os.setgid(gid)

2446

1967

os.setuid(uid)

2447

1968

except OSError as error:

2448

if error.errno != errno.EPERM:

1969

if error[0] != errno.EPERM:

2449

1970

raise error

2450

1971

1972

if not debug and not debuglevel:

1973

syslogger.setLevel(logging.WARNING)

1974

console.setLevel(logging.WARNING)

1975

if debuglevel:

1976

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

1977

syslogger.setLevel(level)

1978

console.setLevel(level)

1979

2451

1980

if debug:

2452

1981

# Enable all possible GnuTLS debugging

2453

1982

2463

1992

.gnutls_global_set_log_function(debug_gnutls))

2464

1993

2465

1994

# Redirect stdin so all checkers get /dev/null

2466

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

1995

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

2467

1996

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

2468

1997

if null > 2:

2469

1998

os.close(null)

1999

else:

2000

# No console logging

2001

logger.removeHandler(console)

2470

2002

2471

2003

# Need to fork before connecting to D-Bus

2472

if not foreground:

2004

if not debug:

2473

2005

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

2474

2006

daemon()

2475

2007

2476

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

2477

# need to inform gobject that threads will be used.

2478

gobject.threads_init()

2479

2480

2008

global main_loop

2481

2009

# From the Avahi example code

2482

DBusGMainLoop(set_as_default=True)

2010

DBusGMainLoop(set_as_default=True )

2483

2011

main_loop = gobject.MainLoop()

2484

2012

bus = dbus.SystemBus()

2485

2013

# End of Avahi example code

2491

2019

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

2492

2020

do_not_queue=True))

2493

2021

except dbus.exceptions.NameExistsException as e:

2494

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

2022

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

2495

2023

use_dbus = False

2496

2024

server_settings["use_dbus"] = False

2497

2025

tcp_server.use_dbus = False

2498

2026

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2499

service = AvahiServiceToSyslog(name =

2500

server_settings["servicename"],

2501

servicetype = "_mandos._tcp",

2502

protocol = protocol, bus = bus)

2027

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

2028

servicetype = "_mandos._tcp",

2029

protocol = protocol, bus = bus)

2503

2030

if server_settings["interface"]:

2504

2031

service.interface = (if_nametoindex

2505

2032

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

2509

2036

2510

2037

client_class = Client

2511

2038

if use_dbus:

2512

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

2513

2514

client_settings = Client.config_parser(client_config)

2515

old_client_settings = {}

2516

clients_data = {}

2517

2518

# Get client data and settings from last running state.

2519

if server_settings["restore"]:

2520

try:

2521

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

2522

clients_data, old_client_settings = (pickle.load

2523

(stored_state))

2524

os.remove(stored_state_path)

2525

except IOError as e:

2526

if e.errno == errno.ENOENT:

2527

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

2528

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

2529

else:

2530

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

2531

exc_info=e)

2532

raise

2533

except EOFError as e:

2534

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

2535

"EOFError:", exc_info=e)

2536

2537

with PGPEngine() as pgp:

2538

for client_name, client in clients_data.iteritems():

2539

# Decide which value to use after restoring saved state.

2540

# We have three different values: Old config file,

2541

# new config file, and saved state.

2542

# New config value takes precedence if it differs from old

2543

# config value, otherwise use saved state.

2544

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

2545

try:

2546

# For each value in new config, check if it

2547

# differs from the old config value (Except for

2548

# the "secret" attribute)

2549

if (name != "secret" and

2550

value != old_client_settings[client_name]

2551

[name]):

2552

client[name] = value

2553

except KeyError:

2554

pass

2555

2556

# Clients who has passed its expire date can still be

2557

# enabled if its last checker was successful. Clients

2558

# whose checker succeeded before we stored its state is

2559

# assumed to have successfully run all checkers during

2560

# downtime.

2561

if client["enabled"]:

2562

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

2563

if not client["last_checked_ok"]:

2564

logger.warning(

2565

"disabling client {0} - Client never "

2566

"performed a successful checker"

2567

.format(client_name))

2568

client["enabled"] = False

2569

elif client["last_checker_status"] != 0:

2570

logger.warning(

2571

"disabling client {0} - Client "

2572

"last checker failed with error code {1}"

2573

.format(client_name,

2574

client["last_checker_status"]))

2575

client["enabled"] = False

2576

else:

2577

client["expires"] = (datetime.datetime

2578

.utcnow()

2579

+ client["timeout"])

2580

logger.debug("Last checker succeeded,"

2581

" keeping {0} enabled"

2582

.format(client_name))

2039

client_class = functools.partial(ClientDBusTransitional,

2040

bus = bus)

2041

def client_config_items(config, section):

2042

special_settings = {

2043

"approved_by_default":

2044

lambda: config.getboolean(section,

2045

"approved_by_default"),

2046

}

2047

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

2583

2048

try:

2584

client["secret"] = (

2585

pgp.decrypt(client["encrypted_secret"],

2586

client_settings[client_name]

2587

["secret"]))

2588

except PGPError:

2589

# If decryption fails, we use secret from new settings

2590

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

2591

.format(client_name))

2592

client["secret"] = (

2593

client_settings[client_name]["secret"])

2594

2595

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

2596

for client_name in (set(old_client_settings)

2597

- set(client_settings)):

2598

del clients_data[client_name]

2599

for client_name in (set(client_settings)

2600

- set(old_client_settings)):

2601

clients_data[client_name] = client_settings[client_name]

2602

2603

# Create all client objects

2604

for client_name, client in clients_data.iteritems():

2605

tcp_server.clients[client_name] = client_class(

2606

name = client_name, settings = client)

2607

2049

yield (name, special_settings[name]())

2050

except KeyError:

2051

yield (name, value)

2052

2053

tcp_server.clients.update(set(

2054

client_class(name = section,

2055

config= dict(client_config_items(

2056

client_config, section)))

2057

for section in client_config.sections()))

2608

2058

if not tcp_server.clients:

2609

2059

logger.warning("No clients defined")

2610

2611

if not foreground:

2612

if pidfile is not None:

2613

try:

2614

with pidfile:

2615

pid = os.getpid()

2616

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

2617

except IOError:

2618

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

2619

pidfilename, pid)

2620

del pidfile

2060

2061

if not debug:

2062

try:

2063

with pidfile:

2064

pid = os.getpid()

2065

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

2066

del pidfile

2067

except IOError:

2068

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

2069

pidfilename, pid)

2070

except NameError:

2071

# "pidfile" was never created

2072

pass

2621

2073

del pidfilename

2074

2075

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

2622

2076

2623

2077

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

2624

2078

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

2625

2079

2626

2080

if use_dbus:

2627

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

2628

"se.bsnet.fukt.Mandos"})

2629

class MandosDBusService(DBusObjectWithProperties):

2081

class MandosDBusService(dbus.service.Object):

2630

2082

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

2631

2083

def __init__(self):

2632

2084

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

2633

2085

_interface = "se.recompile.Mandos"

2634

2086

2635

@dbus_interface_annotations(_interface)

2636

def _foo(self):

2637

return { "org.freedesktop.DBus.Property"

2638

".EmitsChangedSignal":

2639

"false"}

2640

2641

2087

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

2642

2088

def ClientAdded(self, objpath):

2643

2089

"D-Bus signal"

2657

2103

def GetAllClients(self):

2658

2104

"D-Bus method"

2659

2105

return dbus.Array(c.dbus_object_path

2660

for c in

2661

tcp_server.clients.itervalues())

2106

for c in tcp_server.clients)

2662

2107

2663

2108

@dbus.service.method(_interface,

2664

2109

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

2666

2111

"D-Bus method"

2667

2112

return dbus.Dictionary(

2668

2113

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

2669

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

2114

for c in tcp_server.clients),

2670

2115

signature="oa{sv}")

2671

2116

2672

2117

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

2673

2118

def RemoveClient(self, object_path):

2674

2119

"D-Bus method"

2675

for c in tcp_server.clients.itervalues():

2120

for c in tcp_server.clients:

2676

2121

if c.dbus_object_path == object_path:

2677

del tcp_server.clients[c.name]

2122

tcp_server.clients.remove(c)

2678

2123

c.remove_from_connection()

2679

2124

# Don't signal anything except ClientRemoved

2680

2125

c.disable(quiet=True)

2685

2130

2686

2131

del _interface

2687

2132

2688

mandos_dbus_service = MandosDBusService()

2133

class MandosDBusServiceTransitional(MandosDBusService):

2134

__metaclass__ = AlternateDBusNamesMetaclass

2135

mandos_dbus_service = MandosDBusServiceTransitional()

2689

2136

2690

2137

def cleanup():

2691

2138

"Cleanup function; run on exit"

2692

2139

service.cleanup()

2693

2140

2694

2141

multiprocessing.active_children()

2695

if not (tcp_server.clients or client_settings):

2696

return

2697

2698

# Store client before exiting. Secrets are encrypted with key

2699

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

2700

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

2701

clients = {}

2702

with PGPEngine() as pgp:

2703

for client in tcp_server.clients.itervalues():

2704

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

2705

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

2706

key)

2707

client_dict = {}

2708

2709

# A list of attributes that can not be pickled

2710

# + secret.

2711

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

2712

"checker"))

2713

for name, typ in (inspect.getmembers

2714

(dbus.service.Object)):

2715

exclude.add(name)

2716

2717

client_dict["encrypted_secret"] = (client

2718

.encrypted_secret)

2719

for attr in client.client_structure:

2720

if attr not in exclude:

2721

client_dict[attr] = getattr(client, attr)

2722

2723

clients[client.name] = client_dict

2724

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

2725

2726

try:

2727

with (tempfile.NamedTemporaryFile

2728

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

2729

dir=os.path.dirname(stored_state_path),

2730

delete=False)) as stored_state:

2731

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

2732

tempname=stored_state.name

2733

os.rename(tempname, stored_state_path)

2734

except (IOError, OSError) as e:

2735

if not debug:

2736

try:

2737

os.remove(tempname)

2738

except NameError:

2739

pass

2740

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

2741

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

2742

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

2743

else:

2744

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

2745

exc_info=e)

2746

raise e

2747

2748

# Delete all clients, and settings from config

2749

2142

while tcp_server.clients:

2750

name, client = tcp_server.clients.popitem()

2143

client = tcp_server.clients.pop()

2751

2144

if use_dbus:

2752

2145

client.remove_from_connection()

2146

client.disable_hook = None

2753

2147

# Don't signal anything except ClientRemoved

2754

2148

client.disable(quiet=True)

2755

2149

if use_dbus:

2757

2151

mandos_dbus_service.ClientRemoved(client

2758

2152

.dbus_object_path,

2759

2153

client.name)

2760

client_settings.clear()

2761

2154

2762

2155

atexit.register(cleanup)

2763

2156

2764

for client in tcp_server.clients.itervalues():

2157

for client in tcp_server.clients:

2765

2158

if use_dbus:

2766

2159

# Emit D-Bus signal

2767

2160

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2768

# Need to initiate checking of clients

2769

if client.enabled:

2770

client.init_checker()

2161

client.enable()

2771

2162

2772

2163

tcp_server.enable()

2773

2164

tcp_server.server_activate()

2776

2167

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

2777

2168

if use_ipv6:

2778

2169

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

2779

" flowinfo %d, scope_id %d",

2780

*tcp_server.socket.getsockname())

2170

" flowinfo %d, scope_id %d"

2171

% tcp_server.socket.getsockname())

2781

2172

else: # IPv4

2782

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

2783

*tcp_server.socket.getsockname())

2173

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

2174

% tcp_server.socket.getsockname())

2784

2175

2785

2176

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

2786

2177

2789

2180

try:

2790

2181

service.activate()

2791

2182

except dbus.exceptions.DBusException as error:

2792

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

2183

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

2793

2184

cleanup()

2794

2185

sys.exit(1)

2795

2186

# End of Avahi example code

2802

2193

logger.debug("Starting main loop")

2803

2194

main_loop.run()

2804

2195

except AvahiError as error:

2805

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

2196

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

2806

2197

cleanup()

2807

2198

sys.exit(1)

2808

2199

except KeyboardInterrupt:

2813

2204

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

2814

2205

cleanup()

2815

2206

2207

2816

2208

if __name__ == '__main__':

2817

2209

main()