/mandos/trunk : revision 482

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

28

# along with this program. If not, see

29

# <http://www.gnu.org/licenses/>.

30

#

31

# Contact the authors at <mandos@recompile.se>.

31

# Contact the authors at <mandos@fukt.bsnet.se>.

32

#

33

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

64

62

import functools

65

63

import cPickle as pickle

66

64

import multiprocessing

67

import types

68

import binascii

69

import tempfile

70

import itertools

71

65

72

66

import dbus

73

67

import dbus.service

78

72

import ctypes.util

79

73

import xml.dom.minidom

80

74

import inspect

81

import GnuPGInterface

82

75

83

76

try:

84

77

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

88

81

except ImportError:

89

82

SO_BINDTODEVICE = None

90

83

91

version = "1.5.3"

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

84

85

version = "1.3.0"

86

87

#logger = logging.getLogger('mandos')

88

logger = logging.Logger('mandos')

95

89

syslogger = (logging.handlers.SysLogHandler

96

90

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

97

91

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

98

99

try:

100

if_nametoindex = (ctypes.cdll.LoadLibrary

101

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

102

.if_nametoindex)

103

except (OSError, AttributeError):

104

def if_nametoindex(interface):

105

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

106

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

107

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

108

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

109

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

110

interface))

111

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

112

ifreq[16:20])[0]

113

return interface_index

114

115

116

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

117

"""init logger and add loglevel"""

118

119

syslogger.setFormatter(logging.Formatter

120

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

121

' %(message)s'))

122

logger.addHandler(syslogger)

123

124

if debug:

125

console = logging.StreamHandler()

126

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

127

' [%(process)d]:'

128

' %(levelname)s:'

129

' %(message)s'))

130

logger.addHandler(console)

131

logger.setLevel(level)

132

133

134

class PGPError(Exception):

135

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

136

pass

137

138

139

class PGPEngine(object):

140

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

141

def __init__(self):

142

self.gnupg = GnuPGInterface.GnuPG()

143

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

144

self.gnupg = GnuPGInterface.GnuPG()

145

self.gnupg.options.meta_interactive = False

146

self.gnupg.options.homedir = self.tempdir

147

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

148

'--quiet',

149

'--no-use-agent'])

150

151

def __enter__(self):

152

return self

153

154

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

155

self._cleanup()

156

return False

157

158

def __del__(self):

159

self._cleanup()

160

161

def _cleanup(self):

162

if self.tempdir is not None:

163

# Delete contents of tempdir

164

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

165

topdown = False):

166

for filename in files:

167

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

168

for dirname in dirs:

169

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

170

# Remove tempdir

171

os.rmdir(self.tempdir)

172

self.tempdir = None

173

174

def password_encode(self, password):

175

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

176

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

177

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

178

179

def encrypt(self, data, password):

180

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

181

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

182

try:

183

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

184

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

185

attach_fhs={'stderr': devnull})

186

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

187

f.write(data)

188

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

189

ciphertext = f.read()

190

proc.wait()

191

except IOError as e:

192

raise PGPError(e)

193

self.gnupg.passphrase = None

194

return ciphertext

195

196

def decrypt(self, data, password):

197

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

198

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

199

try:

200

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

201

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

202

attach_fhs={'stderr': devnull})

203

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

204

f.write(data)

205

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

206

decrypted_plaintext = f.read()

207

proc.wait()

208

except IOError as e:

209

raise PGPError(e)

210

self.gnupg.passphrase = None

211

return decrypted_plaintext

212

92

syslogger.setFormatter(logging.Formatter

93

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

94

' %(message)s'))

95

logger.addHandler(syslogger)

96

97

console = logging.StreamHandler()

98

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

99

' %(levelname)s:'

100

' %(message)s'))

101

logger.addHandler(console)

213

102

214

103

class AvahiError(Exception):

215

104

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

245

134

server: D-Bus Server

246

135

bus: dbus.SystemBus()

247

136

"""

248

249

137

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

250

138

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

251

139

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

264

152

self.server = None

265

153

self.bus = bus

266

154

self.entry_group_state_changed_match = None

267

268

155

def rename(self):

269

156

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

270

157

if self.rename_count >= self.max_renames:

272

159

" after %i retries, exiting.",

273

160

self.rename_count)

274

161

raise AvahiServiceError("Too many renames")

275

self.name = unicode(self.server

276

.GetAlternativeServiceName(self.name))

162

self.name = unicode(self.server.GetAlternativeServiceName(self.name))

277

163

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

278

164

self.name)

165

syslogger.setFormatter(logging.Formatter

166

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

167

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

168

% self.name))

279

169

self.remove()

280

170

try:

281

171

self.add()

282

172

except dbus.exceptions.DBusException as error:

283

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

173

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

284

174

self.cleanup()

285

175

os._exit(1)

286

176

self.rename_count += 1

287

288

177

def remove(self):

289

178

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

179

if self.group is not None:

180

try:

181

self.group.Free()

182

except (dbus.exceptions.UnknownMethodException,

183

dbus.exceptions.DBusException) as e:

184

pass

185

self.group = None

290

186

if self.entry_group_state_changed_match is not None:

291

187

self.entry_group_state_changed_match.remove()

292

188

self.entry_group_state_changed_match = None

293

if self.group is not None:

294

self.group.Reset()

295

296

189

def add(self):

297

190

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

298

191

self.remove()

299

if self.group is None:

300

self.group = dbus.Interface(

301

self.bus.get_object(avahi.DBUS_NAME,

302

self.server.EntryGroupNew()),

303

avahi.DBUS_INTERFACE_ENTRY_GROUP)

192

self.group = dbus.Interface(

193

self.bus.get_object(avahi.DBUS_NAME,

194

self.server.EntryGroupNew(),

195

follow_name_owner_changes=True),

196

avahi.DBUS_INTERFACE_ENTRY_GROUP)

304

197

self.entry_group_state_changed_match = (

305

198

self.group.connect_to_signal(

306

'StateChanged', self.entry_group_state_changed))

199

'StateChanged', self .entry_group_state_changed))

307

200

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

308

201

self.name, self.type)

309

202

self.group.AddService(

315

208

dbus.UInt16(self.port),

316

209

avahi.string_array_to_txt_array(self.TXT))

317

210

self.group.Commit()

318

319

211

def entry_group_state_changed(self, state, error):

320

212

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

321

213

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

328

220

elif state == avahi.ENTRY_GROUP_FAILURE:

329

221

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

330

222

unicode(error))

331

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

332

.format(error))

333

223

raise AvahiGroupError("State changed: %s"

224

% unicode(error))

334

225

def cleanup(self):

335

226

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

336

if self.group is not None:

337

try:

338

self.group.Free()

339

except (dbus.exceptions.UnknownMethodException,

340

dbus.exceptions.DBusException):

341

pass

342

self.group = None

343

227

self.remove()

344

345

228

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

346

229

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

347

230

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

353

236

avahi.SERVER_FAILURE:

354

237

"Zeroconf server failure" }

355

238

if state in bad_states:

356

if bad_states[state] is not None:

357

if error is None:

358

logger.error(bad_states[state])

359

else:

360

logger.error(bad_states[state] + ": %r", error)

361

self.cleanup()

239

if bad_states[state]:

240

logger.error(bad_states[state])

241

self.remove()

362

242

elif state == avahi.SERVER_RUNNING:

363

243

self.add()

364

244

else:

365

if error is None:

366

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

367

else:

368

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

369

245

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

370

246

def activate(self):

371

247

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

372

248

if self.server is None:

379

255

self.server_state_changed)

380

256

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

381

257

382

class AvahiServiceToSyslog(AvahiService):

383

def rename(self):

384

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

385

ret = AvahiService.rename(self)

386

syslogger.setFormatter(logging.Formatter

387

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

388

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

389

.format(self.name)))

390

return ret

391

392

def timedelta_to_milliseconds(td):

393

"Convert a datetime.timedelta() to milliseconds"

394

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

395

+ (td.seconds * 1000)

396

+ (td.microseconds // 1000))

397

258

398

259

class Client(object):

399

260

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

400

261

401

262

Attributes:

402

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

263

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

403

264

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

404

265

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

405

266

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

412

273

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

413

274

checker_initiator_tag: a gobject event source tag, or None

414

275

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

415

client_structure: Object describing what attributes a client has

416

and is used for storing the client at exit

417

276

current_checker_command: string; current running checker_command

277

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

418

278

disable_initiator_tag: a gobject event source tag, or None

419

279

enabled: bool()

420

280

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

423

283

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

424

284

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

425

285

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

426

last_checker_status: integer between 0 and 255 reflecting exit

427

status of last checker. -1 reflects crashed

428

checker, -2 means no checker completed yet.

429

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

286

last_enabled: datetime.datetime(); (UTC)

430

287

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

431

288

D-Bus identifiers

432

289

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

433

290

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

434

291

until this client is disabled

435

extended_timeout: extra long timeout when secret has been sent

436

292

runtime_expansions: Allowed attributes for runtime expansion.

437

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

438

disabled, or None

439

293

"""

440

294

441

295

runtime_expansions = ("approval_delay", "approval_duration",

442

296

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

443

297

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

444

298

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

445

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

446

"extended_timeout": "15m",

447

"interval": "2m",

448

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

449

"host": "",

450

"approval_delay": "0s",

451

"approval_duration": "1s",

452

"approved_by_default": "True",

453

"enabled": "True",

454

}

299

300

@staticmethod

301

def _timedelta_to_milliseconds(td):

302

"Convert a datetime.timedelta() to milliseconds"

303

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

304

+ (td.seconds * 1000)

305

+ (td.microseconds // 1000))

455

306

456

307

def timeout_milliseconds(self):

457

308

"Return the 'timeout' attribute in milliseconds"

458

return timedelta_to_milliseconds(self.timeout)

459

460

def extended_timeout_milliseconds(self):

461

"Return the 'extended_timeout' attribute in milliseconds"

462

return timedelta_to_milliseconds(self.extended_timeout)

309

return self._timedelta_to_milliseconds(self.timeout)

463

310

464

311

def interval_milliseconds(self):

465

312

"Return the 'interval' attribute in milliseconds"

466

return timedelta_to_milliseconds(self.interval)

467

313

return self._timedelta_to_milliseconds(self.interval)

314

468

315

def approval_delay_milliseconds(self):

469

return timedelta_to_milliseconds(self.approval_delay)

470

471

@staticmethod

472

def config_parser(config):

473

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

474

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

475

with exceptions for any special settings as defined above.

476

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

477

value given the same arguments.

478

"""

479

settings = {}

480

for client_name in config.sections():

481

section = dict(config.items(client_name))

482

client = settings[client_name] = {}

483

484

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

485

# Reformat values from string types to Python types

486

client["approved_by_default"] = config.getboolean(

487

client_name, "approved_by_default")

488

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

489

"enabled")

490

491

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

492

.replace(" ", ""))

493

if "secret" in section:

494

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

495

elif "secfile" in section:

496

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

497

(section["secfile"])),

498

"rb") as secfile:

499

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

500

else:

501

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

502

.format(section))

503

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

504

client["extended_timeout"] = string_to_delta(

505

section["extended_timeout"])

506

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

507

client["approval_delay"] = string_to_delta(

508

section["approval_delay"])

509

client["approval_duration"] = string_to_delta(

510

section["approval_duration"])

511

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

512

client["last_approval_request"] = None

513

client["last_checked_ok"] = None

514

client["last_checker_status"] = -2

515

516

return settings

517

518

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

316

return self._timedelta_to_milliseconds(self.approval_delay)

317

318

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

319

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

320

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

321

attribute."""

519

322

self.name = name

520

# adding all client settings

521

for setting, value in settings.iteritems():

522

setattr(self, setting, value)

523

524

if self.enabled:

525

if not hasattr(self, "last_enabled"):

526

self.last_enabled = datetime.datetime.utcnow()

527

if not hasattr(self, "expires"):

528

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

529

+ self.timeout)

530

else:

531

self.last_enabled = None

532

self.expires = None

533

323

if config is None:

324

config = {}

534

325

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

535

326

# Uppercase and remove spaces from fingerprint for later

536

327

# comparison purposes with return value from the fingerprint()

537

328

# function

329

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

330

.replace(" ", ""))

538

331

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

539

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

540

datetime.datetime.utcnow())

541

542

# attributes specific for this server instance

332

if "secret" in config:

333

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

334

elif "secfile" in config:

335

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

336

(config["secfile"])),

337

"rb") as secfile:

338

self.secret = secfile.read()

339

else:

340

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

341

% self.name)

342

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

343

self.created = datetime.datetime.utcnow()

344

self.enabled = False

345

self.last_approval_request = None

346

self.last_enabled = None

347

self.last_checked_ok = None

348

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

349

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

350

self.disable_hook = disable_hook

543

351

self.checker = None

544

352

self.checker_initiator_tag = None

545

353

self.disable_initiator_tag = None

546

354

self.checker_callback_tag = None

355

self.checker_command = config["checker"]

547

356

self.current_checker_command = None

548

self.approved = None

357

self.last_connect = None

358

self._approved = None

359

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

360

True)

549

361

self.approvals_pending = 0

550

self.changedstate = (multiprocessing_manager

551

.Condition(multiprocessing_manager

552

.Lock()))

553

self.client_structure = [attr for attr in

554

self.__dict__.iterkeys()

555

if not attr.startswith("_")]

556

self.client_structure.append("client_structure")

557

558

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

559

lambda obj:

560

isinstance(obj,

561

property)):

562

if not name.startswith("_"):

563

self.client_structure.append(name)

362

self.approval_delay = string_to_delta(

363

config["approval_delay"])

364

self.approval_duration = string_to_delta(

365

config["approval_duration"])

366

self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())

564

367

565

# Send notice to process children that client state has changed

566

368

def send_changedstate(self):

567

with self.changedstate:

568

self.changedstate.notify_all()

569

369

self.changedstate.acquire()

370

self.changedstate.notify_all()

371

self.changedstate.release()

372

570

373

def enable(self):

571

374

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

572

375

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

573

376

# Already enabled

574

377

return

575

378

self.send_changedstate()

576

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

577

self.enabled = True

578

379

self.last_enabled = datetime.datetime.utcnow()

579

self.init_checker()

380

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

381

# and every interval from then on.

382

self.checker_initiator_tag = (gobject.timeout_add

383

(self.interval_milliseconds(),

384

self.start_checker))

385

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

386

self.disable_initiator_tag = (gobject.timeout_add

387

(self.timeout_milliseconds(),

388

self.disable))

389

self.enabled = True

390

# Also start a new checker *right now*.

391

self.start_checker()

580

392

581

393

def disable(self, quiet=True):

582

394

"""Disable this client."""

589

401

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

590

402

gobject.source_remove(self.disable_initiator_tag)

591

403

self.disable_initiator_tag = None

592

self.expires = None

593

404

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

594

405

gobject.source_remove(self.checker_initiator_tag)

595

406

self.checker_initiator_tag = None

596

407

self.stop_checker()

408

if self.disable_hook:

409

self.disable_hook(self)

597

410

self.enabled = False

598

411

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

599

412

return False

600

413

601

414

def __del__(self):

415

self.disable_hook = None

602

416

self.disable()

603

417

604

def init_checker(self):

605

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

606

# and every interval from then on.

607

self.checker_initiator_tag = (gobject.timeout_add

608

(self.interval_milliseconds(),

609

self.start_checker))

610

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

611

self.disable_initiator_tag = (gobject.timeout_add

612

(self.timeout_milliseconds(),

613

self.disable))

614

# Also start a new checker *right now*.

615

self.start_checker()

616

617

418

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

618

419

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

619

420

self.checker_callback_tag = None

620

421

self.checker = None

621

422

if os.WIFEXITED(condition):

622

self.last_checker_status = os.WEXITSTATUS(condition)

623

if self.last_checker_status == 0:

423

exitstatus = os.WEXITSTATUS(condition)

424

if exitstatus == 0:

624

425

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

625

426

vars(self))

626

427

self.checked_ok()

628

429

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

629

430

vars(self))

630

431

else:

631

self.last_checker_status = -1

632

432

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

633

433

vars(self))

634

434

635

435

def checked_ok(self):

636

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

436

"""Bump up the timeout for this client.

437

438

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

439

alive and well.

440

"""

637

441

self.last_checked_ok = datetime.datetime.utcnow()

638

self.last_checker_status = 0

639

self.bump_timeout()

640

641

def bump_timeout(self, timeout=None):

642

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

643

if timeout is None:

644

timeout = self.timeout

645

if self.disable_initiator_tag is not None:

646

gobject.source_remove(self.disable_initiator_tag)

647

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

648

self.disable_initiator_tag = (gobject.timeout_add

649

(timedelta_to_milliseconds

650

(timeout), self.disable))

651

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

442

gobject.source_remove(self.disable_initiator_tag)

443

self.disable_initiator_tag = (gobject.timeout_add

444

(self.timeout_milliseconds(),

445

self.disable))

652

446

653

447

def need_approval(self):

654

448

self.last_approval_request = datetime.datetime.utcnow()

659

453

If a checker already exists, leave it running and do

660

454

nothing."""

661

455

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

662

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

663

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

664

# would inevitably timeout, since no checker would get a

665

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

456

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

457

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

458

# client would inevitably timeout, since no checker would get

459

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

666

460

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

667

461

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

668

462

# should be.

694

488

'replace')))

695

489

for attr in

696

490

self.runtime_expansions)

697

491

698

492

try:

699

493

command = self.checker_command % escaped_attrs

700

494

except TypeError as error:

701

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

702

self.checker_command, exc_info=error)

495

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

496

' %s', self.checker_command, error)

703

497

return True # Try again later

704

498

self.current_checker_command = command

705

499

try:

723

517

gobject.source_remove(self.checker_callback_tag)

724

518

self.checker_callback(pid, status, command)

725

519

except OSError as error:

726

logger.error("Failed to start subprocess",

727

exc_info=error)

520

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

521

error)

728

522

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

729

523

return True

730

524

737

531

return

738

532

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

739

533

try:

740

self.checker.terminate()

534

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

741

535

#time.sleep(0.5)

742

536

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

743

# self.checker.kill()

537

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

744

538

except OSError as error:

745

539

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

746

540

raise

747

541

self.checker = None

748

542

749

750

543

def dbus_service_property(dbus_interface, signature="v",

751

544

access="readwrite", byte_arrays=False):

752

545

"""Decorators for marking methods of a DBusObjectWithProperties to

763

556

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

764

557

if byte_arrays and signature != "ay":

765

558

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

766

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

559

" signature %r" % signature)

767

560

def decorator(func):

768

561

func._dbus_is_property = True

769

562

func._dbus_interface = dbus_interface

777

570

return decorator

778

571

779

572

780

def dbus_interface_annotations(dbus_interface):

781

"""Decorator for marking functions returning interface annotations

782

783

Usage:

784

785

@dbus_interface_annotations("org.example.Interface")

786

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

787

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

788

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

789

"false"}

790

"""

791

def decorator(func):

792

func._dbus_is_interface = True

793

func._dbus_interface = dbus_interface

794

func._dbus_name = dbus_interface

795

return func

796

return decorator

797

798

799

def dbus_annotations(annotations):

800

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

801

Usage:

802

803

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

804

access="r")

805

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

806

"org.freedesktop.DBus.Property."

807

"EmitsChangedSignal": "false"})

808

def Property_dbus_property(self):

809

return dbus.Boolean(False)

810

"""

811

def decorator(func):

812

func._dbus_annotations = annotations

813

return func

814

return decorator

815

816

817

573

class DBusPropertyException(dbus.exceptions.DBusException):

818

574

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

819

575

"""

835

591

836

592

class DBusObjectWithProperties(dbus.service.Object):

837

593

"""A D-Bus object with properties.

838

594

839

595

Classes inheriting from this can use the dbus_service_property

840

596

decorator to expose methods as D-Bus properties. It exposes the

841

597

standard Get(), Set(), and GetAll() methods on the D-Bus.

842

598

"""

843

599

844

600

@staticmethod

845

def _is_dbus_thing(thing):

846

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

847

848

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

849

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

850

"""

851

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

852

False)

601

def _is_dbus_property(obj):

602

return getattr(obj, "_dbus_is_property", False)

853

603

854

def _get_all_dbus_things(self, thing):

604

def _get_all_dbus_properties(self):

855

605

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

856

606

"""

857

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

858

name),

859

athing.__get__(self))

860

for cls in self.__class__.__mro__

861

for name, athing in

862

inspect.getmembers(cls,

863

self._is_dbus_thing(thing)))

607

return ((prop._dbus_name, prop)

608

for name, prop in

609

inspect.getmembers(self, self._is_dbus_property))

864

610

865

611

def _get_dbus_property(self, interface_name, property_name):

866

612

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

867

613

property with the specified name and interface.

868

614

"""

869

for cls in self.__class__.__mro__:

870

for name, value in (inspect.getmembers

871

(cls,

872

self._is_dbus_thing("property"))):

873

if (value._dbus_name == property_name

874

and value._dbus_interface == interface_name):

875

return value.__get__(self)

876

615

for name in (property_name,

616

property_name + "_dbus_property"):

617

prop = getattr(self, name, None)

618

if (prop is None

619

or not self._is_dbus_property(prop)

620

or prop._dbus_name != property_name

621

or (interface_name and prop._dbus_interface

622

and interface_name != prop._dbus_interface)):

623

continue

624

return prop

877

625

# No such property

878

626

raise DBusPropertyNotFound(self.dbus_object_path + ":"

879

627

+ interface_name + "."

904

652

# signatures other than "ay".

905

653

if prop._dbus_signature != "ay":

906

654

raise ValueError

907

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

908

for byte in value))

655

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

656

for byte in value))

909

657

prop(value)

910

658

911

659

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

913

661

def GetAll(self, interface_name):

914

662

"""Standard D-Bus property GetAll() method, see D-Bus

915

663

standard.

916

664

917

665

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

918

666

"""

919

properties = {}

920

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

667

all = {}

668

for name, prop in self._get_all_dbus_properties():

921

669

if (interface_name

922

670

and interface_name != prop._dbus_interface):

923

671

# Interface non-empty but did not match

927

675

continue

928

676

value = prop()

929

677

if not hasattr(value, "variant_level"):

930

properties[name] = value

678

all[name] = value

931

679

continue

932

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

933

value.variant_level+1)

934

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

680

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

681

value.variant_level+1)

682

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

935

683

936

684

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

937

685

out_signature="s",

938

686

path_keyword='object_path',

939

687

connection_keyword='connection')

940

688

def Introspect(self, object_path, connection):

941

"""Overloading of standard D-Bus method.

942

943

Inserts property tags and interface annotation tags.

689

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

944

690

"""

945

691

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

946

692

connection)

953

699

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

954

700

return e

955

701

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

956

# Add property tags

957

702

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

958

703

for name, prop

959

in self._get_all_dbus_things("property")

704

in self._get_all_dbus_properties()

960

705

if prop._dbus_interface

961

706

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

962

707

if_tag.appendChild(tag)

963

# Add annotation tags

964

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

965

for tag in if_tag.getElementsByTagName(typ):

966

annots = dict()

967

for name, prop in (self.

968

_get_all_dbus_things(typ)):

969

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

970

and prop._dbus_interface

971

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

972

annots.update(getattr

973

(prop,

974

"_dbus_annotations",

975

{}))

976

for name, value in annots.iteritems():

977

ann_tag = document.createElement(

978

"annotation")

979

ann_tag.setAttribute("name", name)

980

ann_tag.setAttribute("value", value)

981

tag.appendChild(ann_tag)

982

# Add interface annotation tags

983

for annotation, value in dict(

984

itertools.chain.from_iterable(

985

annotations().iteritems()

986

for name, annotations in

987

self._get_all_dbus_things("interface")

988

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

989

)).iteritems():

990

ann_tag = document.createElement("annotation")

991

ann_tag.setAttribute("name", annotation)

992

ann_tag.setAttribute("value", value)

993

if_tag.appendChild(ann_tag)

994

708

# Add the names to the return values for the

995

709

# "org.freedesktop.DBus.Properties" methods

996

710

if (if_tag.getAttribute("name")

1011

725

except (AttributeError, xml.dom.DOMException,

1012

726

xml.parsers.expat.ExpatError) as error:

1013

727

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

1014

exc_info=error)

728

error)

1015

729

return xmlstring

1016

730

1017

731

1018

def datetime_to_dbus (dt, variant_level=0):

1019

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

1020

if dt is None:

1021

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

1022

return dbus.String(dt.isoformat(),

1023

variant_level=variant_level)

1024

1025

1026

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1027

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

1028

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

1029

interface names according to the "alt_interface_names" mapping.

1030

Usage:

1031

1032

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

1033

"net.example.AlternateInterface"})

1034

class SampleDBusObject(dbus.service.Object):

1035

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

1036

def SampleDBusMethod():

1037

pass

1038

1039

The above "SampleDBusMethod" on "SampleDBusObject" will be

1040

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

1041

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

1042

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

1043

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

1044

1045

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

1046

(from DBusObjectWithProperties) and interfaces (from the

1047

dbus_interface_annotations decorator).

1048

"""

1049

def wrapper(cls):

1050

for orig_interface_name, alt_interface_name in (

1051

alt_interface_names.iteritems()):

1052

attr = {}

1053

interface_names = set()

1054

# Go though all attributes of the class

1055

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

1056

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

1057

# with the wrong interface name

1058

if (not hasattr(attribute, "_dbus_interface")

1059

or not attribute._dbus_interface

1060

.startswith(orig_interface_name)):

1061

continue

1062

# Create an alternate D-Bus interface name based on

1063

# the current name

1064

alt_interface = (attribute._dbus_interface

1065

.replace(orig_interface_name,

1066

alt_interface_name))

1067

interface_names.add(alt_interface)

1068

# Is this a D-Bus signal?

1069

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

1070

# Extract the original non-method function by

1071

# black magic

1072

nonmethod_func = (dict(

1073

zip(attribute.func_code.co_freevars,

1074

attribute.__closure__))["func"]

1075

.cell_contents)

1076

# Create a new, but exactly alike, function

1077

# object, and decorate it to be a new D-Bus signal

1078

# with the alternate D-Bus interface name

1079

new_function = (dbus.service.signal

1080

(alt_interface,

1081

attribute._dbus_signature)

1082

(types.FunctionType(

1083

nonmethod_func.func_code,

1084

nonmethod_func.func_globals,

1085

nonmethod_func.func_name,

1086

nonmethod_func.func_defaults,

1087

nonmethod_func.func_closure)))

1088

# Copy annotations, if any

1089

try:

1090

new_function._dbus_annotations = (

1091

dict(attribute._dbus_annotations))

1092

except AttributeError:

1093

pass

1094

# Define a creator of a function to call both the

1095

# original and alternate functions, so both the

1096

# original and alternate signals gets sent when

1097

# the function is called

1098

def fixscope(func1, func2):

1099

"""This function is a scope container to pass

1100

func1 and func2 to the "call_both" function

1101

outside of its arguments"""

1102

def call_both(*args, **kwargs):

1103

"""This function will emit two D-Bus

1104

signals by calling func1 and func2"""

1105

func1(*args, **kwargs)

1106

func2(*args, **kwargs)

1107

return call_both

1108

# Create the "call_both" function and add it to

1109

# the class

1110

attr[attrname] = fixscope(attribute, new_function)

1111

# Is this a D-Bus method?

1112

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

1113

# Create a new, but exactly alike, function

1114

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

1115

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

1116

# to the class.

1117

attr[attrname] = (dbus.service.method

1118

(alt_interface,

1119

attribute._dbus_in_signature,

1120

attribute._dbus_out_signature)

1121

(types.FunctionType

1122

(attribute.func_code,

1123

attribute.func_globals,

1124

attribute.func_name,

1125

attribute.func_defaults,

1126

attribute.func_closure)))

1127

# Copy annotations, if any

1128

try:

1129

attr[attrname]._dbus_annotations = (

1130

dict(attribute._dbus_annotations))

1131

except AttributeError:

1132

pass

1133

# Is this a D-Bus property?

1134

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

1135

# Create a new, but exactly alike, function

1136

# object, and decorate it to be a new D-Bus

1137

# property with the alternate D-Bus interface

1138

# name. Add it to the class.

1139

attr[attrname] = (dbus_service_property

1140

(alt_interface,

1141

attribute._dbus_signature,

1142

attribute._dbus_access,

1143

attribute

1144

._dbus_get_args_options

1145

["byte_arrays"])

1146

(types.FunctionType

1147

(attribute.func_code,

1148

attribute.func_globals,

1149

attribute.func_name,

1150

attribute.func_defaults,

1151

attribute.func_closure)))

1152

# Copy annotations, if any

1153

try:

1154

attr[attrname]._dbus_annotations = (

1155

dict(attribute._dbus_annotations))

1156

except AttributeError:

1157

pass

1158

# Is this a D-Bus interface?

1159

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

1160

# Create a new, but exactly alike, function

1161

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

1162

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

1163

# to the class.

1164

attr[attrname] = (dbus_interface_annotations

1165

(alt_interface)

1166

(types.FunctionType

1167

(attribute.func_code,

1168

attribute.func_globals,

1169

attribute.func_name,

1170

attribute.func_defaults,

1171

attribute.func_closure)))

1172

if deprecate:

1173

# Deprecate all alternate interfaces

1174

iname="_AlternateDBusNames_interface_annotation{0}"

1175

for interface_name in interface_names:

1176

@dbus_interface_annotations(interface_name)

1177

def func(self):

1178

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

1179

"true" }

1180

# Find an unused name

1181

for aname in (iname.format(i)

1182

for i in itertools.count()):

1183

if aname not in attr:

1184

attr[aname] = func

1185

break

1186

if interface_names:

1187

# Replace the class with a new subclass of it with

1188

# methods, signals, etc. as created above.

1189

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

1190

(cls,), attr)

1191

return cls

1192

return wrapper

1193

1194

1195

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

1196

"se.bsnet.fukt.Mandos"})

1197

732

class ClientDBus(Client, DBusObjectWithProperties):

1198

733

"""A Client class using D-Bus

1199

734

1208

743

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

1209

744

1210

745

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

746

self._approvals_pending = 0

1211

747

self.bus = bus

1212

748

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

1213

749

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

1219

755

("/clients/" + client_object_name))

1220

756

DBusObjectWithProperties.__init__(self, self.bus,

1221

757

self.dbus_object_path)

1222

1223

def notifychangeproperty(transform_func,

1224

dbus_name, type_func=lambda x: x,

1225

variant_level=1):

1226

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

1227

its changes to DBus.

1228

1229

transform_fun: Function that takes a value and a variant_level

1230

and transforms it to a D-Bus type.

1231

dbus_name: D-Bus name of the variable

1232

type_func: Function that transform the value before sending it

1233

to the D-Bus. Default: no transform

1234

variant_level: D-Bus variant level. Default: 1

1235

"""

1236

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

1237

def setter(self, value):

1238

if hasattr(self, "dbus_object_path"):

1239

if (not hasattr(self, attrname) or

1240

type_func(getattr(self, attrname, None))

1241

!= type_func(value)):

1242

dbus_value = transform_func(type_func(value),

1243

variant_level

1244

=variant_level)

1245

self.PropertyChanged(dbus.String(dbus_name),

1246

dbus_value)

1247

setattr(self, attrname, value)

1248

1249

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

1250

1251

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1252

approvals_pending = notifychangeproperty(dbus.Boolean,

1253

"ApprovalPending",

1254

type_func = bool)

1255

enabled = notifychangeproperty(dbus.Boolean, "Enabled")

1256

last_enabled = notifychangeproperty(datetime_to_dbus,

1257

"LastEnabled")

1258

checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",

1259

type_func = lambda checker:

1260

checker is not None)

1261

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1262

"LastCheckedOK")

1263

last_checker_status = notifychangeproperty(dbus.Int16,

1264

"LastCheckerStatus")

1265

last_approval_request = notifychangeproperty(

1266

datetime_to_dbus, "LastApprovalRequest")

1267

approved_by_default = notifychangeproperty(dbus.Boolean,

1268

"ApprovedByDefault")

1269

approval_delay = notifychangeproperty(dbus.UInt64,

1270

"ApprovalDelay",

1271

type_func =

1272

timedelta_to_milliseconds)

1273

approval_duration = notifychangeproperty(

1274

dbus.UInt64, "ApprovalDuration",

1275

type_func = timedelta_to_milliseconds)

1276

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

1277

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

1278

type_func =

1279

timedelta_to_milliseconds)

1280

extended_timeout = notifychangeproperty(

1281

dbus.UInt64, "ExtendedTimeout",

1282

type_func = timedelta_to_milliseconds)

1283

interval = notifychangeproperty(dbus.UInt64,

1284

"Interval",

1285

type_func =

1286

timedelta_to_milliseconds)

1287

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

1288

1289

del notifychangeproperty

758

759

def _get_approvals_pending(self):

760

return self._approvals_pending

761

def _set_approvals_pending(self, value):

762

old_value = self._approvals_pending

763

self._approvals_pending = value

764

bval = bool(value)

765

if (hasattr(self, "dbus_object_path")

766

and bval is not bool(old_value)):

767

dbus_bool = dbus.Boolean(bval, variant_level=1)

768

self.PropertyChanged(dbus.String("ApprovalPending"),

769

dbus_bool)

770

771

approvals_pending = property(_get_approvals_pending,

772

_set_approvals_pending)

773

del _get_approvals_pending, _set_approvals_pending

774

775

@staticmethod

776

def _datetime_to_dbus(dt, variant_level=0):

777

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

778

return dbus.String(dt.isoformat(),

779

variant_level=variant_level)

780

781

def enable(self):

782

oldstate = getattr(self, "enabled", False)

783

r = Client.enable(self)

784

if oldstate != self.enabled:

785

# Emit D-Bus signals

786

self.PropertyChanged(dbus.String("Enabled"),

787

dbus.Boolean(True, variant_level=1))

788

self.PropertyChanged(

789

dbus.String("LastEnabled"),

790

self._datetime_to_dbus(self.last_enabled,

791

variant_level=1))

792

return r

793

794

def disable(self, quiet = False):

795

oldstate = getattr(self, "enabled", False)

796

r = Client.disable(self, quiet=quiet)

797

if not quiet and oldstate != self.enabled:

798

# Emit D-Bus signal

799

self.PropertyChanged(dbus.String("Enabled"),

800

dbus.Boolean(False, variant_level=1))

801

return r

1290

802

1291

803

def __del__(self, *args, **kwargs):

1292

804

try:

1301

813

*args, **kwargs):

1302

814

self.checker_callback_tag = None

1303

815

self.checker = None

816

# Emit D-Bus signal

817

self.PropertyChanged(dbus.String("CheckerRunning"),

818

dbus.Boolean(False, variant_level=1))

1304

819

if os.WIFEXITED(condition):

1305

820

exitstatus = os.WEXITSTATUS(condition)

1306

821

# Emit D-Bus signal

1316

831

return Client.checker_callback(self, pid, condition, command,

1317

832

*args, **kwargs)

1318

833

834

def checked_ok(self, *args, **kwargs):

835

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

836

# Emit D-Bus signal

837

self.PropertyChanged(

838

dbus.String("LastCheckedOK"),

839

(self._datetime_to_dbus(self.last_checked_ok,

840

variant_level=1)))

841

842

def need_approval(self, *args, **kwargs):

843

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

844

# Emit D-Bus signal

845

self.PropertyChanged(

846

dbus.String("LastApprovalRequest"),

847

(self._datetime_to_dbus(self.last_approval_request,

848

variant_level=1)))

849

return r

850

1319

851

def start_checker(self, *args, **kwargs):

1320

852

old_checker = self.checker

1321

853

if self.checker is not None:

1328

860

and old_checker_pid != self.checker.pid):

1329

861

# Emit D-Bus signal

1330

862

self.CheckerStarted(self.current_checker_command)

863

self.PropertyChanged(

864

dbus.String("CheckerRunning"),

865

dbus.Boolean(True, variant_level=1))

1331

866

return r

1332

867

868

def stop_checker(self, *args, **kwargs):

869

old_checker = getattr(self, "checker", None)

870

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

871

if (old_checker is not None

872

and getattr(self, "checker", None) is None):

873

self.PropertyChanged(dbus.String("CheckerRunning"),

874

dbus.Boolean(False, variant_level=1))

875

return r

876

1333

877

def _reset_approved(self):

1334

self.approved = None

878

self._approved = None

1335

879

return False

1336

880

1337

881

def approve(self, value=True):

1338

882

self.send_changedstate()

1339

self.approved = value

1340

gobject.timeout_add(timedelta_to_milliseconds

883

self._approved = value

884

gobject.timeout_add(self._timedelta_to_milliseconds

1341

885

(self.approval_duration),

1342

886

self._reset_approved)

1343

887

888

1344

889

## D-Bus methods, signals & properties

1345

_interface = "se.recompile.Mandos.Client"

1346

1347

## Interfaces

1348

1349

@dbus_interface_annotations(_interface)

1350

def _foo(self):

1351

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

1352

"false"}

890

_interface = "se.bsnet.fukt.Mandos.Client"

1353

891

1354

892

## Signals

1355

893

1441

979

if value is None: # get

1442

980

return dbus.Boolean(self.approved_by_default)

1443

981

self.approved_by_default = bool(value)

982

# Emit D-Bus signal

983

self.PropertyChanged(dbus.String("ApprovedByDefault"),

984

dbus.Boolean(value, variant_level=1))

1444

985

1445

986

# ApprovalDelay - property

1446

987

@dbus_service_property(_interface, signature="t",

1449

990

if value is None: # get

1450

991

return dbus.UInt64(self.approval_delay_milliseconds())

1451

992

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

993

# Emit D-Bus signal

994

self.PropertyChanged(dbus.String("ApprovalDelay"),

995

dbus.UInt64(value, variant_level=1))

1452

996

1453

997

# ApprovalDuration - property

1454

998

@dbus_service_property(_interface, signature="t",

1455

999

access="readwrite")

1456

1000

def ApprovalDuration_dbus_property(self, value=None):

1457

1001

if value is None: # get

1458

return dbus.UInt64(timedelta_to_milliseconds(

1002

return dbus.UInt64(self._timedelta_to_milliseconds(

1459

1003

self.approval_duration))

1460

1004

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

1005

# Emit D-Bus signal

1006

self.PropertyChanged(dbus.String("ApprovalDuration"),

1007

dbus.UInt64(value, variant_level=1))

1461

1008

1462

1009

# Name - property

1463

1010

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

1475

1022

def Host_dbus_property(self, value=None):

1476

1023

if value is None: # get

1477

1024

return dbus.String(self.host)

1478

self.host = unicode(value)

1025

self.host = value

1026

# Emit D-Bus signal

1027

self.PropertyChanged(dbus.String("Host"),

1028

dbus.String(value, variant_level=1))

1479

1029

1480

1030

# Created - property

1481

1031

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

1482

1032

def Created_dbus_property(self):

1483

return datetime_to_dbus(self.created)

1033

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

1484

1034

1485

1035

# LastEnabled - property

1486

1036

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

1487

1037

def LastEnabled_dbus_property(self):

1488

return datetime_to_dbus(self.last_enabled)

1038

if self.last_enabled is None:

1039

return dbus.String("")

1040

return dbus.String(self._datetime_to_dbus(self.last_enabled))

1489

1041

1490

1042

# Enabled - property

1491

1043

@dbus_service_property(_interface, signature="b",

1505

1057

if value is not None:

1506

1058

self.checked_ok()

1507

1059

return

1508

return datetime_to_dbus(self.last_checked_ok)

1509

1510

# LastCheckerStatus - property

1511

@dbus_service_property(_interface, signature="n",

1512

access="read")

1513

def LastCheckerStatus_dbus_property(self):

1514

return dbus.Int16(self.last_checker_status)

1515

1516

# Expires - property

1517

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

1518

def Expires_dbus_property(self):

1519

return datetime_to_dbus(self.expires)

1060

if self.last_checked_ok is None:

1061

return dbus.String("")

1062

return dbus.String(self._datetime_to_dbus(self

1063

.last_checked_ok))

1520

1064

1521

1065

# LastApprovalRequest - property

1522

1066

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

1523

1067

def LastApprovalRequest_dbus_property(self):

1524

return datetime_to_dbus(self.last_approval_request)

1068

if self.last_approval_request is None:

1069

return dbus.String("")

1070

return dbus.String(self.

1071

_datetime_to_dbus(self

1072

.last_approval_request))

1525

1073

1526

1074

# Timeout - property

1527

1075

@dbus_service_property(_interface, signature="t",

1530

1078

if value is None: # get

1531

1079

return dbus.UInt64(self.timeout_milliseconds())

1532

1080

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

1081

# Emit D-Bus signal

1082

self.PropertyChanged(dbus.String("Timeout"),

1083

dbus.UInt64(value, variant_level=1))

1084

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

1085

return

1533

1086

# Reschedule timeout

1534

if self.enabled:

1535

now = datetime.datetime.utcnow()

1536

time_to_die = timedelta_to_milliseconds(

1537

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

1538

if time_to_die <= 0:

1539

# The timeout has passed

1540

self.disable()

1541

else:

1542

self.expires = (now +

1543

datetime.timedelta(milliseconds =

1544

time_to_die))

1545

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

1546

is None):

1547

return

1548

gobject.source_remove(self.disable_initiator_tag)

1549

self.disable_initiator_tag = (gobject.timeout_add

1550

(time_to_die,

1551

self.disable))

1552

1553

# ExtendedTimeout - property

1554

@dbus_service_property(_interface, signature="t",

1555

access="readwrite")

1556

def ExtendedTimeout_dbus_property(self, value=None):

1557

if value is None: # get

1558

return dbus.UInt64(self.extended_timeout_milliseconds())

1559

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

1087

gobject.source_remove(self.disable_initiator_tag)

1088

self.disable_initiator_tag = None

1089

time_to_die = (self.

1090

_timedelta_to_milliseconds((self

1091

.last_checked_ok

1092

+ self.timeout)

1093

- datetime.datetime

1094

.utcnow()))

1095

if time_to_die <= 0:

1096

# The timeout has passed

1097

self.disable()

1098

else:

1099

self.disable_initiator_tag = (gobject.timeout_add

1100

(time_to_die, self.disable))

1560

1101

1561

1102

# Interval - property

1562

1103

@dbus_service_property(_interface, signature="t",

1565

1106

if value is None: # get

1566

1107

return dbus.UInt64(self.interval_milliseconds())

1567

1108

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

1109

# Emit D-Bus signal

1110

self.PropertyChanged(dbus.String("Interval"),

1111

dbus.UInt64(value, variant_level=1))

1568

1112

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

1569

1113

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

1576

1114

# Reschedule checker run

1115

gobject.source_remove(self.checker_initiator_tag)

1116

self.checker_initiator_tag = (gobject.timeout_add

1117

(value, self.start_checker))

1118

self.start_checker() # Start one now, too

1119

1577

1120

# Checker - property

1578

1121

@dbus_service_property(_interface, signature="s",

1579

1122

access="readwrite")

1580

1123

def Checker_dbus_property(self, value=None):

1581

1124

if value is None: # get

1582

1125

return dbus.String(self.checker_command)

1583

self.checker_command = unicode(value)

1126

self.checker_command = value

1127

# Emit D-Bus signal

1128

self.PropertyChanged(dbus.String("Checker"),

1129

dbus.String(self.checker_command,

1130

variant_level=1))

1584

1131

1585

1132

# CheckerRunning - property

1586

1133

@dbus_service_property(_interface, signature="b",

1613

1160

self._pipe.send(('init', fpr, address))

1614

1161

if not self._pipe.recv():

1615

1162

raise KeyError()

1616

1163

1617

1164

def __getattribute__(self, name):

1618

if name == '_pipe':

1165

if(name == '_pipe'):

1619

1166

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

1620

1167

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

1621

1168

data = self._pipe.recv()

1626

1173

self._pipe.send(('funcall', name, args, kwargs))

1627

1174

return self._pipe.recv()[1]

1628

1175

return func

1629

1176

1630

1177

def __setattr__(self, name, value):

1631

if name == '_pipe':

1178

if(name == '_pipe'):

1632

1179

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

1633

1180

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

1634

1181

1645

1192

unicode(self.client_address))

1646

1193

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

1647

1194

self.server.child_pipe.fileno())

1648

1195

1649

1196

session = (gnutls.connection

1650

1197

.ClientSession(self.request,

1651

1198

gnutls.connection

1652

1199

.X509Credentials()))

1653

1200

1654

1201

# Note: gnutls.connection.X509Credentials is really a

1655

1202

# generic GnuTLS certificate credentials object so long as

1656

1203

# no X.509 keys are added to it. Therefore, we can use it

1657

1204

# here despite using OpenPGP certificates.

1658

1205

1659

1206

#priority = ':'.join(("NONE", "+VERS-TLS1.1",

1660

1207

# "+AES-256-CBC", "+SHA1",

1661

1208

# "+COMP-NULL", "+CTYPE-OPENPGP",

1667

1214

(gnutls.library.functions

1668

1215

.gnutls_priority_set_direct(session._c_object,

1669

1216

priority, None))

1670

1217

1671

1218

# Start communication using the Mandos protocol

1672

1219

# Get protocol number

1673

1220

line = self.request.makefile().readline()

1678

1225

except (ValueError, IndexError, RuntimeError) as error:

1679

1226

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

1680

1227

return

1681

1228

1682

1229

# Start GnuTLS connection

1683

1230

try:

1684

1231

session.handshake()

1688

1235

# established. Just abandon the request.

1689

1236

return

1690

1237

logger.debug("Handshake succeeded")

1691

1238

1692

1239

approval_required = False

1693

1240

try:

1694

1241

try:

1699

1246

logger.warning("Bad certificate: %s", error)

1700

1247

return

1701

1248

logger.debug("Fingerprint: %s", fpr)

1702

1249

1703

1250

try:

1704

1251

client = ProxyClient(child_pipe, fpr,

1705

1252

self.client_address)

1713

1260

1714

1261

while True:

1715

1262

if not client.enabled:

1716

logger.info("Client %s is disabled",

1263

logger.warning("Client %s is disabled",

1717

1264

client.name)

1718

1265

if self.server.use_dbus:

1719

1266

# Emit D-Bus signal

1720

client.Rejected("Disabled")

1267

client.Rejected("Disabled")

1721

1268

return

1722

1269

1723

if client.approved or not client.approval_delay:

1270

if client._approved or not client.approval_delay:

1724

1271

#We are approved or approval is disabled

1725

1272

break

1726

elif client.approved is None:

1273

elif client._approved is None:

1727

1274

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

1728

1275

client.name)

1729

1276

if self.server.use_dbus:

1740

1287

return

1741

1288

1742

1289

#wait until timeout or approved

1290

#x = float(client._timedelta_to_milliseconds(delay))

1743

1291

time = datetime.datetime.now()

1744

1292

client.changedstate.acquire()

1745

(client.changedstate.wait

1746

(float(client.timedelta_to_milliseconds(delay)

1747

/ 1000)))

1293

client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))

1748

1294

client.changedstate.release()

1749

1295

time2 = datetime.datetime.now()

1750

1296

if (time2 - time) >= delay:

1766

1312

try:

1767

1313

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

1768

1314

except gnutls.errors.GNUTLSError as error:

1769

logger.warning("gnutls send failed",

1770

exc_info=error)

1315

logger.warning("gnutls send failed")

1771

1316

return

1772

1317

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

1773

1318

sent, len(client.secret)

1774

1319

- (sent_size + sent))

1775

1320

sent_size += sent

1776

1321

1777

1322

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

1778

# bump the timeout using extended_timeout

1779

client.bump_timeout(client.extended_timeout)

1323

# bump the timeout as if seen

1324

client.checked_ok()

1780

1325

if self.server.use_dbus:

1781

1326

# Emit D-Bus signal

1782

1327

client.GotSecret()

1787

1332

try:

1788

1333

session.bye()

1789

1334

except gnutls.errors.GNUTLSError as error:

1790

logger.warning("GnuTLS bye failed",

1791

exc_info=error)

1335

logger.warning("GnuTLS bye failed")

1792

1336

1793

1337

@staticmethod

1794

1338

def peer_certificate(session):

1850

1394

# Convert the buffer to a Python bytestring

1851

1395

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

1852

1396

# Convert the bytestring to hexadecimal notation

1853

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

1397

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

1854

1398

return hex_fpr

1855

1399

1856

1400

1859

1403

def sub_process_main(self, request, address):

1860

1404

try:

1861

1405

self.finish_request(request, address)

1862

except Exception:

1406

except:

1863

1407

self.handle_error(request, address)

1864

1408

self.close_request(request)

1865

1409

1866

1410

def process_request(self, request, address):

1867

1411

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

1868

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

1869

args = (request, address))

1870

proc.start()

1871

return proc

1872

1412

multiprocessing.Process(target = self.sub_process_main,

1413

args = (request, address)).start()

1873

1414

1874

1415

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1875

1416

""" adds a pipe to the MixIn """

1879

1420

This function creates a new pipe in self.pipe

1880

1421

"""

1881

1422

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1882

1883

proc = MultiprocessingMixIn.process_request(self, request,

1884

client_address)

1423

1424

super(MultiprocessingMixInWithPipe,

1425

self).process_request(request, client_address)

1885

1426

self.child_pipe.close()

1886

self.add_pipe(parent_pipe, proc)

1887

1888

def add_pipe(self, parent_pipe, proc):

1427

self.add_pipe(parent_pipe)

1428

1429

def add_pipe(self, parent_pipe):

1889

1430

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

1890

1431

raise NotImplementedError

1891

1432

1892

1893

1433

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1894

1434

socketserver.TCPServer, object):

1895

1435

"""IPv6-capable TCP server. Accepts 'None' as address and/or port

1969

1509

self.enabled = False

1970

1510

self.clients = clients

1971

1511

if self.clients is None:

1972

self.clients = {}

1512

self.clients = set()

1973

1513

self.use_dbus = use_dbus

1974

1514

self.gnutls_priority = gnutls_priority

1975

1515

IPv6_TCPServer.__init__(self, server_address,

1979

1519

def server_activate(self):

1980

1520

if self.enabled:

1981

1521

return socketserver.TCPServer.server_activate(self)

1982

1983

1522

def enable(self):

1984

1523

self.enabled = True

1985

1986

def add_pipe(self, parent_pipe, proc):

1524

def add_pipe(self, parent_pipe):

1987

1525

# Call "handle_ipc" for both data and EOF events

1988

1526

gobject.io_add_watch(parent_pipe.fileno(),

1989

1527

gobject.IO_IN | gobject.IO_HUP,

1990

1528

functools.partial(self.handle_ipc,

1991

parent_pipe =

1992

parent_pipe,

1993

proc = proc))

1994

1529

parent_pipe = parent_pipe))

1530

1995

1531

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

1996

proc = None, client_object=None):

1997

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

1998

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

1999

# Wait for other process to exit

2000

proc.join()

1532

client_object=None):

1533

condition_names = {

1534

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

1535

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

1536

# blocking).

1537

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

1538

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

1539

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

1540

# broken, usually for pipes and

1541

# sockets).

1542

}

1543

conditions_string = ' | '.join(name

1544

for cond, name in

1545

condition_names.iteritems()

1546

if cond & condition)

1547

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

1548

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

2001

1549

return False

2002

1550

2003

1551

# Read a request from the child

2008

1556

fpr = request[1]

2009

1557

address = request[2]

2010

1558

2011

for c in self.clients.itervalues():

1559

for c in self.clients:

2012

1560

if c.fingerprint == fpr:

2013

1561

client = c

2014

1562

break

2015

1563

else:

2016

logger.info("Client not found for fingerprint: %s, ad"

2017

"dress: %s", fpr, address)

1564

logger.warning("Client not found for fingerprint: %s, ad"

1565

"dress: %s", fpr, address)

2018

1566

if self.use_dbus:

2019

1567

# Emit D-Bus signal

2020

mandos_dbus_service.ClientNotFound(fpr,

2021

address[0])

1568

mandos_dbus_service.ClientNotFound(fpr, address[0])

2022

1569

parent_pipe.send(False)

2023

1570

return False

2024

1571

2025

1572

gobject.io_add_watch(parent_pipe.fileno(),

2026

1573

gobject.IO_IN | gobject.IO_HUP,

2027

1574

functools.partial(self.handle_ipc,

2028

parent_pipe =

2029

parent_pipe,

2030

proc = proc,

2031

client_object =

2032

client))

1575

parent_pipe = parent_pipe,

1576

client_object = client))

2033

1577

parent_pipe.send(True)

2034

# remove the old hook in favor of the new above hook on

2035

# same fileno

1578

# remove the old hook in favor of the new above hook on same fileno

2036

1579

return False

2037

1580

if command == 'funcall':

2038

1581

funcname = request[1]

2039

1582

args = request[2]

2040

1583

kwargs = request[3]

2041

1584

2042

parent_pipe.send(('data', getattr(client_object,

2043

funcname)(*args,

2044

**kwargs)))

2045

1585

parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))

1586

2046

1587

if command == 'getattr':

2047

1588

attrname = request[1]

2048

1589

if callable(client_object.__getattribute__(attrname)):

2049

1590

parent_pipe.send(('function',))

2050

1591

else:

2051

parent_pipe.send(('data', client_object

2052

.__getattribute__(attrname)))

1592

parent_pipe.send(('data', client_object.__getattribute__(attrname)))

2053

1593

2054

1594

if command == 'setattr':

2055

1595

attrname = request[1]

2056

1596

value = request[2]

2057

1597

setattr(client_object, attrname, value)

2058

1598

2059

1599

return True

2060

1600

2061

1601

2091

1631

elif suffix == "w":

2092

1632

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

2093

1633

else:

2094

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

2095

.format(suffix))

1634

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

2096

1635

except (ValueError, IndexError) as e:

2097

1636

raise ValueError(*(e.args))

2098

1637

timevalue += delta

2099

1638

return timevalue

2100

1639

2101

1640

1641

def if_nametoindex(interface):

1642

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

1643

1644

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

1645

global if_nametoindex

1646

try:

1647

if_nametoindex = (ctypes.cdll.LoadLibrary

1648

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

1649

.if_nametoindex)

1650

except (OSError, AttributeError):

1651

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

1652

def if_nametoindex(interface):

1653

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

1654

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

1655

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

1656

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1657

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

1658

interface))

1659

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

1660

ifreq[16:20])[0]

1661

return interface_index

1662

return if_nametoindex(interface)

1663

1664

2102

1665

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

2103

1666

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

2104

1667

2112

1675

sys.exit()

2113

1676

if not noclose:

2114

1677

# Close all standard open file descriptors

2115

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

1678

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

2116

1679

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

2117

1680

raise OSError(errno.ENODEV,

2118

"{0} not a character device"

2119

.format(os.devnull))

1681

"%s not a character device"

1682

% os.path.devnull)

2120

1683

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

2121

1684

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

2122

1685

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

2131

1694

2132

1695

parser = argparse.ArgumentParser()

2133

1696

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

2134

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

1697

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

2135

1698

help="show version number and exit")

2136

1699

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

2137

1700

help="Bind to interface IF")

2159

1722

" system bus interface")

2160

1723

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

2161

1724

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

2162

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

2163

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

2164

" state")

2165

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

2166

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

2167

2168

1725

options = parser.parse_args()

2169

1726

2170

1727

if options.check:

2183

1740

"use_dbus": "True",

2184

1741

"use_ipv6": "True",

2185

1742

"debuglevel": "",

2186

"restore": "True",

2187

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

2188

1743

}

2189

1744

2190

1745

# Parse config file for server-global settings

2207

1762

# options, if set.

2208

1763

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

2209

1764

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

2210

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

2211

"statedir"):

1765

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

2212

1766

value = getattr(options, option)

2213

1767

if value is not None:

2214

1768

server_settings[option] = value

2226

1780

debuglevel = server_settings["debuglevel"]

2227

1781

use_dbus = server_settings["use_dbus"]

2228

1782

use_ipv6 = server_settings["use_ipv6"]

2229

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

2230

stored_state_file)

2231

2232

if debug:

2233

initlogger(debug, logging.DEBUG)

2234

else:

2235

if not debuglevel:

2236

initlogger(debug)

2237

else:

2238

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

2239

initlogger(debug, level)

2240

1783

2241

1784

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

2242

1785

syslogger.setFormatter(logging.Formatter

2243

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

2244

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

2245

.format(server_settings

2246

["servicename"])))

1786

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

1787

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

1788

% server_settings["servicename"]))

2247

1789

2248

1790

# Parse config file with clients

2249

client_config = configparser.SafeConfigParser(Client

2250

.client_defaults)

1791

client_defaults = { "timeout": "1h",

1792

"interval": "5m",

1793

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

1794

"host": "",

1795

"approval_delay": "0s",

1796

"approval_duration": "1s",

1797

}

1798

client_config = configparser.SafeConfigParser(client_defaults)

2251

1799

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

2252

1800

"clients.conf"))

2253

1801

2267

1815

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

2268

1816

try:

2269

1817

pidfile = open(pidfilename, "w")

2270

except IOError as e:

2271

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

2272

exc_info=e)

1818

except IOError:

1819

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

2273

1820

2274

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

1821

try:

1822

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

1823

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

1824

except KeyError:

2275

1825

try:

2276

uid = pwd.getpwnam(name).pw_uid

2277

gid = pwd.getpwnam(name).pw_gid

2278

break

1826

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

1827

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

2279

1828

except KeyError:

2280

continue

2281

else:

2282

uid = 65534

2283

gid = 65534

1829

try:

1830

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

1831

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

1832

except KeyError:

1833

uid = 65534

1834

gid = 65534

2284

1835

try:

2285

1836

os.setgid(gid)

2286

1837

os.setuid(uid)

2288

1839

if error[0] != errno.EPERM:

2289

1840

raise error

2290

1841

1842

if not debug and not debuglevel:

1843

syslogger.setLevel(logging.WARNING)

1844

console.setLevel(logging.WARNING)

1845

if debuglevel:

1846

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

1847

syslogger.setLevel(level)

1848

console.setLevel(level)

1849

2291

1850

if debug:

2292

1851

# Enable all possible GnuTLS debugging

2293

1852

2303

1862

.gnutls_global_set_log_function(debug_gnutls))

2304

1863

2305

1864

# Redirect stdin so all checkers get /dev/null

2306

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

1865

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

2307

1866

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

2308

1867

if null > 2:

2309

1868

os.close(null)

1869

else:

1870

# No console logging

1871

logger.removeHandler(console)

2310

1872

2311

1873

# Need to fork before connecting to D-Bus

2312

1874

if not debug:

2313

1875

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

2314

1876

daemon()

2315

1877

2316

gobject.threads_init()

2317

2318

1878

global main_loop

2319

1879

# From the Avahi example code

2320

DBusGMainLoop(set_as_default=True)

1880

DBusGMainLoop(set_as_default=True )

2321

1881

main_loop = gobject.MainLoop()

2322

1882

bus = dbus.SystemBus()

2323

1883

# End of Avahi example code

2324

1884

if use_dbus:

2325

1885

try:

2326

bus_name = dbus.service.BusName("se.recompile.Mandos",

1886

bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",

2327

1887

bus, do_not_queue=True)

2328

old_bus_name = (dbus.service.BusName

2329

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

2330

do_not_queue=True))

2331

1888

except dbus.exceptions.NameExistsException as e:

2332

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

1889

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

2333

1890

use_dbus = False

2334

1891

server_settings["use_dbus"] = False

2335

1892

tcp_server.use_dbus = False

2336

1893

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2337

service = AvahiServiceToSyslog(name =

2338

server_settings["servicename"],

2339

servicetype = "_mandos._tcp",

2340

protocol = protocol, bus = bus)

1894

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

1895

servicetype = "_mandos._tcp",

1896

protocol = protocol, bus = bus)

2341

1897

if server_settings["interface"]:

2342

1898

service.interface = (if_nametoindex

2343

1899

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

2348

1904

client_class = Client

2349

1905

if use_dbus:

2350

1906

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

2351

2352

client_settings = Client.config_parser(client_config)

2353

old_client_settings = {}

2354

clients_data = {}

2355

2356

# Get client data and settings from last running state.

2357

if server_settings["restore"]:

2358

try:

2359

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

2360

clients_data, old_client_settings = (pickle.load

2361

(stored_state))

2362

os.remove(stored_state_path)

2363

except IOError as e:

2364

if e.errno == errno.ENOENT:

2365

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

2366

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

2367

else:

2368

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

2369

exc_info=e)

2370

raise

2371

except EOFError as e:

2372

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

2373

"EOFError:", exc_info=e)

2374

2375

with PGPEngine() as pgp:

2376

for client_name, client in clients_data.iteritems():

2377

# Decide which value to use after restoring saved state.

2378

# We have three different values: Old config file,

2379

# new config file, and saved state.

2380

# New config value takes precedence if it differs from old

2381

# config value, otherwise use saved state.

2382

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

2383

try:

2384

# For each value in new config, check if it

2385

# differs from the old config value (Except for

2386

# the "secret" attribute)

2387

if (name != "secret" and

2388

value != old_client_settings[client_name]

2389

[name]):

2390

client[name] = value

2391

except KeyError:

2392

pass

2393

2394

# Clients who has passed its expire date can still be

2395

# enabled if its last checker was successful. Clients

2396

# whose checker succeeded before we stored its state is

2397

# assumed to have successfully run all checkers during

2398

# downtime.

2399

if client["enabled"]:

2400

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

2401

if not client["last_checked_ok"]:

2402

logger.warning(

2403

"disabling client {0} - Client never "

2404

"performed a successful checker"

2405

.format(client_name))

2406

client["enabled"] = False

2407

elif client["last_checker_status"] != 0:

2408

logger.warning(

2409

"disabling client {0} - Client "

2410

"last checker failed with error code {1}"

2411

.format(client_name,

2412

client["last_checker_status"]))

2413

client["enabled"] = False

2414

else:

2415

client["expires"] = (datetime.datetime

2416

.utcnow()

2417

+ client["timeout"])

2418

logger.debug("Last checker succeeded,"

2419

" keeping {0} enabled"

2420

.format(client_name))

1907

def client_config_items(config, section):

1908

special_settings = {

1909

"approved_by_default":

1910

lambda: config.getboolean(section,

1911

"approved_by_default"),

1912

}

1913

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

2421

1914

try:

2422

client["secret"] = (

2423

pgp.decrypt(client["encrypted_secret"],

2424

client_settings[client_name]

2425

["secret"]))

2426

except PGPError:

2427

# If decryption fails, we use secret from new settings

2428

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

2429

.format(client_name))

2430

client["secret"] = (

2431

client_settings[client_name]["secret"])

2432

2433

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

2434

for client_name in (set(old_client_settings)

2435

- set(client_settings)):

2436

del clients_data[client_name]

2437

for client_name in (set(client_settings)

2438

- set(old_client_settings)):

2439

clients_data[client_name] = client_settings[client_name]

2440

2441

# Create all client objects

2442

for client_name, client in clients_data.iteritems():

2443

tcp_server.clients[client_name] = client_class(

2444

name = client_name, settings = client)

2445

1915

yield (name, special_settings[name]())

1916

except KeyError:

1917

yield (name, value)

1918

1919

tcp_server.clients.update(set(

1920

client_class(name = section,

1921

config= dict(client_config_items(

1922

client_config, section)))

1923

for section in client_config.sections()))

2446

1924

if not tcp_server.clients:

2447

1925

logger.warning("No clients defined")

2448

1926

2449

1927

if not debug:

2450

1928

try:

2451

1929

with pidfile:

2459

1937

# "pidfile" was never created

2460

1938

pass

2461

1939

del pidfilename

1940

2462

1941

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

2463

1942

2464

1943

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

2465

1944

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

2466

1945

2467

1946

if use_dbus:

2468

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

2469

"se.bsnet.fukt.Mandos"})

2470

class MandosDBusService(DBusObjectWithProperties):

1947

class MandosDBusService(dbus.service.Object):

2471

1948

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

2472

1949

def __init__(self):

2473

1950

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

2474

_interface = "se.recompile.Mandos"

2475

2476

@dbus_interface_annotations(_interface)

2477

def _foo(self):

2478

return { "org.freedesktop.DBus.Property"

2479

".EmitsChangedSignal":

2480

"false"}

1951

_interface = "se.bsnet.fukt.Mandos"

2481

1952

2482

1953

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

2483

1954

def ClientAdded(self, objpath):

2498

1969

def GetAllClients(self):

2499

1970

"D-Bus method"

2500

1971

return dbus.Array(c.dbus_object_path

2501

for c in

2502

tcp_server.clients.itervalues())

1972

for c in tcp_server.clients)

2503

1973

2504

1974

@dbus.service.method(_interface,

2505

1975

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

2507

1977

"D-Bus method"

2508

1978

return dbus.Dictionary(

2509

1979

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

2510

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

1980

for c in tcp_server.clients),

2511

1981

signature="oa{sv}")

2512

1982

2513

1983

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

2514

1984

def RemoveClient(self, object_path):

2515

1985

"D-Bus method"

2516

for c in tcp_server.clients.itervalues():

1986

for c in tcp_server.clients:

2517

1987

if c.dbus_object_path == object_path:

2518

del tcp_server.clients[c.name]

1988

tcp_server.clients.remove(c)

2519

1989

c.remove_from_connection()

2520

1990

# Don't signal anything except ClientRemoved

2521

1991

c.disable(quiet=True)

2532

2002

"Cleanup function; run on exit"

2533

2003

service.cleanup()

2534

2004

2535

multiprocessing.active_children()

2536

if not (tcp_server.clients or client_settings):

2537

return

2538

2539

# Store client before exiting. Secrets are encrypted with key

2540

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

2541

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

2542

clients = {}

2543

with PGPEngine() as pgp:

2544

for client in tcp_server.clients.itervalues():

2545

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

2546

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

2547

key)

2548

client_dict = {}

2549

2550

# A list of attributes that can not be pickled

2551

# + secret.

2552

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

2553

"checker"))

2554

for name, typ in (inspect.getmembers

2555

(dbus.service.Object)):

2556

exclude.add(name)

2557

2558

client_dict["encrypted_secret"] = (client

2559

.encrypted_secret)

2560

for attr in client.client_structure:

2561

if attr not in exclude:

2562

client_dict[attr] = getattr(client, attr)

2563

2564

clients[client.name] = client_dict

2565

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

2566

2567

try:

2568

with (tempfile.NamedTemporaryFile

2569

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

2570

dir=os.path.dirname(stored_state_path),

2571

delete=False)) as stored_state:

2572

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

2573

tempname=stored_state.name

2574

os.rename(tempname, stored_state_path)

2575

except (IOError, OSError) as e:

2576

if not debug:

2577

try:

2578

os.remove(tempname)

2579

except NameError:

2580

pass

2581

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

2582

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

2583

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

2584

else:

2585

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

2586

exc_info=e)

2587

raise e

2588

2589

# Delete all clients, and settings from config

2590

2005

while tcp_server.clients:

2591

name, client = tcp_server.clients.popitem()

2006

client = tcp_server.clients.pop()

2592

2007

if use_dbus:

2593

2008

client.remove_from_connection()

2009

client.disable_hook = None

2594

2010

# Don't signal anything except ClientRemoved

2595

2011

client.disable(quiet=True)

2596

2012

if use_dbus:

2597

2013

# Emit D-Bus signal

2598

mandos_dbus_service.ClientRemoved(client

2599

.dbus_object_path,

2014

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2600

2015

client.name)

2601

client_settings.clear()

2602

2016

2603

2017

atexit.register(cleanup)

2604

2018

2605

for client in tcp_server.clients.itervalues():

2019

for client in tcp_server.clients:

2606

2020

if use_dbus:

2607

2021

# Emit D-Bus signal

2608

2022

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2609

# Need to initiate checking of clients

2610

if client.enabled:

2611

client.init_checker()

2023

client.enable()

2612

2024

2613

2025

tcp_server.enable()

2614

2026

tcp_server.server_activate()

2617

2029

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

2618

2030

if use_ipv6:

2619

2031

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

2620

" flowinfo %d, scope_id %d",

2621

*tcp_server.socket.getsockname())

2032

" flowinfo %d, scope_id %d"

2033

% tcp_server.socket.getsockname())

2622

2034

else: # IPv4

2623

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

2624

*tcp_server.socket.getsockname())

2035

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

2036

% tcp_server.socket.getsockname())

2625

2037

2626

2038

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

2627

2039

2630

2042

try:

2631

2043

service.activate()

2632

2044

except dbus.exceptions.DBusException as error:

2633

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

2045

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

2634

2046

cleanup()

2635

2047

sys.exit(1)

2636

2048

# End of Avahi example code

2643

2055

logger.debug("Starting main loop")

2644

2056

main_loop.run()

2645

2057

except AvahiError as error:

2646

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

2058

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

2647

2059

cleanup()

2648

2060

sys.exit(1)

2649

2061

except KeyboardInterrupt: