/mandos/release : revision 237.16.16

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

63

import cPickle as pickle

64

import multiprocessing

65

import types

66

import binascii

67

import tempfile

68

import itertools

69

66

70

67

import dbus

71

68

import dbus.service

76

73

import ctypes.util

77

74

import xml.dom.minidom

78

75

import inspect

79

import GnuPGInterface

80

76

81

77

try:

82

78

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

86

82

except ImportError:

87

83

SO_BINDTODEVICE = None

88

84

89

version = "1.5.3"

90

stored_state_file = "clients.pickle"

91

92

logger = logging.getLogger()

85

86

version = "1.4.1"

87

88

#logger = logging.getLogger('mandos')

89

logger = logging.Logger('mandos')

93

90

syslogger = (logging.handlers.SysLogHandler

94

91

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

95

92

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

96

97

try:

98

if_nametoindex = (ctypes.cdll.LoadLibrary

99

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

100

.if_nametoindex)

101

except (OSError, AttributeError):

102

def if_nametoindex(interface):

103

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

104

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

105

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

106

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

107

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

108

interface))

109

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

110

ifreq[16:20])[0]

111

return interface_index

112

113

114

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

115

"""init logger and add loglevel"""

116

117

syslogger.setFormatter(logging.Formatter

118

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

119

' %(message)s'))

120

logger.addHandler(syslogger)

121

122

if debug:

123

console = logging.StreamHandler()

124

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

125

' [%(process)d]:'

126

' %(levelname)s:'

127

' %(message)s'))

128

logger.addHandler(console)

129

logger.setLevel(level)

130

131

132

class PGPError(Exception):

133

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

134

pass

135

136

137

class PGPEngine(object):

138

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

139

def __init__(self):

140

self.gnupg = GnuPGInterface.GnuPG()

141

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

142

self.gnupg = GnuPGInterface.GnuPG()

143

self.gnupg.options.meta_interactive = False

144

self.gnupg.options.homedir = self.tempdir

145

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

146

'--quiet',

147

'--no-use-agent'])

148

149

def __enter__(self):

150

return self

151

152

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

153

self._cleanup()

154

return False

155

156

def __del__(self):

157

self._cleanup()

158

159

def _cleanup(self):

160

if self.tempdir is not None:

161

# Delete contents of tempdir

162

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

163

topdown = False):

164

for filename in files:

165

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

166

for dirname in dirs:

167

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

168

# Remove tempdir

169

os.rmdir(self.tempdir)

170

self.tempdir = None

171

172

def password_encode(self, password):

173

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

174

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

175

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

176

177

def encrypt(self, data, password):

178

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

179

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

180

try:

181

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

182

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

183

attach_fhs={'stderr': devnull})

184

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

185

f.write(data)

186

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

187

ciphertext = f.read()

188

proc.wait()

189

except IOError as e:

190

raise PGPError(e)

191

self.gnupg.passphrase = None

192

return ciphertext

193

194

def decrypt(self, data, password):

195

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

196

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

197

try:

198

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

199

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

200

attach_fhs={'stderr': devnull})

201

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

202

f.write(data)

203

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

204

decrypted_plaintext = f.read()

205

proc.wait()

206

except IOError as e:

207

raise PGPError(e)

208

self.gnupg.passphrase = None

209

return decrypted_plaintext

210

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)

211

103

212

104

class AvahiError(Exception):

213

105

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

243

135

server: D-Bus Server

244

136

bus: dbus.SystemBus()

245

137

"""

246

247

138

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

248

139

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

249

140

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

262

153

self.server = None

263

154

self.bus = bus

264

155

self.entry_group_state_changed_match = None

265

266

156

def rename(self):

267

157

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

268

158

if self.rename_count >= self.max_renames:

274

164

.GetAlternativeServiceName(self.name))

275

165

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

276

166

self.name)

167

syslogger.setFormatter(logging.Formatter

168

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

169

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

170

% self.name))

277

171

self.remove()

278

172

try:

279

173

self.add()

280

174

except dbus.exceptions.DBusException as error:

281

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

175

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

282

176

self.cleanup()

283

177

os._exit(1)

284

178

self.rename_count += 1

285

286

179

def remove(self):

287

180

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

288

181

if self.entry_group_state_changed_match is not None:

290

183

self.entry_group_state_changed_match = None

291

184

if self.group is not None:

292

185

self.group.Reset()

293

294

186

def add(self):

295

187

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

296

188

self.remove()

301

193

avahi.DBUS_INTERFACE_ENTRY_GROUP)

302

194

self.entry_group_state_changed_match = (

303

195

self.group.connect_to_signal(

304

'StateChanged', self.entry_group_state_changed))

196

'StateChanged', self .entry_group_state_changed))

305

197

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

306

198

self.name, self.type)

307

199

self.group.AddService(

313

205

dbus.UInt16(self.port),

314

206

avahi.string_array_to_txt_array(self.TXT))

315

207

self.group.Commit()

316

317

208

def entry_group_state_changed(self, state, error):

318

209

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

319

210

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

326

217

elif state == avahi.ENTRY_GROUP_FAILURE:

327

218

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

328

219

unicode(error))

329

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

330

.format(error))

331

220

raise AvahiGroupError("State changed: %s"

221

% unicode(error))

332

222

def cleanup(self):

333

223

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

334

224

if self.group is not None:

335

225

try:

336

226

self.group.Free()

337

227

except (dbus.exceptions.UnknownMethodException,

338

dbus.exceptions.DBusException):

228

dbus.exceptions.DBusException) as e:

339

229

pass

340

230

self.group = None

341

231

self.remove()

342

343

232

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

344

233

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

345

234

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

364

253

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

365

254

else:

366

255

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

367

368

256

def activate(self):

369

257

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

370

258

if self.server is None:

377

265

self.server_state_changed)

378

266

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

379

267

380

class AvahiServiceToSyslog(AvahiService):

381

def rename(self):

382

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

383

ret = AvahiService.rename(self)

384

syslogger.setFormatter(logging.Formatter

385

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

386

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

387

.format(self.name)))

388

return ret

389

268

390

def timedelta_to_milliseconds(td):

269

def _timedelta_to_milliseconds(td):

391

270

"Convert a datetime.timedelta() to milliseconds"

392

271

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

393

272

+ (td.seconds * 1000)

394

273

+ (td.microseconds // 1000))

395

274

396

275

class Client(object):

397

276

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

398

277

399

278

Attributes:

400

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

279

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

401

280

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

402

281

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

403

282

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

410

289

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

411

290

checker_initiator_tag: a gobject event source tag, or None

412

291

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

413

client_structure: Object describing what attributes a client has

414

and is used for storing the client at exit

415

292

current_checker_command: string; current running checker_command

293

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

416

294

disable_initiator_tag: a gobject event source tag, or None

417

295

enabled: bool()

418

296

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

421

299

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

422

300

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

423

301

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

424

last_checker_status: integer between 0 and 255 reflecting exit

425

status of last checker. -1 reflects crashed

426

checker, -2 means no checker completed yet.

427

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

302

last_enabled: datetime.datetime(); (UTC)

428

303

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

429

304

D-Bus identifiers

430

305

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

431

306

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

432

307

until this client is disabled

433

extended_timeout: extra long timeout when secret has been sent

308

extended_timeout: extra long timeout when password has been sent

434

309

runtime_expansions: Allowed attributes for runtime expansion.

435

310

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

436

311

disabled, or None

440

315

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

441

316

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

442

317

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

443

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

444

"extended_timeout": "15m",

445

"interval": "2m",

446

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

447

"host": "",

448

"approval_delay": "0s",

449

"approval_duration": "1s",

450

"approved_by_default": "True",

451

"enabled": "True",

452

}

453

318

454

319

def timeout_milliseconds(self):

455

320

"Return the 'timeout' attribute in milliseconds"

456

return timedelta_to_milliseconds(self.timeout)

321

return _timedelta_to_milliseconds(self.timeout)

457

322

458

323

def extended_timeout_milliseconds(self):

459

324

"Return the 'extended_timeout' attribute in milliseconds"

460

return timedelta_to_milliseconds(self.extended_timeout)

325

return _timedelta_to_milliseconds(self.extended_timeout)

461

326

462

327

def interval_milliseconds(self):

463

328

"Return the 'interval' attribute in milliseconds"

464

return timedelta_to_milliseconds(self.interval)

329

return _timedelta_to_milliseconds(self.interval)

465

330

466

331

def approval_delay_milliseconds(self):

467

return timedelta_to_milliseconds(self.approval_delay)

468

469

@staticmethod

470

def config_parser(config):

471

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

472

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

473

with exceptions for any special settings as defined above.

474

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

475

value given the same arguments.

476

"""

477

settings = {}

478

for client_name in config.sections():

479

section = dict(config.items(client_name))

480

client = settings[client_name] = {}

481

482

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

483

# Reformat values from string types to Python types

484

client["approved_by_default"] = config.getboolean(

485

client_name, "approved_by_default")

486

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

487

"enabled")

488

489

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

490

.replace(" ", ""))

491

if "secret" in section:

492

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

493

elif "secfile" in section:

494

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

495

(section["secfile"])),

496

"rb") as secfile:

497

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

498

else:

499

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

500

.format(section))

501

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

502

client["extended_timeout"] = string_to_delta(

503

section["extended_timeout"])

504

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

505

client["approval_delay"] = string_to_delta(

506

section["approval_delay"])

507

client["approval_duration"] = string_to_delta(

508

section["approval_duration"])

509

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

510

client["last_approval_request"] = None

511

client["last_checked_ok"] = None

512

client["last_checker_status"] = -2

513

514

return settings

515

516

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

517

338

self.name = name

518

# adding all client settings

519

for setting, value in settings.iteritems():

520

setattr(self, setting, value)

521

522

if self.enabled:

523

if not hasattr(self, "last_enabled"):

524

self.last_enabled = datetime.datetime.utcnow()

525

if not hasattr(self, "expires"):

526

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

527

+ self.timeout)

528

else:

529

self.last_enabled = None

530

self.expires = None

531

339

if config is None:

340

config = {}

532

341

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

533

342

# Uppercase and remove spaces from fingerprint for later

534

343

# comparison purposes with return value from the fingerprint()

535

344

# function

345

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

346

.replace(" ", ""))

536

347

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

537

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

538

datetime.datetime.utcnow())

539

540

# 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

541

369

self.checker = None

542

370

self.checker_initiator_tag = None

543

371

self.disable_initiator_tag = None

372

self.expires = None

544

373

self.checker_callback_tag = None

374

self.checker_command = config["checker"]

545

375

self.current_checker_command = None

546

self.approved = None

376

self.last_connect = None

377

self._approved = None

378

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

379

True)

547

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

548

385

self.changedstate = (multiprocessing_manager

549

386

.Condition(multiprocessing_manager

550

387

.Lock()))

551

self.client_structure = [attr for attr in

552

self.__dict__.iterkeys()

553

if not attr.startswith("_")]

554

self.client_structure.append("client_structure")

555

556

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

557

lambda obj:

558

isinstance(obj,

559

property)):

560

if not name.startswith("_"):

561

self.client_structure.append(name)

562

388

563

# Send notice to process children that client state has changed

564

389

def send_changedstate(self):

565

with self.changedstate:

566

self.changedstate.notify_all()

390

self.changedstate.acquire()

391

self.changedstate.notify_all()

392

self.changedstate.release()

567

393

568

394

def enable(self):

569

395

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

571

397

# Already enabled

572

398

return

573

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

574

406

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

407

self.disable_initiator_tag = (gobject.timeout_add

408

(self.timeout_milliseconds(),

409

self.disable))

575

410

self.enabled = True

576

411

self.last_enabled = datetime.datetime.utcnow()

577

self.init_checker()

412

# Also start a new checker *right now*.

413

self.start_checker()

578

414

579

415

def disable(self, quiet=True):

580

416

"""Disable this client."""

592

428

gobject.source_remove(self.checker_initiator_tag)

593

429

self.checker_initiator_tag = None

594

430

self.stop_checker()

431

if self.disable_hook:

432

self.disable_hook(self)

595

433

self.enabled = False

596

434

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

597

435

return False

598

436

599

437

def __del__(self):

438

self.disable_hook = None

600

439

self.disable()

601

440

602

def init_checker(self):

603

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

604

# and every interval from then on.

605

self.checker_initiator_tag = (gobject.timeout_add

606

(self.interval_milliseconds(),

607

self.start_checker))

608

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

609

self.disable_initiator_tag = (gobject.timeout_add

610

(self.timeout_milliseconds(),

611

self.disable))

612

# Also start a new checker *right now*.

613

self.start_checker()

614

615

441

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

616

442

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

617

443

self.checker_callback_tag = None

618

444

self.checker = None

619

445

if os.WIFEXITED(condition):

620

self.last_checker_status = os.WEXITSTATUS(condition)

621

if self.last_checker_status == 0:

446

exitstatus = os.WEXITSTATUS(condition)

447

if exitstatus == 0:

622

448

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

623

449

vars(self))

624

450

self.checked_ok()

626

452

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

627

453

vars(self))

628

454

else:

629

self.last_checker_status = -1

630

455

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

631

456

vars(self))

632

457

633

def checked_ok(self):

634

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

635

self.last_checked_ok = datetime.datetime.utcnow()

636

self.last_checker_status = 0

637

self.bump_timeout()

638

639

def bump_timeout(self, timeout=None):

640

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

"""

641

464

if timeout is None:

642

465

timeout = self.timeout

466

self.last_checked_ok = datetime.datetime.utcnow()

643

467

if self.disable_initiator_tag is not None:

644

468

gobject.source_remove(self.disable_initiator_tag)

645

469

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

646

470

self.disable_initiator_tag = (gobject.timeout_add

647

(timedelta_to_milliseconds

471

(_timedelta_to_milliseconds

648

472

(timeout), self.disable))

649

473

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

650

474

696

520

try:

697

521

command = self.checker_command % escaped_attrs

698

522

except TypeError as error:

699

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

700

self.checker_command, exc_info=error)

523

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

524

' %s', self.checker_command, error)

701

525

return True # Try again later

702

526

self.current_checker_command = command

703

527

try:

721

545

gobject.source_remove(self.checker_callback_tag)

722

546

self.checker_callback(pid, status, command)

723

547

except OSError as error:

724

logger.error("Failed to start subprocess",

725

exc_info=error)

548

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

549

error)

726

550

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

727

551

return True

728

552

735

559

return

736

560

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

737

561

try:

738

self.checker.terminate()

562

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

739

563

#time.sleep(0.5)

740

564

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

741

# self.checker.kill()

565

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

742

566

except OSError as error:

743

567

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

744

568

raise

761

585

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

762

586

if byte_arrays and signature != "ay":

763

587

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

764

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

588

" signature %r" % signature)

765

589

def decorator(func):

766

590

func._dbus_is_property = True

767

591

func._dbus_interface = dbus_interface

775

599

return decorator

776

600

777

601

778

def dbus_interface_annotations(dbus_interface):

779

"""Decorator for marking functions returning interface annotations

780

781

Usage:

782

783

@dbus_interface_annotations("org.example.Interface")

784

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

785

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

786

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

787

"false"}

788

"""

789

def decorator(func):

790

func._dbus_is_interface = True

791

func._dbus_interface = dbus_interface

792

func._dbus_name = dbus_interface

793

return func

794

return decorator

795

796

797

def dbus_annotations(annotations):

798

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

799

Usage:

800

801

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

802

access="r")

803

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

804

"org.freedesktop.DBus.Property."

805

"EmitsChangedSignal": "false"})

806

def Property_dbus_property(self):

807

return dbus.Boolean(False)

808

"""

809

def decorator(func):

810

func._dbus_annotations = annotations

811

return func

812

return decorator

813

814

815

602

class DBusPropertyException(dbus.exceptions.DBusException):

816

603

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

817

604

"""

840

627

"""

841

628

842

629

@staticmethod

843

def _is_dbus_thing(thing):

844

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

845

846

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

847

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

848

"""

849

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

850

False)

630

def _is_dbus_property(obj):

631

return getattr(obj, "_dbus_is_property", False)

851

632

852

def _get_all_dbus_things(self, thing):

633

def _get_all_dbus_properties(self):

853

634

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

854

635

"""

855

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

856

name),

857

athing.__get__(self))

636

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

858

637

for cls in self.__class__.__mro__

859

for name, athing in

860

inspect.getmembers(cls,

861

self._is_dbus_thing(thing)))

638

for name, prop in

639

inspect.getmembers(cls, self._is_dbus_property))

862

640

863

641

def _get_dbus_property(self, interface_name, property_name):

864

642

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

866

644

"""

867

645

for cls in self.__class__.__mro__:

868

646

for name, value in (inspect.getmembers

869

(cls,

870

self._is_dbus_thing("property"))):

647

(cls, self._is_dbus_property)):

871

648

if (value._dbus_name == property_name

872

649

and value._dbus_interface == interface_name):

873

650

return value.__get__(self)

902

679

# signatures other than "ay".

903

680

if prop._dbus_signature != "ay":

904

681

raise ValueError

905

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

906

for byte in value))

682

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

683

for byte in value))

907

684

prop(value)

908

685

909

686

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

914

691

915

692

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

916

693

"""

917

properties = {}

918

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

694

all = {}

695

for name, prop in self._get_all_dbus_properties():

919

696

if (interface_name

920

697

and interface_name != prop._dbus_interface):

921

698

# Interface non-empty but did not match

925

702

continue

926

703

value = prop()

927

704

if not hasattr(value, "variant_level"):

928

properties[name] = value

705

all[name] = value

929

706

continue

930

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

931

value.variant_level+1)

932

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

933

710

934

711

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

935

712

out_signature="s",

936

713

path_keyword='object_path',

937

714

connection_keyword='connection')

938

715

def Introspect(self, object_path, connection):

939

"""Overloading of standard D-Bus method.

940

941

Inserts property tags and interface annotation tags.

716

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

942

717

"""

943

718

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

944

719

connection)

951

726

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

952

727

return e

953

728

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

954

# Add property tags

955

729

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

956

730

for name, prop

957

in self._get_all_dbus_things("property")

731

in self._get_all_dbus_properties()

958

732

if prop._dbus_interface

959

733

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

960

734

if_tag.appendChild(tag)

961

# Add annotation tags

962

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

963

for tag in if_tag.getElementsByTagName(typ):

964

annots = dict()

965

for name, prop in (self.

966

_get_all_dbus_things(typ)):

967

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

968

and prop._dbus_interface

969

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

970

annots.update(getattr

971

(prop,

972

"_dbus_annotations",

973

{}))

974

for name, value in annots.iteritems():

975

ann_tag = document.createElement(

976

"annotation")

977

ann_tag.setAttribute("name", name)

978

ann_tag.setAttribute("value", value)

979

tag.appendChild(ann_tag)

980

# Add interface annotation tags

981

for annotation, value in dict(

982

itertools.chain(

983

*(annotations().iteritems()

984

for name, annotations in

985

self._get_all_dbus_things("interface")

986

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

987

))).iteritems():

988

ann_tag = document.createElement("annotation")

989

ann_tag.setAttribute("name", annotation)

990

ann_tag.setAttribute("value", value)

991

if_tag.appendChild(ann_tag)

992

735

# Add the names to the return values for the

993

736

# "org.freedesktop.DBus.Properties" methods

994

737

if (if_tag.getAttribute("name")

1009

752

except (AttributeError, xml.dom.DOMException,

1010

753

xml.parsers.expat.ExpatError) as error:

1011

754

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

1012

exc_info=error)

755

error)

1013

756

return xmlstring

1014

757

1015

758

1020

763

return dbus.String(dt.isoformat(),

1021

764

variant_level=variant_level)

1022

765

1023

1024

766

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

1025

767

.__metaclass__):

1026

768

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

1029

771

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

1030

772

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

1031

773

# methods, signals, or properties in them

1032

old_interface_names = []

1033

774

for base in (b for b in bases

1034

775

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

1035

776

# Go though all attributes of the base class

1045

786

alt_interface = (attribute._dbus_interface

1046

787

.replace("se.recompile.Mandos",

1047

788

"se.bsnet.fukt.Mandos"))

1048

if alt_interface != attribute._dbus_interface:

1049

old_interface_names.append(alt_interface)

1050

789

# Is this a D-Bus signal?

1051

790

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

1052

791

# Extract the original non-method function by

1067

806

nonmethod_func.func_name,

1068

807

nonmethod_func.func_defaults,

1069

808

nonmethod_func.func_closure)))

1070

# Copy annotations, if any

1071

try:

1072

new_function._dbus_annotations = (

1073

dict(attribute._dbus_annotations))

1074

except AttributeError:

1075

pass

1076

809

# Define a creator of a function to call both the

1077

810

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

1078

811

# signals gets sent when the function is called

1106

839

attribute.func_name,

1107

840

attribute.func_defaults,

1108

841

attribute.func_closure)))

1109

# Copy annotations, if any

1110

try:

1111

attr[attrname]._dbus_annotations = (

1112

dict(attribute._dbus_annotations))

1113

except AttributeError:

1114

pass

1115

842

# Is this a D-Bus property?

1116

843

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

1117

844

# Create a new, but exactly alike, function

1131

858

attribute.func_name,

1132

859

attribute.func_defaults,

1133

860

attribute.func_closure)))

1134

# Copy annotations, if any

1135

try:

1136

attr[attrname]._dbus_annotations = (

1137

dict(attribute._dbus_annotations))

1138

except AttributeError:

1139

pass

1140

# Is this a D-Bus interface?

1141

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

1142

# Create a new, but exactly alike, function

1143

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

1144

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

1145

# to the class.

1146

attr[attrname] = (dbus_interface_annotations

1147

(alt_interface)

1148

(types.FunctionType

1149

(attribute.func_code,

1150

attribute.func_globals,

1151

attribute.func_name,

1152

attribute.func_defaults,

1153

attribute.func_closure)))

1154

# Deprecate all old interfaces

1155

iname="_AlternateDBusNamesMetaclass_interface_annotation{0}"

1156

for old_interface_name in old_interface_names:

1157

@dbus_interface_annotations(old_interface_name)

1158

def func(self):

1159

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

1160

# Find an unused name

1161

for aname in (iname.format(i) for i in itertools.count()):

1162

if aname not in attr:

1163

attr[aname] = func

1164

break

1165

861

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

1166

862

1167

1168

863

class ClientDBus(Client, DBusObjectWithProperties):

1169

864

"""A Client class using D-Bus

1170

865

1179

874

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

1180

875

1181

876

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

877

self._approvals_pending = 0

1182

878

self.bus = bus

1183

879

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

1184

880

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

1190

886

("/clients/" + client_object_name))

1191

887

DBusObjectWithProperties.__init__(self, self.bus,

1192

888

self.dbus_object_path)

1193

889

1194

890

def notifychangeproperty(transform_func,

1195

891

dbus_name, type_func=lambda x: x,

1196

892

variant_level=1):

1197

893

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

1198

894

its changes to DBus.

1199

895

1200

896

transform_fun: Function that takes a value and a variant_level

1201

897

and transforms it to a D-Bus type.

1202

898

dbus_name: D-Bus name of the variable

1219

915

1220

916

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

1221

917

918

1222

919

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1223

920

approvals_pending = notifychangeproperty(dbus.Boolean,

1224

921

"ApprovalPending",

1231

928

checker is not None)

1232

929

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1233

930

"LastCheckedOK")

1234

last_checker_status = notifychangeproperty(dbus.Int16,

1235

"LastCheckerStatus")

1236

931

last_approval_request = notifychangeproperty(

1237

932

datetime_to_dbus, "LastApprovalRequest")

1238

933

approved_by_default = notifychangeproperty(dbus.Boolean,

1239

934

"ApprovedByDefault")

1240

approval_delay = notifychangeproperty(dbus.UInt64,

935

approval_delay = notifychangeproperty(dbus.UInt16,

1241

936

"ApprovalDelay",

1242

937

type_func =

1243

timedelta_to_milliseconds)

938

_timedelta_to_milliseconds)

1244

939

approval_duration = notifychangeproperty(

1245

dbus.UInt64, "ApprovalDuration",

1246

type_func = timedelta_to_milliseconds)

940

dbus.UInt16, "ApprovalDuration",

941

type_func = _timedelta_to_milliseconds)

1247

942

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

1248

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

943

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

1249

944

type_func =

1250

timedelta_to_milliseconds)

945

_timedelta_to_milliseconds)

1251

946

extended_timeout = notifychangeproperty(

1252

dbus.UInt64, "ExtendedTimeout",

1253

type_func = timedelta_to_milliseconds)

1254

interval = notifychangeproperty(dbus.UInt64,

947

dbus.UInt16, "ExtendedTimeout",

948

type_func = _timedelta_to_milliseconds)

949

interval = notifychangeproperty(dbus.UInt16,

1255

950

"Interval",

1256

951

type_func =

1257

timedelta_to_milliseconds)

952

_timedelta_to_milliseconds)

1258

953

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

1259

954

1260

955

del notifychangeproperty

1302

997

return r

1303

998

1304

999

def _reset_approved(self):

1305

self.approved = None

1000

self._approved = None

1306

1001

return False

1307

1002

1308

1003

def approve(self, value=True):

1309

1004

self.send_changedstate()

1310

self.approved = value

1311

gobject.timeout_add(timedelta_to_milliseconds

1005

self._approved = value

1006

gobject.timeout_add(_timedelta_to_milliseconds

1312

1007

(self.approval_duration),

1313

1008

self._reset_approved)

1314

1009

1010

1315

1011

## D-Bus methods, signals & properties

1316

1012

_interface = "se.recompile.Mandos.Client"

1317

1013

1318

## Interfaces

1319

1320

@dbus_interface_annotations(_interface)

1321

def _foo(self):

1322

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

1323

"false"}

1324

1325

1014

## Signals

1326

1015

1327

1016

# CheckerCompleted - signal

1426

1115

access="readwrite")

1427

1116

def ApprovalDuration_dbus_property(self, value=None):

1428

1117

if value is None: # get

1429

return dbus.UInt64(timedelta_to_milliseconds(

1118

return dbus.UInt64(_timedelta_to_milliseconds(

1430

1119

self.approval_duration))

1431

1120

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

1432

1121

1446

1135

def Host_dbus_property(self, value=None):

1447

1136

if value is None: # get

1448

1137

return dbus.String(self.host)

1449

self.host = unicode(value)

1138

self.host = value

1450

1139

1451

1140

# Created - property

1452

1141

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

1453

1142

def Created_dbus_property(self):

1454

return datetime_to_dbus(self.created)

1143

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

1455

1144

1456

1145

# LastEnabled - property

1457

1146

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

1478

1167

return

1479

1168

return datetime_to_dbus(self.last_checked_ok)

1480

1169

1481

# LastCheckerStatus - property

1482

@dbus_service_property(_interface, signature="n",

1483

access="read")

1484

def LastCheckerStatus_dbus_property(self):

1485

return dbus.Int16(self.last_checker_status)

1486

1487

1170

# Expires - property

1488

1171

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

1489

1172

def Expires_dbus_property(self):

1501

1184

if value is None: # get

1502

1185

return dbus.UInt64(self.timeout_milliseconds())

1503

1186

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

1187

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

1188

return

1504

1189

# Reschedule timeout

1505

if self.enabled:

1506

now = datetime.datetime.utcnow()

1507

time_to_die = timedelta_to_milliseconds(

1508

(self.last_checked_ok + self.timeout) - now)

1509

if time_to_die <= 0:

1510

# The timeout has passed

1511

self.disable()

1512

else:

1513

self.expires = (now +

1514

datetime.timedelta(milliseconds =

1515

time_to_die))

1516

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

1517

is None):

1518

return

1519

gobject.source_remove(self.disable_initiator_tag)

1520

self.disable_initiator_tag = (gobject.timeout_add

1521

(time_to_die,

1522

self.disable))

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

1523

1207

1524

1208

# ExtendedTimeout - property

1525

1209

@dbus_service_property(_interface, signature="t",

1538

1222

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

1539

1223

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

1540

1224

return

1541

if self.enabled:

1542

# Reschedule checker run

1543

gobject.source_remove(self.checker_initiator_tag)

1544

self.checker_initiator_tag = (gobject.timeout_add

1545

(value, self.start_checker))

1546

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

1547

1230

1548

1231

# Checker - property

1549

1232

@dbus_service_property(_interface, signature="s",

1551

1234

def Checker_dbus_property(self, value=None):

1552

1235

if value is None: # get

1553

1236

return dbus.String(self.checker_command)

1554

self.checker_command = unicode(value)

1237

self.checker_command = value

1555

1238

1556

1239

# CheckerRunning - property

1557

1240

@dbus_service_property(_interface, signature="b",

1586

1269

raise KeyError()

1587

1270

1588

1271

def __getattribute__(self, name):

1589

if name == '_pipe':

1272

if(name == '_pipe'):

1590

1273

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

1591

1274

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

1592

1275

data = self._pipe.recv()

1599

1282

return func

1600

1283

1601

1284

def __setattr__(self, name, value):

1602

if name == '_pipe':

1285

if(name == '_pipe'):

1603

1286

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

1604

1287

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

1605

1288

1606

1607

1289

class ClientDBusTransitional(ClientDBus):

1608

1290

__metaclass__ = AlternateDBusNamesMetaclass

1609

1291

1610

1611

1292

class ClientHandler(socketserver.BaseRequestHandler, object):

1612

1293

"""A class to handle client connections.

1613

1294

1695

1376

client.Rejected("Disabled")

1696

1377

return

1697

1378

1698

if client.approved or not client.approval_delay:

1379

if client._approved or not client.approval_delay:

1699

1380

#We are approved or approval is disabled

1700

1381

break

1701

elif client.approved is None:

1382

elif client._approved is None:

1702

1383

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

1703

1384

client.name)

1704

1385

if self.server.use_dbus:

1718

1399

time = datetime.datetime.now()

1719

1400

client.changedstate.acquire()

1720

1401

(client.changedstate.wait

1721

(float(client.timedelta_to_milliseconds(delay)

1402

(float(client._timedelta_to_milliseconds(delay)

1722

1403

/ 1000)))

1723

1404

client.changedstate.release()

1724

1405

time2 = datetime.datetime.now()

1750

1431

1751

1432

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

1752

1433

# bump the timeout using extended_timeout

1753

client.bump_timeout(client.extended_timeout)

1434

client.checked_ok(client.extended_timeout)

1754

1435

if self.server.use_dbus:

1755

1436

# Emit D-Bus signal

1756

1437

client.GotSecret()

1823

1504

# Convert the buffer to a Python bytestring

1824

1505

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

1825

1506

# Convert the bytestring to hexadecimal notation

1826

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

1507

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

1827

1508

return hex_fpr

1828

1509

1829

1510

1832

1513

def sub_process_main(self, request, address):

1833

1514

try:

1834

1515

self.finish_request(request, address)

1835

except Exception:

1516

except:

1836

1517

self.handle_error(request, address)

1837

1518

self.close_request(request)

1838

1519

1943

1624

self.enabled = False

1944

1625

self.clients = clients

1945

1626

if self.clients is None:

1946

self.clients = {}

1627

self.clients = set()

1947

1628

self.use_dbus = use_dbus

1948

1629

self.gnutls_priority = gnutls_priority

1949

1630

IPv6_TCPServer.__init__(self, server_address,

1996

1677

fpr = request[1]

1997

1678

address = request[2]

1998

1679

1999

for c in self.clients.itervalues():

1680

for c in self.clients:

2000

1681

if c.fingerprint == fpr:

2001

1682

client = c

2002

1683

break

2079

1760

elif suffix == "w":

2080

1761

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

2081

1762

else:

2082

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

2083

.format(suffix))

1763

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

2084

1764

except (ValueError, IndexError) as e:

2085

1765

raise ValueError(*(e.args))

2086

1766

timevalue += delta

2087

1767

return timevalue

2088

1768

2089

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

2090

1794

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

2091

1795

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

2092

1796

2100

1804

sys.exit()

2101

1805

if not noclose:

2102

1806

# Close all standard open file descriptors

2103

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

1807

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

2104

1808

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

2105

1809

raise OSError(errno.ENODEV,

2106

"{0} not a character device"

2107

.format(os.devnull))

1810

"%s not a character device"

1811

% os.path.devnull)

2108

1812

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

2109

1813

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

2110

1814

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

2119

1823

2120

1824

parser = argparse.ArgumentParser()

2121

1825

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

2122

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

1826

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

2123

1827

help="show version number and exit")

2124

1828

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

2125

1829

help="Bind to interface IF")

2147

1851

" system bus interface")

2148

1852

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

2149

1853

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

2150

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

2151

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

2152

" state")

2153

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

2154

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

2155

2156

1854

options = parser.parse_args()

2157

1855

2158

1856

if options.check:

2171

1869

"use_dbus": "True",

2172

1870

"use_ipv6": "True",

2173

1871

"debuglevel": "",

2174

"restore": "True",

2175

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

2176

1872

}

2177

1873

2178

1874

# Parse config file for server-global settings

2195

1891

# options, if set.

2196

1892

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

2197

1893

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

2198

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

2199

"statedir"):

1894

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

2200

1895

value = getattr(options, option)

2201

1896

if value is not None:

2202

1897

server_settings[option] = value

2214

1909

debuglevel = server_settings["debuglevel"]

2215

1910

use_dbus = server_settings["use_dbus"]

2216

1911

use_ipv6 = server_settings["use_ipv6"]

2217

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

2218

stored_state_file)

2219

2220

if debug:

2221

initlogger(debug, logging.DEBUG)

2222

else:

2223

if not debuglevel:

2224

initlogger(debug)

2225

else:

2226

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

2227

initlogger(debug, level)

2228

1912

2229

1913

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

2230

1914

syslogger.setFormatter(logging.Formatter

2231

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

2232

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

2233

.format(server_settings

2234

["servicename"])))

1915

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

1916

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

1917

% server_settings["servicename"]))

2235

1918

2236

1919

# Parse config file with clients

2237

client_config = configparser.SafeConfigParser(Client

2238

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

2239

1929

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

2240

1930

"clients.conf"))

2241

1931

2258

1948

except IOError:

2259

1949

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

2260

1950

2261

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:

2262

1955

try:

2263

uid = pwd.getpwnam(name).pw_uid

2264

gid = pwd.getpwnam(name).pw_gid

2265

break

1956

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

1957

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

2266

1958

except KeyError:

2267

continue

2268

else:

2269

uid = 65534

2270

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

2271

1965

try:

2272

1966

os.setgid(gid)

2273

1967

os.setuid(uid)

2275

1969

if error[0] != errno.EPERM:

2276

1970

raise error

2277

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

2278

1980

if debug:

2279

1981

# Enable all possible GnuTLS debugging

2280

1982

2290

1992

.gnutls_global_set_log_function(debug_gnutls))

2291

1993

2292

1994

# Redirect stdin so all checkers get /dev/null

2293

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

1995

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

2294

1996

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

2295

1997

if null > 2:

2296

1998

os.close(null)

1999

else:

2000

# No console logging

2001

logger.removeHandler(console)

2297

2002

2298

2003

# Need to fork before connecting to D-Bus

2299

2004

if not debug:

2300

2005

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

2301

2006

daemon()

2302

2007

2303

gobject.threads_init()

2304

2305

2008

global main_loop

2306

2009

# From the Avahi example code

2307

DBusGMainLoop(set_as_default=True)

2010

DBusGMainLoop(set_as_default=True )

2308

2011

main_loop = gobject.MainLoop()

2309

2012

bus = dbus.SystemBus()

2310

2013

# End of Avahi example code

2321

2024

server_settings["use_dbus"] = False

2322

2025

tcp_server.use_dbus = False

2323

2026

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2324

service = AvahiServiceToSyslog(name =

2325

server_settings["servicename"],

2326

servicetype = "_mandos._tcp",

2327

protocol = protocol, bus = bus)

2027

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

2028

servicetype = "_mandos._tcp",

2029

protocol = protocol, bus = bus)

2328

2030

if server_settings["interface"]:

2329

2031

service.interface = (if_nametoindex

2330

2032

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

2336

2038

if use_dbus:

2337

2039

client_class = functools.partial(ClientDBusTransitional,

2338

2040

bus = bus)

2339

2340

client_settings = Client.config_parser(client_config)

2341

old_client_settings = {}

2342

clients_data = {}

2343

2344

# Get client data and settings from last running state.

2345

if server_settings["restore"]:

2346

try:

2347

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

2348

clients_data, old_client_settings = (pickle.load

2349

(stored_state))

2350

os.remove(stored_state_path)

2351

except IOError as e:

2352

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

2353

.format(e))

2354

if e.errno != errno.ENOENT:

2355

raise

2356

except EOFError as e:

2357

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

2358

"EOFError: {0}".format(e))

2359

2360

with PGPEngine() as pgp:

2361

for client_name, client in clients_data.iteritems():

2362

# Decide which value to use after restoring saved state.

2363

# We have three different values: Old config file,

2364

# new config file, and saved state.

2365

# New config value takes precedence if it differs from old

2366

# config value, otherwise use saved state.

2367

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

2368

try:

2369

# For each value in new config, check if it

2370

# differs from the old config value (Except for

2371

# the "secret" attribute)

2372

if (name != "secret" and

2373

value != old_client_settings[client_name]

2374

[name]):

2375

client[name] = value

2376

except KeyError:

2377

pass

2378

2379

# Clients who has passed its expire date can still be

2380

# enabled if its last checker was successful. Clients

2381

# whose checker succeeded before we stored its state is

2382

# assumed to have successfully run all checkers during

2383

# downtime.

2384

if client["enabled"]:

2385

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

2386

if not client["last_checked_ok"]:

2387

logger.warning(

2388

"disabling client {0} - Client never "

2389

"performed a successful checker"

2390

.format(client_name))

2391

client["enabled"] = False

2392

elif client["last_checker_status"] != 0:

2393

logger.warning(

2394

"disabling client {0} - Client "

2395

"last checker failed with error code {1}"

2396

.format(client_name,

2397

client["last_checker_status"]))

2398

client["enabled"] = False

2399

else:

2400

client["expires"] = (datetime.datetime

2401

.utcnow()

2402

+ client["timeout"])

2403

logger.debug("Last checker succeeded,"

2404

" keeping {0} enabled"

2405

.format(client_name))

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

2406

2048

try:

2407

client["secret"] = (

2408

pgp.decrypt(client["encrypted_secret"],

2409

client_settings[client_name]

2410

["secret"]))

2411

except PGPError:

2412

# If decryption fails, we use secret from new settings

2413

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

2414

.format(client_name))

2415

client["secret"] = (

2416

client_settings[client_name]["secret"])

2417

2418

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

2419

for client_name in (set(old_client_settings)

2420

- set(client_settings)):

2421

del clients_data[client_name]

2422

for client_name in (set(client_settings)

2423

- set(old_client_settings)):

2424

clients_data[client_name] = client_settings[client_name]

2425

2426

# Create all client objects

2427

for client_name, client in clients_data.iteritems():

2428

tcp_server.clients[client_name] = client_class(

2429

name = client_name, settings = client)

2430

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

2431

2058

if not tcp_server.clients:

2432

2059

logger.warning("No clients defined")

2433

2060

2434

2061

if not debug:

2435

2062

try:

2436

2063

with pidfile:

2444

2071

# "pidfile" was never created

2445

2072

pass

2446

2073

del pidfilename

2074

2447

2075

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

2448

2076

2449

2077

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

2450

2078

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

2451

2079

2452

2080

if use_dbus:

2453

class MandosDBusService(DBusObjectWithProperties):

2081

class MandosDBusService(dbus.service.Object):

2454

2082

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

2455

2083

def __init__(self):

2456

2084

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

2457

2085

_interface = "se.recompile.Mandos"

2458

2086

2459

@dbus_interface_annotations(_interface)

2460

def _foo(self):

2461

return { "org.freedesktop.DBus.Property"

2462

".EmitsChangedSignal":

2463

"false"}

2464

2465

2087

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

2466

2088

def ClientAdded(self, objpath):

2467

2089

"D-Bus signal"

2481

2103

def GetAllClients(self):

2482

2104

"D-Bus method"

2483

2105

return dbus.Array(c.dbus_object_path

2484

for c in

2485

tcp_server.clients.itervalues())

2106

for c in tcp_server.clients)

2486

2107

2487

2108

@dbus.service.method(_interface,

2488

2109

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

2490

2111

"D-Bus method"

2491

2112

return dbus.Dictionary(

2492

2113

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

2493

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

2114

for c in tcp_server.clients),

2494

2115

signature="oa{sv}")

2495

2116

2496

2117

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

2497

2118

def RemoveClient(self, object_path):

2498

2119

"D-Bus method"

2499

for c in tcp_server.clients.itervalues():

2120

for c in tcp_server.clients:

2500

2121

if c.dbus_object_path == object_path:

2501

del tcp_server.clients[c.name]

2122

tcp_server.clients.remove(c)

2502

2123

c.remove_from_connection()

2503

2124

# Don't signal anything except ClientRemoved

2504

2125

c.disable(quiet=True)

2518

2139

service.cleanup()

2519

2140

2520

2141

multiprocessing.active_children()

2521

if not (tcp_server.clients or client_settings):

2522

return

2523

2524

# Store client before exiting. Secrets are encrypted with key

2525

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

2526

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

2527

clients = {}

2528

with PGPEngine() as pgp:

2529

for client in tcp_server.clients.itervalues():

2530

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

2531

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

2532

key)

2533

client_dict = {}

2534

2535

# A list of attributes that can not be pickled

2536

# + secret.

2537

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

2538

"checker"))

2539

for name, typ in (inspect.getmembers

2540

(dbus.service.Object)):

2541

exclude.add(name)

2542

2543

client_dict["encrypted_secret"] = (client

2544

.encrypted_secret)

2545

for attr in client.client_structure:

2546

if attr not in exclude:

2547

client_dict[attr] = getattr(client, attr)

2548

2549

clients[client.name] = client_dict

2550

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

2551

2552

try:

2553

tempfd, tempname = tempfile.mkstemp(suffix=".pickle",

2554

prefix="clients-",

2555

dir=os.path.dirname

2556

(stored_state_path))

2557

with os.fdopen(tempfd, "wb") as stored_state:

2558

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

2559

os.rename(tempname, stored_state_path)

2560

except (IOError, OSError) as e:

2561

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

2562

.format(e))

2563

if not debug:

2564

try:

2565

os.remove(tempname)

2566

except NameError:

2567

pass

2568

if e.errno not in set((errno.ENOENT, errno.EACCES,

2569

errno.EEXIST)):

2570

raise e

2571

2572

# Delete all clients, and settings from config

2573

2142

while tcp_server.clients:

2574

name, client = tcp_server.clients.popitem()

2143

client = tcp_server.clients.pop()

2575

2144

if use_dbus:

2576

2145

client.remove_from_connection()

2146

client.disable_hook = None

2577

2147

# Don't signal anything except ClientRemoved

2578

2148

client.disable(quiet=True)

2579

2149

if use_dbus:

2581

2151

mandos_dbus_service.ClientRemoved(client

2582

2152

.dbus_object_path,

2583

2153

client.name)

2584

client_settings.clear()

2585

2154

2586

2155

atexit.register(cleanup)

2587

2156

2588

for client in tcp_server.clients.itervalues():

2157

for client in tcp_server.clients:

2589

2158

if use_dbus:

2590

2159

# Emit D-Bus signal

2591

2160

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2592

# Need to initiate checking of clients

2593

if client.enabled:

2594

client.init_checker()

2161

client.enable()

2595

2162

2596

2163

tcp_server.enable()

2597

2164

tcp_server.server_activate()

2600

2167

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

2601

2168

if use_ipv6:

2602

2169

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

2603

" flowinfo %d, scope_id %d",

2604

*tcp_server.socket.getsockname())

2170

" flowinfo %d, scope_id %d"

2171

% tcp_server.socket.getsockname())

2605

2172

else: # IPv4

2606

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

2607

*tcp_server.socket.getsockname())

2173

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

2174

% tcp_server.socket.getsockname())

2608

2175

2609

2176

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

2610

2177

2613

2180

try:

2614

2181

service.activate()

2615

2182

except dbus.exceptions.DBusException as error:

2616

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

2183

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

2617

2184

cleanup()

2618

2185

sys.exit(1)

2619

2186

# End of Avahi example code

2626

2193

logger.debug("Starting main loop")

2627

2194

main_loop.run()

2628

2195

except AvahiError as error:

2629

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

2196

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

2630

2197

cleanup()

2631

2198

sys.exit(1)

2632

2199

except KeyboardInterrupt:

2637

2204

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

2638

2205

cleanup()

2639

2206

2207

2640

2208

if __name__ == '__main__':

2641

2209

main()