/mandos/trunk : revision 24.1.183

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

import collections

72

65

73

66

import dbus

74

67

import dbus.service

88

81

except ImportError:

89

82

SO_BINDTODEVICE = None

90

83

91

version = "1.6.1"

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

84

85

version = "1.3.1"

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.tempdir = tempfile.mkdtemp(prefix="mandos-")

143

self.gnupgargs = ['--batch',

144

'--home', self.tempdir,

145

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

encoded = b"mandos" + binascii.hexlify(password)

176

if len(encoded) > 2048:

177

# GnuPG can't handle long passwords, so encode differently

178

encoded = (b"mandos" + password.replace(b"\\", b"\\\\")

179

.replace(b"\n", b"\\n")

180

.replace(b"\0", b"\\x00"))

181

return encoded

182

183

def encrypt(self, data, password):

184

passphrase = self.password_encode(password)

185

with tempfile.NamedTemporaryFile(dir=self.tempdir

186

) as passfile:

187

passfile.write(passphrase)

188

passfile.flush()

189

proc = subprocess.Popen(['gpg', '--symmetric',

190

'--passphrase-file',

191

passfile.name]

192

+ self.gnupgargs,

193

stdin = subprocess.PIPE,

194

stdout = subprocess.PIPE,

195

stderr = subprocess.PIPE)

196

ciphertext, err = proc.communicate(input = data)

197

if proc.returncode != 0:

198

raise PGPError(err)

199

return ciphertext

200

201

def decrypt(self, data, password):

202

passphrase = self.password_encode(password)

203

with tempfile.NamedTemporaryFile(dir = self.tempdir

204

) as passfile:

205

passfile.write(passphrase)

206

passfile.flush()

207

proc = subprocess.Popen(['gpg', '--decrypt',

208

'--passphrase-file',

209

passfile.name]

210

+ self.gnupgargs,

211

stdin = subprocess.PIPE,

212

stdout = subprocess.PIPE,

213

stderr = subprocess.PIPE)

214

decrypted_plaintext, err = proc.communicate(input

215

= data)

216

if proc.returncode != 0:

217

raise PGPError(err)

218

return decrypted_plaintext

219

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)

220

102

221

103

class AvahiError(Exception):

222

104

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

240

122

Used to optionally bind to the specified interface.

241

123

name: string; Example: 'Mandos'

242

124

type: string; Example: '_mandos._tcp'.

243

See <https://www.iana.org/assignments/service-names-port-numbers>

125

See <http://www.dns-sd.org/ServiceTypes.html>

244

126

port: integer; what port to announce

245

127

TXT: list of strings; TXT record for the service

246

128

domain: string; Domain to publish on, default to .local if empty.

252

134

server: D-Bus Server

253

135

bus: dbus.SystemBus()

254

136

"""

255

256

137

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

257

138

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

258

139

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

271

152

self.server = None

272

153

self.bus = bus

273

154

self.entry_group_state_changed_match = None

274

275

155

def rename(self):

276

156

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

277

157

if self.rename_count >= self.max_renames:

279

159

" after %i retries, exiting.",

280

160

self.rename_count)

281

161

raise AvahiServiceError("Too many renames")

282

self.name = unicode(self.server

283

.GetAlternativeServiceName(self.name))

162

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

284

163

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

285

164

self.name)

165

syslogger.setFormatter(logging.Formatter

166

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

167

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

168

% self.name))

286

169

self.remove()

287

170

try:

288

171

self.add()

289

172

except dbus.exceptions.DBusException as error:

290

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

173

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

291

174

self.cleanup()

292

175

os._exit(1)

293

176

self.rename_count += 1

294

295

177

def remove(self):

296

178

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

297

179

if self.entry_group_state_changed_match is not None:

299

181

self.entry_group_state_changed_match = None

300

182

if self.group is not None:

301

183

self.group.Reset()

302

303

184

def add(self):

304

185

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

305

186

self.remove()

310

191

avahi.DBUS_INTERFACE_ENTRY_GROUP)

311

192

self.entry_group_state_changed_match = (

312

193

self.group.connect_to_signal(

313

'StateChanged', self.entry_group_state_changed))

194

'StateChanged', self .entry_group_state_changed))

314

195

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

315

196

self.name, self.type)

316

197

self.group.AddService(

322

203

dbus.UInt16(self.port),

323

204

avahi.string_array_to_txt_array(self.TXT))

324

205

self.group.Commit()

325

326

206

def entry_group_state_changed(self, state, error):

327

207

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

328

208

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

335

215

elif state == avahi.ENTRY_GROUP_FAILURE:

336

216

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

337

217

unicode(error))

338

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

339

.format(error))

340

218

raise AvahiGroupError("State changed: %s"

219

% unicode(error))

341

220

def cleanup(self):

342

221

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

343

222

if self.group is not None:

344

223

try:

345

224

self.group.Free()

346

225

except (dbus.exceptions.UnknownMethodException,

347

dbus.exceptions.DBusException):

226

dbus.exceptions.DBusException) as e:

348

227

pass

349

228

self.group = None

350

229

self.remove()

351

352

230

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

353

231

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

354

232

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

373

251

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

374

252

else:

375

253

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

376

377

254

def activate(self):

378

255

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

379

256

if self.server is None:

387

264

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

388

265

389

266

390

class AvahiServiceToSyslog(AvahiService):

391

def rename(self):

392

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

393

ret = AvahiService.rename(self)

394

syslogger.setFormatter(logging.Formatter

395

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

396

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

397

.format(self.name)))

398

return ret

399

400

401

def timedelta_to_milliseconds(td):

267

def _timedelta_to_milliseconds(td):

402

268

"Convert a datetime.timedelta() to milliseconds"

403

269

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

404

270

+ (td.seconds * 1000)

405

271

+ (td.microseconds // 1000))

406

407

272

408

273

class Client(object):

409

274

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

410

275

411

276

Attributes:

412

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

277

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

413

278

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

414

279

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

415

280

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

422

287

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

423

288

checker_initiator_tag: a gobject event source tag, or None

424

289

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

425

client_structure: Object describing what attributes a client has

426

and is used for storing the client at exit

427

290

current_checker_command: string; current running checker_command

291

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

428

292

disable_initiator_tag: a gobject event source tag, or None

429

293

enabled: bool()

430

294

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

433

297

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

434

298

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

435

299

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

436

last_checker_status: integer between 0 and 255 reflecting exit

437

status of last checker. -1 reflects crashed

438

checker, -2 means no checker completed yet.

439

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

300

last_enabled: datetime.datetime(); (UTC)

440

301

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

441

302

D-Bus identifiers

442

303

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

443

304

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

444

305

until this client is disabled

445

extended_timeout: extra long timeout when secret has been sent

306

extended_timeout: extra long timeout when password has been sent

446

307

runtime_expansions: Allowed attributes for runtime expansion.

447

308

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

448

309

disabled, or None

449

server_settings: The server_settings dict from main()

450

310

"""

451

311

452

312

runtime_expansions = ("approval_delay", "approval_duration",

453

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

454

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

455

"last_approval_request", "last_checked_ok",

313

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

314

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

456

315

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

457

client_defaults = { "timeout": "PT5M",

458

"extended_timeout": "PT15M",

459

"interval": "PT2M",

460

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

461

"host": "",

462

"approval_delay": "PT0S",

463

"approval_duration": "PT1S",

464

"approved_by_default": "True",

465

"enabled": "True",

466

}

467

316

468

317

def timeout_milliseconds(self):

469

318

"Return the 'timeout' attribute in milliseconds"

470

return timedelta_to_milliseconds(self.timeout)

471

319

return _timedelta_to_milliseconds(self.timeout)

320

472

321

def extended_timeout_milliseconds(self):

473

322

"Return the 'extended_timeout' attribute in milliseconds"

474

return timedelta_to_milliseconds(self.extended_timeout)

323

return _timedelta_to_milliseconds(self.extended_timeout)

475

324

476

325

def interval_milliseconds(self):

477

326

"Return the 'interval' attribute in milliseconds"

478

return timedelta_to_milliseconds(self.interval)

479

327

return _timedelta_to_milliseconds(self.interval)

328

480

329

def approval_delay_milliseconds(self):

481

return timedelta_to_milliseconds(self.approval_delay)

482

483

@staticmethod

484

def config_parser(config):

485

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

486

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

487

with exceptions for any special settings as defined above.

488

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

489

value given the same arguments.

490

"""

491

settings = {}

492

for client_name in config.sections():

493

section = dict(config.items(client_name))

494

client = settings[client_name] = {}

495

496

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

497

# Reformat values from string types to Python types

498

client["approved_by_default"] = config.getboolean(

499

client_name, "approved_by_default")

500

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

501

"enabled")

502

503

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

504

.replace(" ", ""))

505

if "secret" in section:

506

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

507

elif "secfile" in section:

508

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

509

(section["secfile"])),

510

"rb") as secfile:

511

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

512

else:

513

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

514

.format(section))

515

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

516

client["extended_timeout"] = string_to_delta(

517

section["extended_timeout"])

518

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

519

client["approval_delay"] = string_to_delta(

520

section["approval_delay"])

521

client["approval_duration"] = string_to_delta(

522

section["approval_duration"])

523

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

524

client["last_approval_request"] = None

525

client["last_checked_ok"] = None

526

client["last_checker_status"] = -2

527

528

return settings

529

530

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

330

return _timedelta_to_milliseconds(self.approval_delay)

331

332

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

333

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

334

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

335

attribute."""

531

336

self.name = name

532

if server_settings is None:

533

server_settings = {}

534

self.server_settings = server_settings

535

# adding all client settings

536

for setting, value in settings.iteritems():

537

setattr(self, setting, value)

538

539

if self.enabled:

540

if not hasattr(self, "last_enabled"):

541

self.last_enabled = datetime.datetime.utcnow()

542

if not hasattr(self, "expires"):

543

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

544

+ self.timeout)

545

else:

546

self.last_enabled = None

547

self.expires = None

548

337

if config is None:

338

config = {}

549

339

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

550

340

# Uppercase and remove spaces from fingerprint for later

551

341

# comparison purposes with return value from the fingerprint()

552

342

# function

343

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

344

.replace(" ", ""))

553

345

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

554

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

555

datetime.datetime.utcnow())

556

557

# attributes specific for this server instance

346

if "secret" in config:

347

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

348

elif "secfile" in config:

349

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

350

(config["secfile"])),

351

"rb") as secfile:

352

self.secret = secfile.read()

353

else:

354

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

355

% self.name)

356

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

357

self.created = datetime.datetime.utcnow()

358

self.enabled = False

359

self.last_approval_request = None

360

self.last_enabled = None

361

self.last_checked_ok = None

362

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

363

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

364

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

365

self.disable_hook = disable_hook

558

366

self.checker = None

559

367

self.checker_initiator_tag = None

560

368

self.disable_initiator_tag = None

369

self.expires = None

561

370

self.checker_callback_tag = None

371

self.checker_command = config["checker"]

562

372

self.current_checker_command = None

563

self.approved = None

373

self.last_connect = None

374

self._approved = None

375

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

376

True)

564

377

self.approvals_pending = 0

565

self.changedstate = (multiprocessing_manager

566

.Condition(multiprocessing_manager

567

.Lock()))

568

self.client_structure = [attr for attr in

569

self.__dict__.iterkeys()

570

if not attr.startswith("_")]

571

self.client_structure.append("client_structure")

572

573

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

574

lambda obj:

575

isinstance(obj,

576

property)):

577

if not name.startswith("_"):

578

self.client_structure.append(name)

378

self.approval_delay = string_to_delta(

379

config["approval_delay"])

380

self.approval_duration = string_to_delta(

381

config["approval_duration"])

382

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

579

383

580

# Send notice to process children that client state has changed

581

384

def send_changedstate(self):

582

with self.changedstate:

583

self.changedstate.notify_all()

584

385

self.changedstate.acquire()

386

self.changedstate.notify_all()

387

self.changedstate.release()

388

585

389

def enable(self):

586

390

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

587

391

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

588

392

# Already enabled

589

393

return

394

self.send_changedstate()

395

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

396

# and every interval from then on.

397

self.checker_initiator_tag = (gobject.timeout_add

398

(self.interval_milliseconds(),

399

self.start_checker))

400

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

590

401

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

402

self.disable_initiator_tag = (gobject.timeout_add

403

(self.timeout_milliseconds(),

404

self.disable))

591

405

self.enabled = True

592

406

self.last_enabled = datetime.datetime.utcnow()

593

self.init_checker()

594

self.send_changedstate()

407

# Also start a new checker *right now*.

408

self.start_checker()

595

409

596

410

def disable(self, quiet=True):

597

411

"""Disable this client."""

598

412

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

599

413

return False

600

414

if not quiet:

415

self.send_changedstate()

416

if not quiet:

601

417

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

602

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

418

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

603

419

gobject.source_remove(self.disable_initiator_tag)

604

420

self.disable_initiator_tag = None

605

421

self.expires = None

606

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

422

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

607

423

gobject.source_remove(self.checker_initiator_tag)

608

424

self.checker_initiator_tag = None

609

425

self.stop_checker()

426

if self.disable_hook:

427

self.disable_hook(self)

610

428

self.enabled = False

611

if not quiet:

612

self.send_changedstate()

613

429

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

614

430

return False

615

431

616

432

def __del__(self):

433

self.disable_hook = None

617

434

self.disable()

618

435

619

def init_checker(self):

620

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

621

# and every interval from then on.

622

if self.checker_initiator_tag is not None:

623

gobject.source_remove(self.checker_initiator_tag)

624

self.checker_initiator_tag = (gobject.timeout_add

625

(self.interval_milliseconds(),

626

self.start_checker))

627

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

628

if self.disable_initiator_tag is not None:

629

gobject.source_remove(self.disable_initiator_tag)

630

self.disable_initiator_tag = (gobject.timeout_add

631

(self.timeout_milliseconds(),

632

self.disable))

633

# Also start a new checker *right now*.

634

self.start_checker()

635

636

436

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

637

437

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

638

438

self.checker_callback_tag = None

639

439

self.checker = None

640

440

if os.WIFEXITED(condition):

641

self.last_checker_status = os.WEXITSTATUS(condition)

642

if self.last_checker_status == 0:

441

exitstatus = os.WEXITSTATUS(condition)

442

if exitstatus == 0:

643

443

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

644

444

vars(self))

645

445

self.checked_ok()

647

447

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

648

448

vars(self))

649

449

else:

650

self.last_checker_status = -1

651

450

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

652

451

vars(self))

653

452

654

def checked_ok(self):

655

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

656

self.last_checked_ok = datetime.datetime.utcnow()

657

self.last_checker_status = 0

658

self.bump_timeout()

659

660

def bump_timeout(self, timeout=None):

661

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

453

def checked_ok(self, timeout=None):

454

"""Bump up the timeout for this client.

455

456

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

457

alive and well.

458

"""

662

459

if timeout is None:

663

460

timeout = self.timeout

664

if self.disable_initiator_tag is not None:

665

gobject.source_remove(self.disable_initiator_tag)

666

self.disable_initiator_tag = None

667

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

668

self.disable_initiator_tag = (gobject.timeout_add

669

(timedelta_to_milliseconds

670

(timeout), self.disable))

671

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

461

self.last_checked_ok = datetime.datetime.utcnow()

462

gobject.source_remove(self.disable_initiator_tag)

463

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

464

self.disable_initiator_tag = (gobject.timeout_add

465

(_timedelta_to_milliseconds(timeout),

466

self.disable))

672

467

673

468

def need_approval(self):

674

469

self.last_approval_request = datetime.datetime.utcnow()

679

474

If a checker already exists, leave it running and do

680

475

nothing."""

681

476

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

682

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

683

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

684

# would inevitably timeout, since no checker would get a

685

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

477

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

478

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

479

# client would inevitably timeout, since no checker would get

480

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

686

481

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

687

482

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

688

483

# should be.

702

497

self.current_checker_command)

703

498

# Start a new checker if needed

704

499

if self.checker is None:

705

# Escape attributes for the shell

706

escaped_attrs = dict(

707

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

708

for attr in

709

self.runtime_expansions)

710

500

try:

711

command = self.checker_command % escaped_attrs

712

except TypeError as error:

713

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

714

self.checker_command, exc_info=error)

715

return True # Try again later

501

# In case checker_command has exactly one % operator

502

command = self.checker_command % self.host

503

except TypeError:

504

# Escape attributes for the shell

505

escaped_attrs = dict(

506

(attr,

507

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

508

errors=

509

'replace')))

510

for attr in

511

self.runtime_expansions)

512

513

try:

514

command = self.checker_command % escaped_attrs

515

except TypeError as error:

516

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

517

' %s', self.checker_command, error)

518

return True # Try again later

716

519

self.current_checker_command = command

717

520

try:

718

521

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

721

524

# in normal mode, that is already done by daemon(),

722

525

# and in debug mode we don't want to. (Stdin is

723

526

# always replaced by /dev/null.)

724

# The exception is when not debugging but nevertheless

725

# running in the foreground; use the previously

726

# created wnull.

727

popen_args = {}

728

if (not self.server_settings["debug"]

729

and self.server_settings["foreground"]):

730

popen_args.update({"stdout": wnull,

731

"stderr": wnull })

732

527

self.checker = subprocess.Popen(command,

733

528

close_fds=True,

734

shell=True, cwd="/",

735

**popen_args)

736

except OSError as error:

737

logger.error("Failed to start subprocess",

738

exc_info=error)

739

return True

740

self.checker_callback_tag = (gobject.child_watch_add

741

(self.checker.pid,

742

self.checker_callback,

743

data=command))

744

# The checker may have completed before the gobject

745

# watch was added. Check for this.

746

try:

529

shell=True, cwd="/")

530

self.checker_callback_tag = (gobject.child_watch_add

531

(self.checker.pid,

532

self.checker_callback,

533

data=command))

534

# The checker may have completed before the gobject

535

# watch was added. Check for this.

747

536

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

537

if pid:

538

gobject.source_remove(self.checker_callback_tag)

539

self.checker_callback(pid, status, command)

748

540

except OSError as error:

749

if error.errno == errno.ECHILD:

750

# This should never happen

751

logger.error("Child process vanished",

752

exc_info=error)

753

return True

754

raise

755

if pid:

756

gobject.source_remove(self.checker_callback_tag)

757

self.checker_callback(pid, status, command)

541

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

542

error)

758

543

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

759

544

return True

760

545

767

552

return

768

553

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

769

554

try:

770

self.checker.terminate()

555

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

771

556

#time.sleep(0.5)

772

557

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

773

# self.checker.kill()

558

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

774

559

except OSError as error:

775

560

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

776

561

raise

777

562

self.checker = None

778

563

779

780

564

def dbus_service_property(dbus_interface, signature="v",

781

565

access="readwrite", byte_arrays=False):

782

566

"""Decorators for marking methods of a DBusObjectWithProperties to

793

577

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

794

578

if byte_arrays and signature != "ay":

795

579

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

796

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

580

" signature %r" % signature)

797

581

def decorator(func):

798

582

func._dbus_is_property = True

799

583

func._dbus_interface = dbus_interface

807

591

return decorator

808

592

809

593

810

def dbus_interface_annotations(dbus_interface):

811

"""Decorator for marking functions returning interface annotations

812

813

Usage:

814

815

@dbus_interface_annotations("org.example.Interface")

816

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

817

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

818

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

819

"false"}

820

"""

821

def decorator(func):

822

func._dbus_is_interface = True

823

func._dbus_interface = dbus_interface

824

func._dbus_name = dbus_interface

825

return func

826

return decorator

827

828

829

def dbus_annotations(annotations):

830

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

831

Usage:

832

833

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

834

access="r")

835

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

836

"org.freedesktop.DBus.Property."

837

"EmitsChangedSignal": "false"})

838

def Property_dbus_property(self):

839

return dbus.Boolean(False)

840

"""

841

def decorator(func):

842

func._dbus_annotations = annotations

843

return func

844

return decorator

845

846

847

594

class DBusPropertyException(dbus.exceptions.DBusException):

848

595

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

849

596

"""

865

612

866

613

class DBusObjectWithProperties(dbus.service.Object):

867

614

"""A D-Bus object with properties.

868

615

869

616

Classes inheriting from this can use the dbus_service_property

870

617

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

871

618

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

872

619

"""

873

620

874

621

@staticmethod

875

def _is_dbus_thing(thing):

876

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

877

878

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

879

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

880

"""

881

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

882

False)

622

def _is_dbus_property(obj):

623

return getattr(obj, "_dbus_is_property", False)

883

624

884

def _get_all_dbus_things(self, thing):

625

def _get_all_dbus_properties(self):

885

626

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

886

627

"""

887

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

888

name),

889

athing.__get__(self))

890

for cls in self.__class__.__mro__

891

for name, athing in

892

inspect.getmembers(cls,

893

self._is_dbus_thing(thing)))

628

return ((prop._dbus_name, prop)

629

for name, prop in

630

inspect.getmembers(self, self._is_dbus_property))

894

631

895

632

def _get_dbus_property(self, interface_name, property_name):

896

633

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

897

634

property with the specified name and interface.

898

635

"""

899

for cls in self.__class__.__mro__:

900

for name, value in (inspect.getmembers

901

(cls,

902

self._is_dbus_thing("property"))):

903

if (value._dbus_name == property_name

904

and value._dbus_interface == interface_name):

905

return value.__get__(self)

906

636

for name in (property_name,

637

property_name + "_dbus_property"):

638

prop = getattr(self, name, None)

639

if (prop is None

640

or not self._is_dbus_property(prop)

641

or prop._dbus_name != property_name

642

or (interface_name and prop._dbus_interface

643

and interface_name != prop._dbus_interface)):

644

continue

645

return prop

907

646

# No such property

908

647

raise DBusPropertyNotFound(self.dbus_object_path + ":"

909

648

+ interface_name + "."

934

673

# signatures other than "ay".

935

674

if prop._dbus_signature != "ay":

936

675

raise ValueError

937

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

938

for byte in value))

676

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

677

for byte in value))

939

678

prop(value)

940

679

941

680

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

943

682

def GetAll(self, interface_name):

944

683

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

945

684

standard.

946

685

947

686

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

948

687

"""

949

properties = {}

950

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

688

all = {}

689

for name, prop in self._get_all_dbus_properties():

951

690

if (interface_name

952

691

and interface_name != prop._dbus_interface):

953

692

# Interface non-empty but did not match

957

696

continue

958

697

value = prop()

959

698

if not hasattr(value, "variant_level"):

960

properties[name] = value

699

all[name] = value

961

700

continue

962

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

963

value.variant_level+1)

964

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

701

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

702

value.variant_level+1)

703

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

965

704

966

705

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

967

706

out_signature="s",

968

707

path_keyword='object_path',

969

708

connection_keyword='connection')

970

709

def Introspect(self, object_path, connection):

971

"""Overloading of standard D-Bus method.

972

973

Inserts property tags and interface annotation tags.

710

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

974

711

"""

975

712

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

976

713

connection)

983

720

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

984

721

return e

985

722

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

986

# Add property tags

987

723

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

988

724

for name, prop

989

in self._get_all_dbus_things("property")

725

in self._get_all_dbus_properties()

990

726

if prop._dbus_interface

991

727

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

992

728

if_tag.appendChild(tag)

993

# Add annotation tags

994

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

995

for tag in if_tag.getElementsByTagName(typ):

996

annots = dict()

997

for name, prop in (self.

998

_get_all_dbus_things(typ)):

999

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

1000

and prop._dbus_interface

1001

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

1002

annots.update(getattr

1003

(prop,

1004

"_dbus_annotations",

1005

{}))

1006

for name, value in annots.iteritems():

1007

ann_tag = document.createElement(

1008

"annotation")

1009

ann_tag.setAttribute("name", name)

1010

ann_tag.setAttribute("value", value)

1011

tag.appendChild(ann_tag)

1012

# Add interface annotation tags

1013

for annotation, value in dict(

1014

itertools.chain.from_iterable(

1015

annotations().iteritems()

1016

for name, annotations in

1017

self._get_all_dbus_things("interface")

1018

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

1019

)).iteritems():

1020

ann_tag = document.createElement("annotation")

1021

ann_tag.setAttribute("name", annotation)

1022

ann_tag.setAttribute("value", value)

1023

if_tag.appendChild(ann_tag)

1024

729

# Add the names to the return values for the

1025

730

# "org.freedesktop.DBus.Properties" methods

1026

731

if (if_tag.getAttribute("name")

1041

746

except (AttributeError, xml.dom.DOMException,

1042

747

xml.parsers.expat.ExpatError) as error:

1043

748

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

1044

exc_info=error)

749

error)

1045

750

return xmlstring

1046

751

1047

752

1048

def datetime_to_dbus(dt, variant_level=0):

753

def datetime_to_dbus (dt, variant_level=0):

1049

754

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

1050

755

if dt is None:

1051

756

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

1052

757

return dbus.String(dt.isoformat(),

1053

758

variant_level=variant_level)

1054

759

1055

1056

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1057

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

1058

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

1059

interface names according to the "alt_interface_names" mapping.

1060

Usage:

1061

1062

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

1063

"net.example.AlternateInterface"})

1064

class SampleDBusObject(dbus.service.Object):

1065

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

1066

def SampleDBusMethod():

1067

pass

1068

1069

The above "SampleDBusMethod" on "SampleDBusObject" will be

1070

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

1071

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

1072

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

1073

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

1074

1075

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

1076

(from DBusObjectWithProperties) and interfaces (from the

1077

dbus_interface_annotations decorator).

1078

"""

1079

def wrapper(cls):

1080

for orig_interface_name, alt_interface_name in (

1081

alt_interface_names.iteritems()):

1082

attr = {}

1083

interface_names = set()

1084

# Go though all attributes of the class

1085

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

1086

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

1087

# with the wrong interface name

1088

if (not hasattr(attribute, "_dbus_interface")

1089

or not attribute._dbus_interface

1090

.startswith(orig_interface_name)):

1091

continue

1092

# Create an alternate D-Bus interface name based on

1093

# the current name

1094

alt_interface = (attribute._dbus_interface

1095

.replace(orig_interface_name,

1096

alt_interface_name))

1097

interface_names.add(alt_interface)

1098

# Is this a D-Bus signal?

1099

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

1100

# Extract the original non-method undecorated

1101

# function by black magic

1102

nonmethod_func = (dict(

1103

zip(attribute.func_code.co_freevars,

1104

attribute.__closure__))["func"]

1105

.cell_contents)

1106

# Create a new, but exactly alike, function

1107

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

1108

# with the alternate D-Bus interface name

1109

new_function = (dbus.service.signal

1110

(alt_interface,

1111

attribute._dbus_signature)

1112

(types.FunctionType(

1113

nonmethod_func.func_code,

1114

nonmethod_func.func_globals,

1115

nonmethod_func.func_name,

1116

nonmethod_func.func_defaults,

1117

nonmethod_func.func_closure)))

1118

# Copy annotations, if any

1119

try:

1120

new_function._dbus_annotations = (

1121

dict(attribute._dbus_annotations))

1122

except AttributeError:

1123

pass

1124

# Define a creator of a function to call both the

1125

# original and alternate functions, so both the

1126

# original and alternate signals gets sent when

1127

# the function is called

1128

def fixscope(func1, func2):

1129

"""This function is a scope container to pass

1130

func1 and func2 to the "call_both" function

1131

outside of its arguments"""

1132

def call_both(*args, **kwargs):

1133

"""This function will emit two D-Bus

1134

signals by calling func1 and func2"""

1135

func1(*args, **kwargs)

1136

func2(*args, **kwargs)

1137

return call_both

1138

# Create the "call_both" function and add it to

1139

# the class

1140

attr[attrname] = fixscope(attribute, new_function)

1141

# Is this a D-Bus method?

1142

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

1143

# Create a new, but exactly alike, function

1144

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

1145

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

1146

# to the class.

1147

attr[attrname] = (dbus.service.method

1148

(alt_interface,

1149

attribute._dbus_in_signature,

1150

attribute._dbus_out_signature)

1151

(types.FunctionType

1152

(attribute.func_code,

1153

attribute.func_globals,

1154

attribute.func_name,

1155

attribute.func_defaults,

1156

attribute.func_closure)))

1157

# Copy annotations, if any

1158

try:

1159

attr[attrname]._dbus_annotations = (

1160

dict(attribute._dbus_annotations))

1161

except AttributeError:

1162

pass

1163

# Is this a D-Bus property?

1164

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

1165

# Create a new, but exactly alike, function

1166

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

1167

# property with the alternate D-Bus interface

1168

# name. Add it to the class.

1169

attr[attrname] = (dbus_service_property

1170

(alt_interface,

1171

attribute._dbus_signature,

1172

attribute._dbus_access,

1173

attribute

1174

._dbus_get_args_options

1175

["byte_arrays"])

1176

(types.FunctionType

1177

(attribute.func_code,

1178

attribute.func_globals,

1179

attribute.func_name,

1180

attribute.func_defaults,

1181

attribute.func_closure)))

1182

# Copy annotations, if any

1183

try:

1184

attr[attrname]._dbus_annotations = (

1185

dict(attribute._dbus_annotations))

1186

except AttributeError:

1187

pass

1188

# Is this a D-Bus interface?

1189

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

1190

# Create a new, but exactly alike, function

1191

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

1192

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

1193

# to the class.

1194

attr[attrname] = (dbus_interface_annotations

1195

(alt_interface)

1196

(types.FunctionType

1197

(attribute.func_code,

1198

attribute.func_globals,

1199

attribute.func_name,

1200

attribute.func_defaults,

1201

attribute.func_closure)))

1202

if deprecate:

1203

# Deprecate all alternate interfaces

1204

iname="_AlternateDBusNames_interface_annotation{0}"

1205

for interface_name in interface_names:

1206

@dbus_interface_annotations(interface_name)

1207

def func(self):

1208

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

1209

"true" }

1210

# Find an unused name

1211

for aname in (iname.format(i)

1212

for i in itertools.count()):

1213

if aname not in attr:

1214

attr[aname] = func

1215

break

1216

if interface_names:

1217

# Replace the class with a new subclass of it with

1218

# methods, signals, etc. as created above.

1219

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

1220

(cls,), attr)

1221

return cls

1222

return wrapper

1223

1224

1225

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

1226

"se.bsnet.fukt.Mandos"})

1227

760

class ClientDBus(Client, DBusObjectWithProperties):

1228

761

"""A Client class using D-Bus

1229

762

1238

771

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

1239

772

1240

773

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

774

self._approvals_pending = 0

1241

775

self.bus = bus

1242

776

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

1243

777

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

1249

783

("/clients/" + client_object_name))

1250

784

DBusObjectWithProperties.__init__(self, self.bus,

1251

785

self.dbus_object_path)

1252

786

1253

787

def notifychangeproperty(transform_func,

1254

788

dbus_name, type_func=lambda x: x,

1255

789

variant_level=1):

1256

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

1257

its changes to DBus.

1258

1259

transform_fun: Function that takes a value and a variant_level

1260

and transforms it to a D-Bus type.

1261

dbus_name: D-Bus name of the variable

790

""" Modify a variable so that its a property that announce its

791

changes to DBus.

792

transform_fun: Function that takes a value and transform it to

793

DBus type.

794

dbus_name: DBus name of the variable

1262

795

type_func: Function that transform the value before sending it

1263

to the D-Bus. Default: no transform

1264

variant_level: D-Bus variant level. Default: 1

796

to DBus

797

variant_level: DBus variant level. default: 1

1265

798

"""

1266

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

799

real_value = [None,]

1267

800

def setter(self, value):

801

old_value = real_value[0]

802

real_value[0] = value

1268

803

if hasattr(self, "dbus_object_path"):

1269

if (not hasattr(self, attrname) or

1270

type_func(getattr(self, attrname, None))

1271

!= type_func(value)):

1272

dbus_value = transform_func(type_func(value),

1273

variant_level

1274

=variant_level)

804

if type_func(old_value) != type_func(real_value[0]):

805

dbus_value = transform_func(type_func(real_value[0]),

806

variant_level)

1275

807

self.PropertyChanged(dbus.String(dbus_name),

1276

808

dbus_value)

1277

setattr(self, attrname, value)

1278

1279

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

1280

809

810

return property(lambda self: real_value[0], setter)

811

812

1281

813

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1282

814

approvals_pending = notifychangeproperty(dbus.Boolean,

1283

815

"ApprovalPending",

1286

818

last_enabled = notifychangeproperty(datetime_to_dbus,

1287

819

"LastEnabled")

1288

820

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

1289

type_func = lambda checker:

1290

checker is not None)

821

type_func = lambda checker: checker is not None)

1291

822

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1292

823

"LastCheckedOK")

1293

last_checker_status = notifychangeproperty(dbus.Int16,

1294

"LastCheckerStatus")

1295

last_approval_request = notifychangeproperty(

1296

datetime_to_dbus, "LastApprovalRequest")

824

last_approval_request = notifychangeproperty(datetime_to_dbus,

825

"LastApprovalRequest")

1297

826

approved_by_default = notifychangeproperty(dbus.Boolean,

1298

827

"ApprovedByDefault")

1299

approval_delay = notifychangeproperty(dbus.UInt64,

1300

"ApprovalDelay",

1301

type_func =

1302

timedelta_to_milliseconds)

1303

approval_duration = notifychangeproperty(

1304

dbus.UInt64, "ApprovalDuration",

1305

type_func = timedelta_to_milliseconds)

828

approval_delay = notifychangeproperty(dbus.UInt16, "ApprovalDelay",

829

type_func = _timedelta_to_milliseconds)

830

approval_duration = notifychangeproperty(dbus.UInt16, "ApprovalDuration",

831

type_func = _timedelta_to_milliseconds)

1306

832

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

1307

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

1308

type_func =

1309

timedelta_to_milliseconds)

1310

extended_timeout = notifychangeproperty(

1311

dbus.UInt64, "ExtendedTimeout",

1312

type_func = timedelta_to_milliseconds)

1313

interval = notifychangeproperty(dbus.UInt64,

1314

"Interval",

1315

type_func =

1316

timedelta_to_milliseconds)

833

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

834

type_func = _timedelta_to_milliseconds)

835

extended_timeout = notifychangeproperty(dbus.UInt16, "ExtendedTimeout",

836

type_func = _timedelta_to_milliseconds)

837

interval = notifychangeproperty(dbus.UInt16, "Interval",

838

type_func = _timedelta_to_milliseconds)

1317

839

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

1318

840

1319

841

del notifychangeproperty

1345

867

1346

868

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

1347

869

*args, **kwargs)

1348

870

1349

871

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

1350

872

old_checker = self.checker

1351

873

if self.checker is not None:

1361

883

return r

1362

884

1363

885

def _reset_approved(self):

1364

self.approved = None

886

self._approved = None

1365

887

return False

1366

888

1367

889

def approve(self, value=True):

1368

self.approved = value

1369

gobject.timeout_add(timedelta_to_milliseconds

890

self.send_changedstate()

891

self._approved = value

892

gobject.timeout_add(_timedelta_to_milliseconds

1370

893

(self.approval_duration),

1371

894

self._reset_approved)

1372

self.send_changedstate()

895

1373

896

1374

897

## D-Bus methods, signals & properties

1375

_interface = "se.recompile.Mandos.Client"

1376

1377

## Interfaces

1378

1379

@dbus_interface_annotations(_interface)

1380

def _foo(self):

1381

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

1382

"false"}

898

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

1383

899

1384

900

## Signals

1385

901

1485

1001

access="readwrite")

1486

1002

def ApprovalDuration_dbus_property(self, value=None):

1487

1003

if value is None: # get

1488

return dbus.UInt64(timedelta_to_milliseconds(

1004

return dbus.UInt64(_timedelta_to_milliseconds(

1489

1005

self.approval_duration))

1490

1006

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

1491

1007

1505

1021

def Host_dbus_property(self, value=None):

1506

1022

if value is None: # get

1507

1023

return dbus.String(self.host)

1508

self.host = unicode(value)

1024

self.host = value

1509

1025

1510

1026

# Created - property

1511

1027

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

1512

1028

def Created_dbus_property(self):

1513

return datetime_to_dbus(self.created)

1029

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

1514

1030

1515

1031

# LastEnabled - property

1516

1032

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

1537

1053

return

1538

1054

return datetime_to_dbus(self.last_checked_ok)

1539

1055

1540

# LastCheckerStatus - property

1541

@dbus_service_property(_interface, signature="n",

1542

access="read")

1543

def LastCheckerStatus_dbus_property(self):

1544

return dbus.Int16(self.last_checker_status)

1545

1546

1056

# Expires - property

1547

1057

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

1548

1058

def Expires_dbus_property(self):

1559

1069

def Timeout_dbus_property(self, value=None):

1560

1070

if value is None: # get

1561

1071

return dbus.UInt64(self.timeout_milliseconds())

1562

old_timeout = self.timeout

1563

1072

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

1564

# Reschedule disabling

1565

if self.enabled:

1566

now = datetime.datetime.utcnow()

1567

self.expires += self.timeout - old_timeout

1568

if self.expires <= now:

1569

# The timeout has passed

1570

self.disable()

1571

else:

1572

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

1573

is None):

1574

return

1575

gobject.source_remove(self.disable_initiator_tag)

1576

self.disable_initiator_tag = (

1577

gobject.timeout_add(

1578

timedelta_to_milliseconds(self.expires - now),

1579

self.disable))

1580

1073

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

1074

return

1075

# Reschedule timeout

1076

gobject.source_remove(self.disable_initiator_tag)

1077

self.disable_initiator_tag = None

1078

self.expires = None

1079

time_to_die = (self.

1080

_timedelta_to_milliseconds((self

1081

.last_checked_ok

1082

+ self.timeout)

1083

- datetime.datetime

1084

.utcnow()))

1085

if time_to_die <= 0:

1086

# The timeout has passed

1087

self.disable()

1088

else:

1089

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

1090

+ datetime.timedelta(milliseconds = time_to_die))

1091

self.disable_initiator_tag = (gobject.timeout_add

1092

(time_to_die, self.disable))

1093

1581

1094

# ExtendedTimeout - property

1582

1095

@dbus_service_property(_interface, signature="t",

1583

1096

access="readwrite")

1585

1098

if value is None: # get

1586

1099

return dbus.UInt64(self.extended_timeout_milliseconds())

1587

1100

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

1588

1101

1589

1102

# Interval - property

1590

1103

@dbus_service_property(_interface, signature="t",

1591

1104

access="readwrite")

1595

1108

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

1596

1109

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

1597

1110

return

1598

if self.enabled:

1599

# Reschedule checker run

1600

gobject.source_remove(self.checker_initiator_tag)

1601

self.checker_initiator_tag = (gobject.timeout_add

1602

(value, self.start_checker))

1603

self.start_checker() # Start one now, too

1604

1111

# Reschedule checker run

1112

gobject.source_remove(self.checker_initiator_tag)

1113

self.checker_initiator_tag = (gobject.timeout_add

1114

(value, self.start_checker))

1115

self.start_checker() # Start one now, too

1116

1605

1117

# Checker - property

1606

1118

@dbus_service_property(_interface, signature="s",

1607

1119

access="readwrite")

1608

1120

def Checker_dbus_property(self, value=None):

1609

1121

if value is None: # get

1610

1122

return dbus.String(self.checker_command)

1611

self.checker_command = unicode(value)

1123

self.checker_command = value

1612

1124

1613

1125

# CheckerRunning - property

1614

1126

@dbus_service_property(_interface, signature="b",

1641

1153

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

1642

1154

if not self._pipe.recv():

1643

1155

raise KeyError()

1644

1156

1645

1157

def __getattribute__(self, name):

1646

if name == '_pipe':

1158

if(name == '_pipe'):

1647

1159

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

1648

1160

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

1649

1161

data = self._pipe.recv()

1654

1166

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

1655

1167

return self._pipe.recv()[1]

1656

1168

return func

1657

1169

1658

1170

def __setattr__(self, name, value):

1659

if name == '_pipe':

1171

if(name == '_pipe'):

1660

1172

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

1661

1173

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

1662

1174

1673

1185

unicode(self.client_address))

1674

1186

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

1675

1187

self.server.child_pipe.fileno())

1676

1188

1677

1189

session = (gnutls.connection

1678

1190

.ClientSession(self.request,

1679

1191

gnutls.connection

1680

1192

.X509Credentials()))

1681

1193

1682

1194

# Note: gnutls.connection.X509Credentials is really a

1683

1195

# generic GnuTLS certificate credentials object so long as

1684

1196

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

1685

1197

# here despite using OpenPGP certificates.

1686

1198

1687

1199

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

1688

1200

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

1689

1201

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

1695

1207

(gnutls.library.functions

1696

1208

.gnutls_priority_set_direct(session._c_object,

1697

1209

priority, None))

1698

1210

1699

1211

# Start communication using the Mandos protocol

1700

1212

# Get protocol number

1701

1213

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

1706

1218

except (ValueError, IndexError, RuntimeError) as error:

1707

1219

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

1708

1220

return

1709

1221

1710

1222

# Start GnuTLS connection

1711

1223

try:

1712

1224

session.handshake()

1716

1228

# established. Just abandon the request.

1717

1229

return

1718

1230

logger.debug("Handshake succeeded")

1719

1231

1720

1232

approval_required = False

1721

1233

try:

1722

1234

try:

1727

1239

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

1728

1240

return

1729

1241

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

1730

1242

1731

1243

try:

1732

1244

client = ProxyClient(child_pipe, fpr,

1733

1245

self.client_address)

1745

1257

client.name)

1746

1258

if self.server.use_dbus:

1747

1259

# Emit D-Bus signal

1748

client.Rejected("Disabled")

1260

client.Rejected("Disabled")

1749

1261

return

1750

1262

1751

if client.approved or not client.approval_delay:

1263

if client._approved or not client.approval_delay:

1752

1264

#We are approved or approval is disabled

1753

1265

break

1754

elif client.approved is None:

1266

elif client._approved is None:

1755

1267

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

1756

1268

client.name)

1757

1269

if self.server.use_dbus:

1768

1280

return

1769

1281

1770

1282

#wait until timeout or approved

1283

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

1771

1284

time = datetime.datetime.now()

1772

1285

client.changedstate.acquire()

1773

client.changedstate.wait(

1774

float(timedelta_to_milliseconds(delay)

1775

/ 1000))

1286

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

1776

1287

client.changedstate.release()

1777

1288

time2 = datetime.datetime.now()

1778

1289

if (time2 - time) >= delay:

1794

1305

try:

1795

1306

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

1796

1307

except gnutls.errors.GNUTLSError as error:

1797

logger.warning("gnutls send failed",

1798

exc_info=error)

1308

logger.warning("gnutls send failed")

1799

1309

return

1800

1310

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

1801

1311

sent, len(client.secret)

1802

1312

- (sent_size + sent))

1803

1313

sent_size += sent

1804

1314

1805

1315

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

1806

# bump the timeout using extended_timeout

1807

client.bump_timeout(client.extended_timeout)

1316

# bump the timeout as if seen

1317

client.checked_ok(client.extended_timeout)

1808

1318

if self.server.use_dbus:

1809

1319

# Emit D-Bus signal

1810

1320

client.GotSecret()

1815

1325

try:

1816

1326

session.bye()

1817

1327

except gnutls.errors.GNUTLSError as error:

1818

logger.warning("GnuTLS bye failed",

1819

exc_info=error)

1328

logger.warning("GnuTLS bye failed")

1820

1329

1821

1330

@staticmethod

1822

1331

def peer_certificate(session):

1878

1387

# Convert the buffer to a Python bytestring

1879

1388

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

1880

1389

# Convert the bytestring to hexadecimal notation

1881

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

1390

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

1882

1391

return hex_fpr

1883

1392

1884

1393

1887

1396

def sub_process_main(self, request, address):

1888

1397

try:

1889

1398

self.finish_request(request, address)

1890

except Exception:

1399

except:

1891

1400

self.handle_error(request, address)

1892

1401

self.close_request(request)

1893

1402

1894

1403

def process_request(self, request, address):

1895

1404

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

1896

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

1897

args = (request, address))

1898

proc.start()

1899

return proc

1900

1405

multiprocessing.Process(target = self.sub_process_main,

1406

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

1901

1407

1902

1408

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1903

1409

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

1907

1413

This function creates a new pipe in self.pipe

1908

1414

"""

1909

1415

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1910

1911

proc = MultiprocessingMixIn.process_request(self, request,

1912

client_address)

1416

1417

super(MultiprocessingMixInWithPipe,

1418

self).process_request(request, client_address)

1913

1419

self.child_pipe.close()

1914

self.add_pipe(parent_pipe, proc)

1915

1916

def add_pipe(self, parent_pipe, proc):

1420

self.add_pipe(parent_pipe)

1421

1422

def add_pipe(self, parent_pipe):

1917

1423

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

1918

1424

raise NotImplementedError

1919

1425

1920

1921

1426

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1922

1427

socketserver.TCPServer, object):

1923

1428

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

1928

1433

use_ipv6: Boolean; to use IPv6 or not

1929

1434

"""

1930

1435

def __init__(self, server_address, RequestHandlerClass,

1931

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

1932

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

1933

creating a new one with socket.socket().

1934

"""

1436

interface=None, use_ipv6=True):

1935

1437

self.interface = interface

1936

1438

if use_ipv6:

1937

1439

self.address_family = socket.AF_INET6

1938

if socketfd is not None:

1939

# Save the file descriptor

1940

self.socketfd = socketfd

1941

# Save the original socket.socket() function

1942

self.socket_socket = socket.socket

1943

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

1944

#

1945

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

1946

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

1947

# patching socket.socket.)

1948

#

1949

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

1950

@functools.wraps(socket.socket)

1951

def socket_wrapper(*args, **kwargs):

1952

# Restore original function so subsequent calls are

1953

# not affected.

1954

socket.socket = self.socket_socket

1955

del self.socket_socket

1956

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

1957

# saved file descriptor.

1958

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

1959

# Replace socket.socket() function with wrapper

1960

socket.socket = socket_wrapper

1961

# The socketserver.TCPServer.__init__ will call

1962

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

1963

# socket_wrapper(), if socketfd was set.

1964

1440

socketserver.TCPServer.__init__(self, server_address,

1965

1441

RequestHandlerClass)

1966

1967

1442

def server_bind(self):

1968

1443

"""This overrides the normal server_bind() function

1969

1444

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

1977

1452

try:

1978

1453

self.socket.setsockopt(socket.SOL_SOCKET,

1979

1454

SO_BINDTODEVICE,

1980

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

1455

str(self.interface

1456

+ '\0'))

1981

1457

except socket.error as error:

1982

if error.errno == errno.EPERM:

1983

logger.error("No permission to bind to"

1984

" interface %s", self.interface)

1985

elif error.errno == errno.ENOPROTOOPT:

1458

if error[0] == errno.EPERM:

1459

logger.error("No permission to"

1460

" bind to interface %s",

1461

self.interface)

1462

elif error[0] == errno.ENOPROTOOPT:

1986

1463

logger.error("SO_BINDTODEVICE not available;"

1987

1464

" cannot bind to interface %s",

1988

1465

self.interface)

1989

elif error.errno == errno.ENODEV:

1990

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

1991

" cannot bind", self.interface)

1992

1466

else:

1993

1467

raise

1994

1468

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

1997

1471

if self.address_family == socket.AF_INET6:

1998

1472

any_address = "::" # in6addr_any

1999

1473

else:

2000

any_address = "0.0.0.0" # INADDR_ANY

1474

any_address = socket.INADDR_ANY

2001

1475

self.server_address = (any_address,

2002

1476

self.server_address[1])

2003

1477

elif not self.server_address[1]:

2024

1498

"""

2025

1499

def __init__(self, server_address, RequestHandlerClass,

2026

1500

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

2027

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

1501

gnutls_priority=None, use_dbus=True):

2028

1502

self.enabled = False

2029

1503

self.clients = clients

2030

1504

if self.clients is None:

2031

self.clients = {}

1505

self.clients = set()

2032

1506

self.use_dbus = use_dbus

2033

1507

self.gnutls_priority = gnutls_priority

2034

1508

IPv6_TCPServer.__init__(self, server_address,

2035

1509

RequestHandlerClass,

2036

1510

interface = interface,

2037

use_ipv6 = use_ipv6,

2038

socketfd = socketfd)

1511

use_ipv6 = use_ipv6)

2039

1512

def server_activate(self):

2040

1513

if self.enabled:

2041

1514

return socketserver.TCPServer.server_activate(self)

2042

2043

1515

def enable(self):

2044

1516

self.enabled = True

2045

2046

def add_pipe(self, parent_pipe, proc):

1517

def add_pipe(self, parent_pipe):

2047

1518

# Call "handle_ipc" for both data and EOF events

2048

1519

gobject.io_add_watch(parent_pipe.fileno(),

2049

1520

gobject.IO_IN | gobject.IO_HUP,

2050

1521

functools.partial(self.handle_ipc,

2051

parent_pipe =

2052

parent_pipe,

2053

proc = proc))

2054

1522

parent_pipe = parent_pipe))

1523

2055

1524

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

2056

proc = None, client_object=None):

2057

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

2058

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

2059

# Wait for other process to exit

2060

proc.join()

1525

client_object=None):

1526

condition_names = {

1527

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

1528

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

1529

# blocking).

1530

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

1531

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

1532

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

1533

# broken, usually for pipes and

1534

# sockets).

1535

}

1536

conditions_string = ' | '.join(name

1537

for cond, name in

1538

condition_names.iteritems()

1539

if cond & condition)

1540

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

1541

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

2061

1542

return False

2062

1543

2063

1544

# Read a request from the child

2068

1549

fpr = request[1]

2069

1550

address = request[2]

2070

1551

2071

for c in self.clients.itervalues():

1552

for c in self.clients:

2072

1553

if c.fingerprint == fpr:

2073

1554

client = c

2074

1555

break

2077

1558

"dress: %s", fpr, address)

2078

1559

if self.use_dbus:

2079

1560

# Emit D-Bus signal

2080

mandos_dbus_service.ClientNotFound(fpr,

2081

address[0])

1561

mandos_dbus_service.ClientNotFound(fpr, address[0])

2082

1562

parent_pipe.send(False)

2083

1563

return False

2084

1564

2085

1565

gobject.io_add_watch(parent_pipe.fileno(),

2086

1566

gobject.IO_IN | gobject.IO_HUP,

2087

1567

functools.partial(self.handle_ipc,

2088

parent_pipe =

2089

parent_pipe,

2090

proc = proc,

2091

client_object =

2092

client))

1568

parent_pipe = parent_pipe,

1569

client_object = client))

2093

1570

parent_pipe.send(True)

2094

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

2095

# same fileno

1571

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

2096

1572

return False

2097

1573

if command == 'funcall':

2098

1574

funcname = request[1]

2099

1575

args = request[2]

2100

1576

kwargs = request[3]

2101

1577

2102

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

2103

funcname)(*args,

2104

**kwargs)))

2105

1578

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

1579

2106

1580

if command == 'getattr':

2107

1581

attrname = request[1]

2108

1582

if callable(client_object.__getattribute__(attrname)):

2109

1583

parent_pipe.send(('function',))

2110

1584

else:

2111

parent_pipe.send(('data', client_object

2112

.__getattribute__(attrname)))

1585

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

2113

1586

2114

1587

if command == 'setattr':

2115

1588

attrname = request[1]

2116

1589

value = request[2]

2117

1590

setattr(client_object, attrname, value)

2118

1591

2119

1592

return True

2120

1593

2121

1594

2122

def rfc3339_duration_to_delta(duration):

2123

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

2124

2125

>>> rfc3339_duration_to_delta("P7D")

2126

datetime.timedelta(7)

2127

>>> rfc3339_duration_to_delta("PT60S")

2128

datetime.timedelta(0, 60)

2129

>>> rfc3339_duration_to_delta("PT60M")

2130

datetime.timedelta(0, 3600)

2131

>>> rfc3339_duration_to_delta("PT24H")

2132

datetime.timedelta(1)

2133

>>> rfc3339_duration_to_delta("P1W")

2134

datetime.timedelta(7)

2135

>>> rfc3339_duration_to_delta("PT5M30S")

2136

datetime.timedelta(0, 330)

2137

>>> rfc3339_duration_to_delta("P1DT3M20S")

2138

datetime.timedelta(1, 200)

2139

"""

2140

2141

# Parsing an RFC 3339 duration with regular expressions is not

2142

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

2143

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

2144

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

2145

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

2146

# avoid excessive use of external libraries.

2147

2148

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

2149

Token = collections.namedtuple("Token",

2150

("regexp", # To match token; if

2151

# "value" is not None,

2152

# must have a "group"

2153

# containing digits

2154

"value", # datetime.timedelta or

2155

# None

2156

"followers")) # Tokens valid after

2157

# this token

2158

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

2159

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

2160

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

2161

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

2162

datetime.timedelta(seconds=1),

2163

frozenset((token_end,)))

2164

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

2165

datetime.timedelta(minutes=1),

2166

frozenset((token_second, token_end)))

2167

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

2168

datetime.timedelta(hours=1),

2169

frozenset((token_minute, token_end)))

2170

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

2171

None,

2172

frozenset((token_hour, token_minute,

2173

token_second)))

2174

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

2175

datetime.timedelta(days=1),

2176

frozenset((token_time, token_end)))

2177

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

2178

datetime.timedelta(weeks=4),

2179

frozenset((token_day, token_end)))

2180

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

2181

datetime.timedelta(weeks=52),

2182

frozenset((token_month, token_end)))

2183

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

2184

datetime.timedelta(weeks=1),

2185

frozenset((token_end,)))

2186

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

2187

frozenset((token_year, token_month,

2188

token_day, token_time,

2189

token_week))),

2190

# Define starting values

2191

value = datetime.timedelta() # Value so far

2192

found_token = None

2193

followers = frozenset(token_duration,) # Following valid tokens

2194

s = duration # String left to parse

2195

# Loop until end token is found

2196

while found_token is not token_end:

2197

# Search for any currently valid tokens

2198

for token in followers:

2199

match = token.regexp.match(s)

2200

if match is not None:

2201

# Token found

2202

if token.value is not None:

2203

# Value found, parse digits

2204

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

2205

# Add to value so far

2206

value += factor * token.value

2207

# Strip token from string

2208

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

2209

# Go to found token

2210

found_token = token

2211

# Set valid next tokens

2212

followers = found_token.followers

2213

break

2214

else:

2215

# No currently valid tokens were found

2216

raise ValueError("Invalid RFC 3339 duration")

2217

# End token found

2218

return value

2219

2220

2221

1595

def string_to_delta(interval):

2222

1596

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

2223

1597

2234

1608

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

2235

1609

datetime.timedelta(0, 330)

2236

1610

"""

2237

2238

try:

2239

return rfc3339_duration_to_delta(interval)

2240

except ValueError:

2241

pass

2242

2243

1611

timevalue = datetime.timedelta(0)

2244

1612

for s in interval.split():

2245

1613

try:

2256

1624

elif suffix == "w":

2257

1625

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

2258

1626

else:

2259

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

2260

.format(suffix))

1627

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

2261

1628

except (ValueError, IndexError) as e:

2262

1629

raise ValueError(*(e.args))

2263

1630

timevalue += delta

2264

1631

return timevalue

2265

1632

2266

1633

1634

def if_nametoindex(interface):

1635

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

1636

1637

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

1638

global if_nametoindex

1639

try:

1640

if_nametoindex = (ctypes.cdll.LoadLibrary

1641

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

1642

.if_nametoindex)

1643

except (OSError, AttributeError):

1644

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

1645

def if_nametoindex(interface):

1646

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

1647

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

1648

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

1649

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1650

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

1651

interface))

1652

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

1653

ifreq[16:20])[0]

1654

return interface_index

1655

return if_nametoindex(interface)

1656

1657

2267

1658

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

2268

1659

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

2269

1660

2277

1668

sys.exit()

2278

1669

if not noclose:

2279

1670

# Close all standard open file descriptors

2280

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

1671

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

2281

1672

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

2282

1673

raise OSError(errno.ENODEV,

2283

"{0} not a character device"

2284

.format(os.devnull))

1674

"%s not a character device"

1675

% os.path.devnull)

2285

1676

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

2286

1677

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

2287

1678

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

2296

1687

2297

1688

parser = argparse.ArgumentParser()

2298

1689

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

2299

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

1690

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

2300

1691

help="show version number and exit")

2301

1692

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

2302

1693

help="Bind to interface IF")

2308

1699

help="Run self-test")

2309

1700

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

2310

1701

help="Debug mode; run in foreground and log"

2311

" to terminal", default=None)

1702

" to terminal")

2312

1703

parser.add_argument("--debuglevel", metavar="LEVEL",

2313

1704

help="Debug level for stdout output")

2314

1705

parser.add_argument("--priority", help="GnuTLS"

2321

1712

" files")

2322

1713

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

2323

1714

dest="use_dbus", help="Do not provide D-Bus"

2324

" system bus interface", default=None)

1715

" system bus interface")

2325

1716

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

2326

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

2327

default=None)

2328

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

2329

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

2330

" state", default=None)

2331

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

2332

help="Specify a file descriptor to a network"

2333

" socket to use instead of creating one")

2334

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

2335

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

2336

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

2337

help="Run in foreground", default=None)

2338

1717

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

2339

1718

options = parser.parse_args()

2340

1719

2341

1720

if options.check:

2349

1728

"port": "",

2350

1729

"debug": "False",

2351

1730

"priority":

2352

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

1731

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",

2353

1732

"servicename": "Mandos",

2354

1733

"use_dbus": "True",

2355

1734

"use_ipv6": "True",

2356

1735

"debuglevel": "",

2357

"restore": "True",

2358

"socket": "",

2359

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

2360

"foreground": "False",

2361

1736

}

2362

1737

2363

1738

# Parse config file for server-global settings

2368

1743

# Convert the SafeConfigParser object to a dict

2369

1744

server_settings = server_config.defaults()

2370

1745

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

2371

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

1746

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

2372

1747

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

2373

1748

option)

2374

1749

if server_settings["port"]:

2375

1750

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

2376

1751

"port")

2377

if server_settings["socket"]:

2378

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

2379

"socket")

2380

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

2381

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

2382

# happen with a supplied network socket.

2383

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

2384

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

2385

["socket"])

2386

1752

del server_config

2387

1753

2388

1754

# Override the settings from the config file with command line

2389

1755

# options, if set.

2390

1756

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

2391

1757

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

2392

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

2393

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

1758

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

2394

1759

value = getattr(options, option)

2395

1760

if value is not None:

2396

1761

server_settings[option] = value

2399

1764

for option in server_settings.keys():

2400

1765

if type(server_settings[option]) is str:

2401

1766

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

2402

# Force all boolean options to be boolean

2403

for option in ("debug", "use_dbus", "use_ipv6", "restore",

2404

"foreground"):

2405

server_settings[option] = bool(server_settings[option])

2406

# Debug implies foreground

2407

if server_settings["debug"]:

2408

server_settings["foreground"] = True

2409

1767

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

2410

1768

2411

1769

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

2415

1773

debuglevel = server_settings["debuglevel"]

2416

1774

use_dbus = server_settings["use_dbus"]

2417

1775

use_ipv6 = server_settings["use_ipv6"]

2418

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

2419

stored_state_file)

2420

foreground = server_settings["foreground"]

2421

2422

if debug:

2423

initlogger(debug, logging.DEBUG)

2424

else:

2425

if not debuglevel:

2426

initlogger(debug)

2427

else:

2428

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

2429

initlogger(debug, level)

2430

1776

2431

1777

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

2432

1778

syslogger.setFormatter(logging.Formatter

2433

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

2434

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

2435

.format(server_settings

2436

["servicename"])))

1779

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

1780

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

1781

% server_settings["servicename"]))

2437

1782

2438

1783

# Parse config file with clients

2439

client_config = configparser.SafeConfigParser(Client

2440

.client_defaults)

1784

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

1785

"extended_timeout": "15m",

1786

"interval": "2m",

1787

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

1788

"host": "",

1789

"approval_delay": "0s",

1790

"approval_duration": "1s",

1791

}

1792

client_config = configparser.SafeConfigParser(client_defaults)

2441

1793

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

2442

1794

"clients.conf"))

2443

1795

2452

1804

use_ipv6=use_ipv6,

2453

1805

gnutls_priority=

2454

1806

server_settings["priority"],

2455

use_dbus=use_dbus,

2456

socketfd=(server_settings["socket"]

2457

or None))

2458

if not foreground:

2459

pidfilename = "/run/mandos.pid"

2460

pidfile = None

1807

use_dbus=use_dbus)

1808

if not debug:

1809

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

2461

1810

try:

2462

1811

pidfile = open(pidfilename, "w")

2463

except IOError as e:

2464

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

2465

exc_info=e)

1812

except IOError:

1813

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

2466

1814

2467

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

1815

try:

1816

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

1817

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

1818

except KeyError:

2468

1819

try:

2469

uid = pwd.getpwnam(name).pw_uid

2470

gid = pwd.getpwnam(name).pw_gid

2471

break

1820

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

1821

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

2472

1822

except KeyError:

2473

continue

2474

else:

2475

uid = 65534

2476

gid = 65534

1823

try:

1824

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

1825

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

1826

except KeyError:

1827

uid = 65534

1828

gid = 65534

2477

1829

try:

2478

1830

os.setgid(gid)

2479

1831

os.setuid(uid)

2480

1832

except OSError as error:

2481

if error.errno != errno.EPERM:

1833

if error[0] != errno.EPERM:

2482

1834

raise error

2483

1835

1836

if not debug and not debuglevel:

1837

syslogger.setLevel(logging.WARNING)

1838

console.setLevel(logging.WARNING)

1839

if debuglevel:

1840

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

1841

syslogger.setLevel(level)

1842

console.setLevel(level)

1843

2484

1844

if debug:

2485

1845

# Enable all possible GnuTLS debugging

2486

1846

2496

1856

.gnutls_global_set_log_function(debug_gnutls))

2497

1857

2498

1858

# Redirect stdin so all checkers get /dev/null

2499

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

1859

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

2500

1860

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

2501

1861

if null > 2:

2502

1862

os.close(null)

1863

else:

1864

# No console logging

1865

logger.removeHandler(console)

2503

1866

2504

1867

# Need to fork before connecting to D-Bus

2505

if not foreground:

1868

if not debug:

2506

1869

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

2507

1870

daemon()

2508

1871

2509

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

2510

# need to inform gobject that threads will be used.

2511

gobject.threads_init()

2512

2513

1872

global main_loop

2514

1873

# From the Avahi example code

2515

DBusGMainLoop(set_as_default=True)

1874

DBusGMainLoop(set_as_default=True )

2516

1875

main_loop = gobject.MainLoop()

2517

1876

bus = dbus.SystemBus()

2518

1877

# End of Avahi example code

2519

1878

if use_dbus:

2520

1879

try:

2521

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

1880

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

2522

1881

bus, do_not_queue=True)

2523

old_bus_name = (dbus.service.BusName

2524

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

2525

do_not_queue=True))

2526

1882

except dbus.exceptions.NameExistsException as e:

2527

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

1883

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

2528

1884

use_dbus = False

2529

1885

server_settings["use_dbus"] = False

2530

1886

tcp_server.use_dbus = False

2531

1887

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2532

service = AvahiServiceToSyslog(name =

2533

server_settings["servicename"],

2534

servicetype = "_mandos._tcp",

2535

protocol = protocol, bus = bus)

1888

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

1889

servicetype = "_mandos._tcp",

1890

protocol = protocol, bus = bus)

2536

1891

if server_settings["interface"]:

2537

1892

service.interface = (if_nametoindex

2538

1893

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

2543

1898

client_class = Client

2544

1899

if use_dbus:

2545

1900

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

2546

2547

client_settings = Client.config_parser(client_config)

2548

old_client_settings = {}

2549

clients_data = {}

2550

2551

# This is used to redirect stdout and stderr for checker processes

2552

global wnull

2553

wnull = open(os.devnull, "w") # A writable /dev/null

2554

# Only used if server is running in foreground but not in debug

2555

# mode

2556

if debug or not foreground:

2557

wnull.close()

2558

2559

# Get client data and settings from last running state.

2560

if server_settings["restore"]:

2561

try:

2562

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

2563

clients_data, old_client_settings = (pickle.load

2564

(stored_state))

2565

os.remove(stored_state_path)

2566

except IOError as e:

2567

if e.errno == errno.ENOENT:

2568

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

2569

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

2570

else:

2571

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

2572

exc_info=e)

2573

raise

2574

except EOFError as e:

2575

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

2576

"EOFError:", exc_info=e)

2577

2578

with PGPEngine() as pgp:

2579

for client_name, client in clients_data.iteritems():

2580

# Skip removed clients

2581

if client_name not in client_settings:

2582

continue

2583

2584

# Decide which value to use after restoring saved state.

2585

# We have three different values: Old config file,

2586

# new config file, and saved state.

2587

# New config value takes precedence if it differs from old

2588

# config value, otherwise use saved state.

2589

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

2590

try:

2591

# For each value in new config, check if it

2592

# differs from the old config value (Except for

2593

# the "secret" attribute)

2594

if (name != "secret" and

2595

value != old_client_settings[client_name]

2596

[name]):

2597

client[name] = value

2598

except KeyError:

2599

pass

2600

2601

# Clients who has passed its expire date can still be

2602

# enabled if its last checker was successful. Clients

2603

# whose checker succeeded before we stored its state is

2604

# assumed to have successfully run all checkers during

2605

# downtime.

2606

if client["enabled"]:

2607

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

2608

if not client["last_checked_ok"]:

2609

logger.warning(

2610

"disabling client {0} - Client never "

2611

"performed a successful checker"

2612

.format(client_name))

2613

client["enabled"] = False

2614

elif client["last_checker_status"] != 0:

2615

logger.warning(

2616

"disabling client {0} - Client "

2617

"last checker failed with error code {1}"

2618

.format(client_name,

2619

client["last_checker_status"]))

2620

client["enabled"] = False

2621

else:

2622

client["expires"] = (datetime.datetime

2623

.utcnow()

2624

+ client["timeout"])

2625

logger.debug("Last checker succeeded,"

2626

" keeping {0} enabled"

2627

.format(client_name))

1901

def client_config_items(config, section):

1902

special_settings = {

1903

"approved_by_default":

1904

lambda: config.getboolean(section,

1905

"approved_by_default"),

1906

}

1907

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

2628

1908

try:

2629

client["secret"] = (

2630

pgp.decrypt(client["encrypted_secret"],

2631

client_settings[client_name]

2632

["secret"]))

2633

except PGPError:

2634

# If decryption fails, we use secret from new settings

2635

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

2636

.format(client_name))

2637

client["secret"] = (

2638

client_settings[client_name]["secret"])

2639

2640

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

2641

for client_name in (set(old_client_settings)

2642

- set(client_settings)):

2643

del clients_data[client_name]

2644

for client_name in (set(client_settings)

2645

- set(old_client_settings)):

2646

clients_data[client_name] = client_settings[client_name]

2647

2648

# Create all client objects

2649

for client_name, client in clients_data.iteritems():

2650

tcp_server.clients[client_name] = client_class(

2651

name = client_name, settings = client,

2652

server_settings = server_settings)

2653

1909

yield (name, special_settings[name]())

1910

except KeyError:

1911

yield (name, value)

1912

1913

tcp_server.clients.update(set(

1914

client_class(name = section,

1915

config= dict(client_config_items(

1916

client_config, section)))

1917

for section in client_config.sections()))

2654

1918

if not tcp_server.clients:

2655

1919

logger.warning("No clients defined")

2656

2657

if not foreground:

2658

if pidfile is not None:

2659

try:

2660

with pidfile:

2661

pid = os.getpid()

2662

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

2663

except IOError:

2664

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

2665

pidfilename, pid)

2666

del pidfile

1920

1921

if not debug:

1922

try:

1923

with pidfile:

1924

pid = os.getpid()

1925

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

1926

del pidfile

1927

except IOError:

1928

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

1929

pidfilename, pid)

1930

except NameError:

1931

# "pidfile" was never created

1932

pass

2667

1933

del pidfilename

2668

1934

1935

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

1936

2669

1937

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

2670

1938

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

2671

1939

2672

1940

if use_dbus:

2673

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

2674

"se.bsnet.fukt.Mandos"})

2675

class MandosDBusService(DBusObjectWithProperties):

1941

class MandosDBusService(dbus.service.Object):

2676

1942

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

2677

1943

def __init__(self):

2678

1944

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

2679

_interface = "se.recompile.Mandos"

2680

2681

@dbus_interface_annotations(_interface)

2682

def _foo(self):

2683

return { "org.freedesktop.DBus.Property"

2684

".EmitsChangedSignal":

2685

"false"}

1945

_interface = "se.bsnet.fukt.Mandos"

2686

1946

2687

1947

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

2688

1948

def ClientAdded(self, objpath):

2703

1963

def GetAllClients(self):

2704

1964

"D-Bus method"

2705

1965

return dbus.Array(c.dbus_object_path

2706

for c in

2707

tcp_server.clients.itervalues())

1966

for c in tcp_server.clients)

2708

1967

2709

1968

@dbus.service.method(_interface,

2710

1969

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

2712

1971

"D-Bus method"

2713

1972

return dbus.Dictionary(

2714

1973

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

2715

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

1974

for c in tcp_server.clients),

2716

1975

signature="oa{sv}")

2717

1976

2718

1977

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

2719

1978

def RemoveClient(self, object_path):

2720

1979

"D-Bus method"

2721

for c in tcp_server.clients.itervalues():

1980

for c in tcp_server.clients:

2722

1981

if c.dbus_object_path == object_path:

2723

del tcp_server.clients[c.name]

1982

tcp_server.clients.remove(c)

2724

1983

c.remove_from_connection()

2725

1984

# Don't signal anything except ClientRemoved

2726

1985

c.disable(quiet=True)

2737

1996

"Cleanup function; run on exit"

2738

1997

service.cleanup()

2739

1998

2740

multiprocessing.active_children()

2741

wnull.close()

2742

if not (tcp_server.clients or client_settings):

2743

return

2744

2745

# Store client before exiting. Secrets are encrypted with key

2746

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

2747

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

2748

clients = {}

2749

with PGPEngine() as pgp:

2750

for client in tcp_server.clients.itervalues():

2751

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

2752

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

2753

key)

2754

client_dict = {}

2755

2756

# A list of attributes that can not be pickled

2757

# + secret.

2758

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

2759

"checker", "server_settings"))

2760

for name, typ in (inspect.getmembers

2761

(dbus.service.Object)):

2762

exclude.add(name)

2763

2764

client_dict["encrypted_secret"] = (client

2765

.encrypted_secret)

2766

for attr in client.client_structure:

2767

if attr not in exclude:

2768

client_dict[attr] = getattr(client, attr)

2769

2770

clients[client.name] = client_dict

2771

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

2772

2773

try:

2774

with (tempfile.NamedTemporaryFile

2775

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

2776

dir=os.path.dirname(stored_state_path),

2777

delete=False)) as stored_state:

2778

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

2779

tempname=stored_state.name

2780

os.rename(tempname, stored_state_path)

2781

except (IOError, OSError) as e:

2782

if not debug:

2783

try:

2784

os.remove(tempname)

2785

except NameError:

2786

pass

2787

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

2788

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

2789

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

2790

else:

2791

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

2792

exc_info=e)

2793

raise e

2794

2795

# Delete all clients, and settings from config

2796

1999

while tcp_server.clients:

2797

name, client = tcp_server.clients.popitem()

2000

client = tcp_server.clients.pop()

2798

2001

if use_dbus:

2799

2002

client.remove_from_connection()

2003

client.disable_hook = None

2800

2004

# Don't signal anything except ClientRemoved

2801

2005

client.disable(quiet=True)

2802

2006

if use_dbus:

2803

2007

# Emit D-Bus signal

2804

mandos_dbus_service.ClientRemoved(client

2805

.dbus_object_path,

2008

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2806

2009

client.name)

2807

client_settings.clear()

2808

2010

2809

2011

atexit.register(cleanup)

2810

2012

2811

for client in tcp_server.clients.itervalues():

2013

for client in tcp_server.clients:

2812

2014

if use_dbus:

2813

2015

# Emit D-Bus signal

2814

2016

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2815

# Need to initiate checking of clients

2816

if client.enabled:

2817

client.init_checker()

2017

client.enable()

2818

2018

2819

2019

tcp_server.enable()

2820

2020

tcp_server.server_activate()

2823

2023

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

2824

2024

if use_ipv6:

2825

2025

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

2826

" flowinfo %d, scope_id %d",

2827

*tcp_server.socket.getsockname())

2026

" flowinfo %d, scope_id %d"

2027

% tcp_server.socket.getsockname())

2828

2028

else: # IPv4

2829

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

2830

*tcp_server.socket.getsockname())

2029

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

2030

% tcp_server.socket.getsockname())

2831

2031

2832

2032

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

2833

2033

2836

2036

try:

2837

2037

service.activate()

2838

2038

except dbus.exceptions.DBusException as error:

2839

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

2039

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

2840

2040

cleanup()

2841

2041

sys.exit(1)

2842

2042

# End of Avahi example code

2849

2049

logger.debug("Starting main loop")

2850

2050

main_loop.run()

2851

2051

except AvahiError as error:

2852

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

2052

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

2853

2053

cleanup()

2854

2054

sys.exit(1)

2855

2055

except KeyboardInterrupt: