/mandos/trunk : revision 482

11

# "AvahiService" class, and some lines in "main".

12

#

13

# Everything else is

14

15

14

15

16

#

17

# This program is free software: you can redistribute it and/or modify

18

# it under the terms of the GNU General Public License as published by

28

# along with this program. If not, see

29

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

30

#

31

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

31

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

32

#

33

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

64

62

import functools

65

63

import cPickle as pickle

66

64

import multiprocessing

67

import types

68

import binascii

69

import tempfile

70

import itertools

71

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

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

84

85

version = "1.3.0"

86

87

#logger = logging.getLogger('mandos')

88

logger = logging.Logger('mandos')

95

89

syslogger = (logging.handlers.SysLogHandler

96

90

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

97

91

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

98

99

try:

100

if_nametoindex = (ctypes.cdll.LoadLibrary

101

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

102

.if_nametoindex)

103

except (OSError, AttributeError):

104

def if_nametoindex(interface):

105

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

106

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

107

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

108

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

109

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

110

interface))

111

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

112

ifreq[16:20])[0]

113

return interface_index

114

115

116

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

117

"""init logger and add loglevel"""

118

119

syslogger.setFormatter(logging.Formatter

120

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

121

' %(message)s'))

122

logger.addHandler(syslogger)

123

124

if debug:

125

console = logging.StreamHandler()

126

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

127

' [%(process)d]:'

128

' %(levelname)s:'

129

' %(message)s'))

130

logger.addHandler(console)

131

logger.setLevel(level)

132

133

134

class PGPError(Exception):

135

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

136

pass

137

138

139

class PGPEngine(object):

140

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

141

def __init__(self):

142

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

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

176

177

def encrypt(self, data, password):

178

passphrase = self.password_encode(password)

179

with tempfile.NamedTemporaryFile(dir=self.tempdir

180

) as passfile:

181

passfile.write(passphrase)

182

passfile.flush()

183

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

184

'--passphrase-file',

185

passfile.name]

186

+ self.gnupgargs,

187

stdin = subprocess.PIPE,

188

stdout = subprocess.PIPE,

189

stderr = subprocess.PIPE)

190

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

191

if proc.returncode != 0:

192

raise PGPError(err)

193

return ciphertext

194

195

def decrypt(self, data, password):

196

passphrase = self.password_encode(password)

197

with tempfile.NamedTemporaryFile(dir = self.tempdir

198

) as passfile:

199

passfile.write(passphrase)

200

passfile.flush()

201

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

202

'--passphrase-file',

203

passfile.name]

204

+ self.gnupgargs,

205

stdin = subprocess.PIPE,

206

stdout = subprocess.PIPE,

207

stderr = subprocess.PIPE)

208

decrypted_plaintext, err = proc.communicate(input

209

= data)

210

if proc.returncode != 0:

211

raise PGPError(err)

212

return decrypted_plaintext

213

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)

214

102

215

103

class AvahiError(Exception):

216

104

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

234

122

Used to optionally bind to the specified interface.

235

123

name: string; Example: 'Mandos'

236

124

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

237

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

125

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

238

126

port: integer; what port to announce

239

127

TXT: list of strings; TXT record for the service

240

128

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

246

134

server: D-Bus Server

247

135

bus: dbus.SystemBus()

248

136

"""

249

250

137

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

251

138

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

252

139

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

265

152

self.server = None

266

153

self.bus = bus

267

154

self.entry_group_state_changed_match = None

268

269

155

def rename(self):

270

156

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

271

157

if self.rename_count >= self.max_renames:

273

159

" after %i retries, exiting.",

274

160

self.rename_count)

275

161

raise AvahiServiceError("Too many renames")

276

self.name = unicode(self.server

277

.GetAlternativeServiceName(self.name))

162

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

278

163

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

279

164

self.name)

165

syslogger.setFormatter(logging.Formatter

166

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

167

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

168

% self.name))

280

169

self.remove()

281

170

try:

282

171

self.add()

283

172

except dbus.exceptions.DBusException as error:

284

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

173

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

285

174

self.cleanup()

286

175

os._exit(1)

287

176

self.rename_count += 1

288

289

177

def remove(self):

290

178

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

179

if self.group is not None:

180

try:

181

self.group.Free()

182

except (dbus.exceptions.UnknownMethodException,

183

dbus.exceptions.DBusException) as e:

184

pass

185

self.group = None

291

186

if self.entry_group_state_changed_match is not None:

292

187

self.entry_group_state_changed_match.remove()

293

188

self.entry_group_state_changed_match = None

294

if self.group is not None:

295

self.group.Reset()

296

297

189

def add(self):

298

190

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

299

191

self.remove()

300

if self.group is None:

301

self.group = dbus.Interface(

302

self.bus.get_object(avahi.DBUS_NAME,

303

self.server.EntryGroupNew()),

304

avahi.DBUS_INTERFACE_ENTRY_GROUP)

192

self.group = dbus.Interface(

193

self.bus.get_object(avahi.DBUS_NAME,

194

self.server.EntryGroupNew(),

195

follow_name_owner_changes=True),

196

avahi.DBUS_INTERFACE_ENTRY_GROUP)

305

197

self.entry_group_state_changed_match = (

306

198

self.group.connect_to_signal(

307

'StateChanged', self.entry_group_state_changed))

199

'StateChanged', self .entry_group_state_changed))

308

200

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

309

201

self.name, self.type)

310

202

self.group.AddService(

316

208

dbus.UInt16(self.port),

317

209

avahi.string_array_to_txt_array(self.TXT))

318

210

self.group.Commit()

319

320

211

def entry_group_state_changed(self, state, error):

321

212

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

322

213

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

329

220

elif state == avahi.ENTRY_GROUP_FAILURE:

330

221

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

331

222

unicode(error))

332

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

333

.format(error))

334

223

raise AvahiGroupError("State changed: %s"

224

% unicode(error))

335

225

def cleanup(self):

336

226

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

337

if self.group is not None:

338

try:

339

self.group.Free()

340

except (dbus.exceptions.UnknownMethodException,

341

dbus.exceptions.DBusException):

342

pass

343

self.group = None

344

227

self.remove()

345

346

228

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

347

229

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

348

230

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

354

236

avahi.SERVER_FAILURE:

355

237

"Zeroconf server failure" }

356

238

if state in bad_states:

357

if bad_states[state] is not None:

358

if error is None:

359

logger.error(bad_states[state])

360

else:

361

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

362

self.cleanup()

239

if bad_states[state]:

240

logger.error(bad_states[state])

241

self.remove()

363

242

elif state == avahi.SERVER_RUNNING:

364

243

self.add()

365

244

else:

366

if error is None:

367

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

368

else:

369

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

370

245

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

371

246

def activate(self):

372

247

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

373

248

if self.server is None:

381

256

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

382

257

383

258

384

class AvahiServiceToSyslog(AvahiService):

385

def rename(self):

386

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

387

ret = AvahiService.rename(self)

388

syslogger.setFormatter(logging.Formatter

389

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

390

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

391

.format(self.name)))

392

return ret

393

394

395

def timedelta_to_milliseconds(td):

396

"Convert a datetime.timedelta() to milliseconds"

397

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

398

+ (td.seconds * 1000)

399

+ (td.microseconds // 1000))

400

401

402

259

class Client(object):

403

260

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

404

261

405

262

Attributes:

406

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

263

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

407

264

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

408

265

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

409

266

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

416

273

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

417

274

checker_initiator_tag: a gobject event source tag, or None

418

275

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

419

client_structure: Object describing what attributes a client has

420

and is used for storing the client at exit

421

276

current_checker_command: string; current running checker_command

277

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

422

278

disable_initiator_tag: a gobject event source tag, or None

423

279

enabled: bool()

424

280

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

427

283

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

428

284

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

429

285

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

430

last_checker_status: integer between 0 and 255 reflecting exit

431

status of last checker. -1 reflects crashed

432

checker, -2 means no checker completed yet.

433

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

286

last_enabled: datetime.datetime(); (UTC)

434

287

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

435

288

D-Bus identifiers

436

289

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

437

290

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

438

291

until this client is disabled

439

extended_timeout: extra long timeout when secret has been sent

440

292

runtime_expansions: Allowed attributes for runtime expansion.

441

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

442

disabled, or None

443

server_settings: The server_settings dict from main()

444

293

"""

445

294

446

295

runtime_expansions = ("approval_delay", "approval_duration",

447

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

448

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

449

"last_approval_request", "last_checked_ok",

296

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

297

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

450

298

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

451

client_defaults = { "timeout": "PT5M",

452

"extended_timeout": "PT15M",

453

"interval": "PT2M",

454

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

455

"host": "",

456

"approval_delay": "PT0S",

457

"approval_duration": "PT1S",

458

"approved_by_default": "True",

459

"enabled": "True",

460

}

299

300

@staticmethod

301

def _timedelta_to_milliseconds(td):

302

"Convert a datetime.timedelta() to milliseconds"

303

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

304

+ (td.seconds * 1000)

305

+ (td.microseconds // 1000))

461

306

462

307

def timeout_milliseconds(self):

463

308

"Return the 'timeout' attribute in milliseconds"

464

return timedelta_to_milliseconds(self.timeout)

465

466

def extended_timeout_milliseconds(self):

467

"Return the 'extended_timeout' attribute in milliseconds"

468

return timedelta_to_milliseconds(self.extended_timeout)

309

return self._timedelta_to_milliseconds(self.timeout)

469

310

470

311

def interval_milliseconds(self):

471

312

"Return the 'interval' attribute in milliseconds"

472

return timedelta_to_milliseconds(self.interval)

473

313

return self._timedelta_to_milliseconds(self.interval)

314

474

315

def approval_delay_milliseconds(self):

475

return timedelta_to_milliseconds(self.approval_delay)

476

477

@staticmethod

478

def config_parser(config):

479

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

480

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

481

with exceptions for any special settings as defined above.

482

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

483

value given the same arguments.

484

"""

485

settings = {}

486

for client_name in config.sections():

487

section = dict(config.items(client_name))

488

client = settings[client_name] = {}

489

490

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

491

# Reformat values from string types to Python types

492

client["approved_by_default"] = config.getboolean(

493

client_name, "approved_by_default")

494

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

495

"enabled")

496

497

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

498

.replace(" ", ""))

499

if "secret" in section:

500

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

501

elif "secfile" in section:

502

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

503

(section["secfile"])),

504

"rb") as secfile:

505

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

506

else:

507

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

508

.format(section))

509

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

510

client["extended_timeout"] = string_to_delta(

511

section["extended_timeout"])

512

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

513

client["approval_delay"] = string_to_delta(

514

section["approval_delay"])

515

client["approval_duration"] = string_to_delta(

516

section["approval_duration"])

517

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

518

client["last_approval_request"] = None

519

client["last_checked_ok"] = None

520

client["last_checker_status"] = -2

521

522

return settings

523

524

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

316

return self._timedelta_to_milliseconds(self.approval_delay)

317

318

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

319

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

320

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

321

attribute."""

525

322

self.name = name

526

if server_settings is None:

527

server_settings = {}

528

self.server_settings = server_settings

529

# adding all client settings

530

for setting, value in settings.iteritems():

531

setattr(self, setting, value)

532

533

if self.enabled:

534

if not hasattr(self, "last_enabled"):

535

self.last_enabled = datetime.datetime.utcnow()

536

if not hasattr(self, "expires"):

537

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

538

+ self.timeout)

539

else:

540

self.last_enabled = None

541

self.expires = None

542

323

if config is None:

324

config = {}

543

325

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

544

326

# Uppercase and remove spaces from fingerprint for later

545

327

# comparison purposes with return value from the fingerprint()

546

328

# function

329

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

330

.replace(" ", ""))

547

331

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

548

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

549

datetime.datetime.utcnow())

550

551

# attributes specific for this server instance

332

if "secret" in config:

333

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

334

elif "secfile" in config:

335

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

336

(config["secfile"])),

337

"rb") as secfile:

338

self.secret = secfile.read()

339

else:

340

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

341

% self.name)

342

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

343

self.created = datetime.datetime.utcnow()

344

self.enabled = False

345

self.last_approval_request = None

346

self.last_enabled = None

347

self.last_checked_ok = None

348

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

349

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

350

self.disable_hook = disable_hook

552

351

self.checker = None

553

352

self.checker_initiator_tag = None

554

353

self.disable_initiator_tag = None

555

354

self.checker_callback_tag = None

355

self.checker_command = config["checker"]

556

356

self.current_checker_command = None

557

self.approved = None

357

self.last_connect = None

358

self._approved = None

359

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

360

True)

558

361

self.approvals_pending = 0

559

self.changedstate = (multiprocessing_manager

560

.Condition(multiprocessing_manager

561

.Lock()))

562

self.client_structure = [attr for attr in

563

self.__dict__.iterkeys()

564

if not attr.startswith("_")]

565

self.client_structure.append("client_structure")

566

567

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

568

lambda obj:

569

isinstance(obj,

570

property)):

571

if not name.startswith("_"):

572

self.client_structure.append(name)

362

self.approval_delay = string_to_delta(

363

config["approval_delay"])

364

self.approval_duration = string_to_delta(

365

config["approval_duration"])

366

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

573

367

574

# Send notice to process children that client state has changed

575

368

def send_changedstate(self):

576

with self.changedstate:

577

self.changedstate.notify_all()

578

369

self.changedstate.acquire()

370

self.changedstate.notify_all()

371

self.changedstate.release()

372

579

373

def enable(self):

580

374

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

581

375

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

582

376

# Already enabled

583

377

return

584

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

585

self.enabled = True

378

self.send_changedstate()

586

379

self.last_enabled = datetime.datetime.utcnow()

587

self.init_checker()

588

self.send_changedstate()

589

590

def disable(self, quiet=True):

591

"""Disable this client."""

592

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

593

return False

594

if not quiet:

595

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

596

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

597

gobject.source_remove(self.disable_initiator_tag)

598

self.disable_initiator_tag = None

599

self.expires = None

600

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

601

gobject.source_remove(self.checker_initiator_tag)

602

self.checker_initiator_tag = None

603

self.stop_checker()

604

self.enabled = False

605

if not quiet:

606

self.send_changedstate()

607

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

608

return False

609

610

def __del__(self):

611

self.disable()

612

613

def init_checker(self):

614

380

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

615

381

# and every interval from then on.

616

if self.checker_initiator_tag is not None:

617

gobject.source_remove(self.checker_initiator_tag)

618

382

self.checker_initiator_tag = (gobject.timeout_add

619

383

(self.interval_milliseconds(),

620

384

self.start_checker))

621

385

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

622

if self.disable_initiator_tag is not None:

623

gobject.source_remove(self.disable_initiator_tag)

624

386

self.disable_initiator_tag = (gobject.timeout_add

625

387

(self.timeout_milliseconds(),

626

388

self.disable))

389

self.enabled = True

627

390

# Also start a new checker *right now*.

628

391

self.start_checker()

629

392

393

def disable(self, quiet=True):

394

"""Disable this client."""

395

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

396

return False

397

if not quiet:

398

self.send_changedstate()

399

if not quiet:

400

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

401

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

402

gobject.source_remove(self.disable_initiator_tag)

403

self.disable_initiator_tag = None

404

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

405

gobject.source_remove(self.checker_initiator_tag)

406

self.checker_initiator_tag = None

407

self.stop_checker()

408

if self.disable_hook:

409

self.disable_hook(self)

410

self.enabled = False

411

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

412

return False

413

414

def __del__(self):

415

self.disable_hook = None

416

self.disable()

417

630

418

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

631

419

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

632

420

self.checker_callback_tag = None

633

421

self.checker = None

634

422

if os.WIFEXITED(condition):

635

self.last_checker_status = os.WEXITSTATUS(condition)

636

if self.last_checker_status == 0:

423

exitstatus = os.WEXITSTATUS(condition)

424

if exitstatus == 0:

637

425

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

638

426

vars(self))

639

427

self.checked_ok()

641

429

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

642

430

vars(self))

643

431

else:

644

self.last_checker_status = -1

645

432

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

646

433

vars(self))

647

434

648

435

def checked_ok(self):

649

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

436

"""Bump up the timeout for this client.

437

438

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

439

alive and well.

440

"""

650

441

self.last_checked_ok = datetime.datetime.utcnow()

651

self.last_checker_status = 0

652

self.bump_timeout()

653

654

def bump_timeout(self, timeout=None):

655

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

656

if timeout is None:

657

timeout = self.timeout

658

if self.disable_initiator_tag is not None:

659

gobject.source_remove(self.disable_initiator_tag)

660

self.disable_initiator_tag = None

661

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

662

self.disable_initiator_tag = (gobject.timeout_add

663

(timedelta_to_milliseconds

664

(timeout), self.disable))

665

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

442

gobject.source_remove(self.disable_initiator_tag)

443

self.disable_initiator_tag = (gobject.timeout_add

444

(self.timeout_milliseconds(),

445

self.disable))

666

446

667

447

def need_approval(self):

668

448

self.last_approval_request = datetime.datetime.utcnow()

673

453

If a checker already exists, leave it running and do

674

454

nothing."""

675

455

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

676

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

677

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

678

# would inevitably timeout, since no checker would get a

679

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

456

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

457

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

458

# client would inevitably timeout, since no checker would get

459

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

680

460

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

681

461

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

682

462

# should be.

696

476

self.current_checker_command)

697

477

# Start a new checker if needed

698

478

if self.checker is None:

699

# Escape attributes for the shell

700

escaped_attrs = dict(

701

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

702

for attr in

703

self.runtime_expansions)

704

479

try:

705

command = self.checker_command % escaped_attrs

706

except TypeError as error:

707

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

708

self.checker_command, exc_info=error)

709

return True # Try again later

480

# In case checker_command has exactly one % operator

481

command = self.checker_command % self.host

482

except TypeError:

483

# Escape attributes for the shell

484

escaped_attrs = dict(

485

(attr,

486

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

487

errors=

488

'replace')))

489

for attr in

490

self.runtime_expansions)

491

492

try:

493

command = self.checker_command % escaped_attrs

494

except TypeError as error:

495

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

496

' %s', self.checker_command, error)

497

return True # Try again later

710

498

self.current_checker_command = command

711

499

try:

712

500

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

715

503

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

716

504

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

717

505

# always replaced by /dev/null.)

718

# The exception is when not debugging but nevertheless

719

# running in the foreground; use the previously

720

# created wnull.

721

popen_args = {}

722

if (not self.server_settings["debug"]

723

and self.server_settings["foreground"]):

724

popen_args.update({"stdout": wnull,

725

"stderr": wnull })

726

506

self.checker = subprocess.Popen(command,

727

507

close_fds=True,

728

shell=True, cwd="/",

729

**popen_args)

730

except OSError as error:

731

logger.error("Failed to start subprocess",

732

exc_info=error)

733

return True

734

self.checker_callback_tag = (gobject.child_watch_add

735

(self.checker.pid,

736

self.checker_callback,

737

data=command))

738

# The checker may have completed before the gobject

739

# watch was added. Check for this.

740

try:

508

shell=True, cwd="/")

509

self.checker_callback_tag = (gobject.child_watch_add

510

(self.checker.pid,

511

self.checker_callback,

512

data=command))

513

# The checker may have completed before the gobject

514

# watch was added. Check for this.

741

515

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

516

if pid:

517

gobject.source_remove(self.checker_callback_tag)

518

self.checker_callback(pid, status, command)

742

519

except OSError as error:

743

if error.errno == errno.ECHILD:

744

# This should never happen

745

logger.error("Child process vanished",

746

exc_info=error)

747

return True

748

raise

749

if pid:

750

gobject.source_remove(self.checker_callback_tag)

751

self.checker_callback(pid, status, command)

520

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

521

error)

752

522

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

753

523

return True

754

524

761

531

return

762

532

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

763

533

try:

764

self.checker.terminate()

534

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

765

535

#time.sleep(0.5)

766

536

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

767

# self.checker.kill()

537

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

768

538

except OSError as error:

769

539

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

770

540

raise

771

541

self.checker = None

772

542

773

774

543

def dbus_service_property(dbus_interface, signature="v",

775

544

access="readwrite", byte_arrays=False):

776

545

"""Decorators for marking methods of a DBusObjectWithProperties to

787

556

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

788

557

if byte_arrays and signature != "ay":

789

558

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

790

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

559

" signature %r" % signature)

791

560

def decorator(func):

792

561

func._dbus_is_property = True

793

562

func._dbus_interface = dbus_interface

801

570

return decorator

802

571

803

572

804

def dbus_interface_annotations(dbus_interface):

805

"""Decorator for marking functions returning interface annotations

806

807

Usage:

808

809

@dbus_interface_annotations("org.example.Interface")

810

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

811

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

812

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

813

"false"}

814

"""

815

def decorator(func):

816

func._dbus_is_interface = True

817

func._dbus_interface = dbus_interface

818

func._dbus_name = dbus_interface

819

return func

820

return decorator

821

822

823

def dbus_annotations(annotations):

824

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

825

Usage:

826

827

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

828

access="r")

829

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

830

"org.freedesktop.DBus.Property."

831

"EmitsChangedSignal": "false"})

832

def Property_dbus_property(self):

833

return dbus.Boolean(False)

834

"""

835

def decorator(func):

836

func._dbus_annotations = annotations

837

return func

838

return decorator

839

840

841

573

class DBusPropertyException(dbus.exceptions.DBusException):

842

574

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

843

575

"""

859

591

860

592

class DBusObjectWithProperties(dbus.service.Object):

861

593

"""A D-Bus object with properties.

862

594

863

595

Classes inheriting from this can use the dbus_service_property

864

596

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

865

597

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

866

598

"""

867

599

868

600

@staticmethod

869

def _is_dbus_thing(thing):

870

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

871

872

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

873

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

874

"""

875

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

876

False)

601

def _is_dbus_property(obj):

602

return getattr(obj, "_dbus_is_property", False)

877

603

878

def _get_all_dbus_things(self, thing):

604

def _get_all_dbus_properties(self):

879

605

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

880

606

"""

881

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

882

name),

883

athing.__get__(self))

884

for cls in self.__class__.__mro__

885

for name, athing in

886

inspect.getmembers(cls,

887

self._is_dbus_thing(thing)))

607

return ((prop._dbus_name, prop)

608

for name, prop in

609

inspect.getmembers(self, self._is_dbus_property))

888

610

889

611

def _get_dbus_property(self, interface_name, property_name):

890

612

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

891

613

property with the specified name and interface.

892

614

"""

893

for cls in self.__class__.__mro__:

894

for name, value in (inspect.getmembers

895

(cls,

896

self._is_dbus_thing("property"))):

897

if (value._dbus_name == property_name

898

and value._dbus_interface == interface_name):

899

return value.__get__(self)

900

615

for name in (property_name,

616

property_name + "_dbus_property"):

617

prop = getattr(self, name, None)

618

if (prop is None

619

or not self._is_dbus_property(prop)

620

or prop._dbus_name != property_name

621

or (interface_name and prop._dbus_interface

622

and interface_name != prop._dbus_interface)):

623

continue

624

return prop

901

625

# No such property

902

626

raise DBusPropertyNotFound(self.dbus_object_path + ":"

903

627

+ interface_name + "."

928

652

# signatures other than "ay".

929

653

if prop._dbus_signature != "ay":

930

654

raise ValueError

931

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

932

for byte in value))

655

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

656

for byte in value))

933

657

prop(value)

934

658

935

659

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

937

661

def GetAll(self, interface_name):

938

662

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

939

663

standard.

940

664

941

665

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

942

666

"""

943

properties = {}

944

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

667

all = {}

668

for name, prop in self._get_all_dbus_properties():

945

669

if (interface_name

946

670

and interface_name != prop._dbus_interface):

947

671

# Interface non-empty but did not match

951

675

continue

952

676

value = prop()

953

677

if not hasattr(value, "variant_level"):

954

properties[name] = value

678

all[name] = value

955

679

continue

956

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

957

value.variant_level+1)

958

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

680

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

681

value.variant_level+1)

682

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

959

683

960

684

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

961

685

out_signature="s",

962

686

path_keyword='object_path',

963

687

connection_keyword='connection')

964

688

def Introspect(self, object_path, connection):

965

"""Overloading of standard D-Bus method.

966

967

Inserts property tags and interface annotation tags.

689

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

968

690

"""

969

691

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

970

692

connection)

977

699

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

978

700

return e

979

701

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

980

# Add property tags

981

702

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

982

703

for name, prop

983

in self._get_all_dbus_things("property")

704

in self._get_all_dbus_properties()

984

705

if prop._dbus_interface

985

706

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

986

707

if_tag.appendChild(tag)

987

# Add annotation tags

988

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

989

for tag in if_tag.getElementsByTagName(typ):

990

annots = dict()

991

for name, prop in (self.

992

_get_all_dbus_things(typ)):

993

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

994

and prop._dbus_interface

995

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

996

annots.update(getattr

997

(prop,

998

"_dbus_annotations",

999

{}))

1000

for name, value in annots.iteritems():

1001

ann_tag = document.createElement(

1002

"annotation")

1003

ann_tag.setAttribute("name", name)

1004

ann_tag.setAttribute("value", value)

1005

tag.appendChild(ann_tag)

1006

# Add interface annotation tags

1007

for annotation, value in dict(

1008

itertools.chain.from_iterable(

1009

annotations().iteritems()

1010

for name, annotations in

1011

self._get_all_dbus_things("interface")

1012

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

1013

)).iteritems():

1014

ann_tag = document.createElement("annotation")

1015

ann_tag.setAttribute("name", annotation)

1016

ann_tag.setAttribute("value", value)

1017

if_tag.appendChild(ann_tag)

1018

708

# Add the names to the return values for the

1019

709

# "org.freedesktop.DBus.Properties" methods

1020

710

if (if_tag.getAttribute("name")

1035

725

except (AttributeError, xml.dom.DOMException,

1036

726

xml.parsers.expat.ExpatError) as error:

1037

727

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

1038

exc_info=error)

728

error)

1039

729

return xmlstring

1040

730

1041

731

1042

def datetime_to_dbus(dt, variant_level=0):

1043

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

1044

if dt is None:

1045

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

1046

return dbus.String(dt.isoformat(),

1047

variant_level=variant_level)

1048

1049

1050

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1051

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

1052

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

1053

interface names according to the "alt_interface_names" mapping.

1054

Usage:

1055

1056

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

1057

"net.example.AlternateInterface"})

1058

class SampleDBusObject(dbus.service.Object):

1059

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

1060

def SampleDBusMethod():

1061

pass

1062

1063

The above "SampleDBusMethod" on "SampleDBusObject" will be

1064

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

1065

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

1066

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

1067

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

1068

1069

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

1070

(from DBusObjectWithProperties) and interfaces (from the

1071

dbus_interface_annotations decorator).

1072

"""

1073

def wrapper(cls):

1074

for orig_interface_name, alt_interface_name in (

1075

alt_interface_names.iteritems()):

1076

attr = {}

1077

interface_names = set()

1078

# Go though all attributes of the class

1079

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

1080

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

1081

# with the wrong interface name

1082

if (not hasattr(attribute, "_dbus_interface")

1083

or not attribute._dbus_interface

1084

.startswith(orig_interface_name)):

1085

continue

1086

# Create an alternate D-Bus interface name based on

1087

# the current name

1088

alt_interface = (attribute._dbus_interface

1089

.replace(orig_interface_name,

1090

alt_interface_name))

1091

interface_names.add(alt_interface)

1092

# Is this a D-Bus signal?

1093

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

1094

# Extract the original non-method undecorated

1095

# function by black magic

1096

nonmethod_func = (dict(

1097

zip(attribute.func_code.co_freevars,

1098

attribute.__closure__))["func"]

1099

.cell_contents)

1100

# Create a new, but exactly alike, function

1101

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

1102

# with the alternate D-Bus interface name

1103

new_function = (dbus.service.signal

1104

(alt_interface,

1105

attribute._dbus_signature)

1106

(types.FunctionType(

1107

nonmethod_func.func_code,

1108

nonmethod_func.func_globals,

1109

nonmethod_func.func_name,

1110

nonmethod_func.func_defaults,

1111

nonmethod_func.func_closure)))

1112

# Copy annotations, if any

1113

try:

1114

new_function._dbus_annotations = (

1115

dict(attribute._dbus_annotations))

1116

except AttributeError:

1117

pass

1118

# Define a creator of a function to call both the

1119

# original and alternate functions, so both the

1120

# original and alternate signals gets sent when

1121

# the function is called

1122

def fixscope(func1, func2):

1123

"""This function is a scope container to pass

1124

func1 and func2 to the "call_both" function

1125

outside of its arguments"""

1126

def call_both(*args, **kwargs):

1127

"""This function will emit two D-Bus

1128

signals by calling func1 and func2"""

1129

func1(*args, **kwargs)

1130

func2(*args, **kwargs)

1131

return call_both

1132

# Create the "call_both" function and add it to

1133

# the class

1134

attr[attrname] = fixscope(attribute, new_function)

1135

# Is this a D-Bus method?

1136

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

1137

# Create a new, but exactly alike, function

1138

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

1139

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

1140

# to the class.

1141

attr[attrname] = (dbus.service.method

1142

(alt_interface,

1143

attribute._dbus_in_signature,

1144

attribute._dbus_out_signature)

1145

(types.FunctionType

1146

(attribute.func_code,

1147

attribute.func_globals,

1148

attribute.func_name,

1149

attribute.func_defaults,

1150

attribute.func_closure)))

1151

# Copy annotations, if any

1152

try:

1153

attr[attrname]._dbus_annotations = (

1154

dict(attribute._dbus_annotations))

1155

except AttributeError:

1156

pass

1157

# Is this a D-Bus property?

1158

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

1159

# Create a new, but exactly alike, function

1160

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

1161

# property with the alternate D-Bus interface

1162

# name. Add it to the class.

1163

attr[attrname] = (dbus_service_property

1164

(alt_interface,

1165

attribute._dbus_signature,

1166

attribute._dbus_access,

1167

attribute

1168

._dbus_get_args_options

1169

["byte_arrays"])

1170

(types.FunctionType

1171

(attribute.func_code,

1172

attribute.func_globals,

1173

attribute.func_name,

1174

attribute.func_defaults,

1175

attribute.func_closure)))

1176

# Copy annotations, if any

1177

try:

1178

attr[attrname]._dbus_annotations = (

1179

dict(attribute._dbus_annotations))

1180

except AttributeError:

1181

pass

1182

# Is this a D-Bus interface?

1183

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

1184

# Create a new, but exactly alike, function

1185

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

1186

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

1187

# to the class.

1188

attr[attrname] = (dbus_interface_annotations

1189

(alt_interface)

1190

(types.FunctionType

1191

(attribute.func_code,

1192

attribute.func_globals,

1193

attribute.func_name,

1194

attribute.func_defaults,

1195

attribute.func_closure)))

1196

if deprecate:

1197

# Deprecate all alternate interfaces

1198

iname="_AlternateDBusNames_interface_annotation{0}"

1199

for interface_name in interface_names:

1200

@dbus_interface_annotations(interface_name)

1201

def func(self):

1202

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

1203

"true" }

1204

# Find an unused name

1205

for aname in (iname.format(i)

1206

for i in itertools.count()):

1207

if aname not in attr:

1208

attr[aname] = func

1209

break

1210

if interface_names:

1211

# Replace the class with a new subclass of it with

1212

# methods, signals, etc. as created above.

1213

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

1214

(cls,), attr)

1215

return cls

1216

return wrapper

1217

1218

1219

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

1220

"se.bsnet.fukt.Mandos"})

1221

732

class ClientDBus(Client, DBusObjectWithProperties):

1222

733

"""A Client class using D-Bus

1223

734

1232

743

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

1233

744

1234

745

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

746

self._approvals_pending = 0

1235

747

self.bus = bus

1236

748

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

1237

749

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

1243

755

("/clients/" + client_object_name))

1244

756

DBusObjectWithProperties.__init__(self, self.bus,

1245

757

self.dbus_object_path)

1246

1247

def notifychangeproperty(transform_func,

1248

dbus_name, type_func=lambda x: x,

1249

variant_level=1):

1250

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

1251

its changes to DBus.

1252

1253

transform_fun: Function that takes a value and a variant_level

1254

and transforms it to a D-Bus type.

1255

dbus_name: D-Bus name of the variable

1256

type_func: Function that transform the value before sending it

1257

to the D-Bus. Default: no transform

1258

variant_level: D-Bus variant level. Default: 1

1259

"""

1260

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

1261

def setter(self, value):

1262

if hasattr(self, "dbus_object_path"):

1263

if (not hasattr(self, attrname) or

1264

type_func(getattr(self, attrname, None))

1265

!= type_func(value)):

1266

dbus_value = transform_func(type_func(value),

1267

variant_level

1268

=variant_level)

1269

self.PropertyChanged(dbus.String(dbus_name),

1270

dbus_value)

1271

setattr(self, attrname, value)

1272

1273

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

1274

1275

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1276

approvals_pending = notifychangeproperty(dbus.Boolean,

1277

"ApprovalPending",

1278

type_func = bool)

1279

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

1280

last_enabled = notifychangeproperty(datetime_to_dbus,

1281

"LastEnabled")

1282

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

1283

type_func = lambda checker:

1284

checker is not None)

1285

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1286

"LastCheckedOK")

1287

last_checker_status = notifychangeproperty(dbus.Int16,

1288

"LastCheckerStatus")

1289

last_approval_request = notifychangeproperty(

1290

datetime_to_dbus, "LastApprovalRequest")

1291

approved_by_default = notifychangeproperty(dbus.Boolean,

1292

"ApprovedByDefault")

1293

approval_delay = notifychangeproperty(dbus.UInt64,

1294

"ApprovalDelay",

1295

type_func =

1296

timedelta_to_milliseconds)

1297

approval_duration = notifychangeproperty(

1298

dbus.UInt64, "ApprovalDuration",

1299

type_func = timedelta_to_milliseconds)

1300

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

1301

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

1302

type_func =

1303

timedelta_to_milliseconds)

1304

extended_timeout = notifychangeproperty(

1305

dbus.UInt64, "ExtendedTimeout",

1306

type_func = timedelta_to_milliseconds)

1307

interval = notifychangeproperty(dbus.UInt64,

1308

"Interval",

1309

type_func =

1310

timedelta_to_milliseconds)

1311

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

1312

1313

del notifychangeproperty

758

759

def _get_approvals_pending(self):

760

return self._approvals_pending

761

def _set_approvals_pending(self, value):

762

old_value = self._approvals_pending

763

self._approvals_pending = value

764

bval = bool(value)

765

if (hasattr(self, "dbus_object_path")

766

and bval is not bool(old_value)):

767

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

768

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

769

dbus_bool)

770

771

approvals_pending = property(_get_approvals_pending,

772

_set_approvals_pending)

773

del _get_approvals_pending, _set_approvals_pending

774

775

@staticmethod

776

def _datetime_to_dbus(dt, variant_level=0):

777

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

778

return dbus.String(dt.isoformat(),

779

variant_level=variant_level)

780

781

def enable(self):

782

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

783

r = Client.enable(self)

784

if oldstate != self.enabled:

785

# Emit D-Bus signals

786

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

787

dbus.Boolean(True, variant_level=1))

788

self.PropertyChanged(

789

dbus.String("LastEnabled"),

790

self._datetime_to_dbus(self.last_enabled,

791

variant_level=1))

792

return r

793

794

def disable(self, quiet = False):

795

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

796

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

797

if not quiet and oldstate != self.enabled:

798

# Emit D-Bus signal

799

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

800

dbus.Boolean(False, variant_level=1))

801

return r

1314

802

1315

803

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

1316

804

try:

1325

813

*args, **kwargs):

1326

814

self.checker_callback_tag = None

1327

815

self.checker = None

816

# Emit D-Bus signal

817

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

818

dbus.Boolean(False, variant_level=1))

1328

819

if os.WIFEXITED(condition):

1329

820

exitstatus = os.WEXITSTATUS(condition)

1330

821

# Emit D-Bus signal

1340

831

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

1341

832

*args, **kwargs)

1342

833

834

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

835

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

836

# Emit D-Bus signal

837

self.PropertyChanged(

838

dbus.String("LastCheckedOK"),

839

(self._datetime_to_dbus(self.last_checked_ok,

840

variant_level=1)))

841

842

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

843

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

844

# Emit D-Bus signal

845

self.PropertyChanged(

846

dbus.String("LastApprovalRequest"),

847

(self._datetime_to_dbus(self.last_approval_request,

848

variant_level=1)))

849

return r

850

1343

851

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

1344

852

old_checker = self.checker

1345

853

if self.checker is not None:

1352

860

and old_checker_pid != self.checker.pid):

1353

861

# Emit D-Bus signal

1354

862

self.CheckerStarted(self.current_checker_command)

863

self.PropertyChanged(

864

dbus.String("CheckerRunning"),

865

dbus.Boolean(True, variant_level=1))

1355

866

return r

1356

867

868

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

869

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

870

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

871

if (old_checker is not None

872

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

873

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

874

dbus.Boolean(False, variant_level=1))

875

return r

876

1357

877

def _reset_approved(self):

1358

self.approved = None

878

self._approved = None

1359

879

return False

1360

880

1361

881

def approve(self, value=True):

1362

self.approved = value

1363

gobject.timeout_add(timedelta_to_milliseconds

882

self.send_changedstate()

883

self._approved = value

884

gobject.timeout_add(self._timedelta_to_milliseconds

1364

885

(self.approval_duration),

1365

886

self._reset_approved)

1366

self.send_changedstate()

887

1367

888

1368

889

## D-Bus methods, signals & properties

1369

_interface = "se.recompile.Mandos.Client"

1370

1371

## Interfaces

1372

1373

@dbus_interface_annotations(_interface)

1374

def _foo(self):

1375

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

1376

"false"}

890

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

1377

891

1378

892

## Signals

1379

893

1465

979

if value is None: # get

1466

980

return dbus.Boolean(self.approved_by_default)

1467

981

self.approved_by_default = bool(value)

982

# Emit D-Bus signal

983

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

984

dbus.Boolean(value, variant_level=1))

1468

985

1469

986

# ApprovalDelay - property

1470

987

@dbus_service_property(_interface, signature="t",

1473

990

if value is None: # get

1474

991

return dbus.UInt64(self.approval_delay_milliseconds())

1475

992

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

993

# Emit D-Bus signal

994

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

995

dbus.UInt64(value, variant_level=1))

1476

996

1477

997

# ApprovalDuration - property

1478

998

@dbus_service_property(_interface, signature="t",

1479

999

access="readwrite")

1480

1000

def ApprovalDuration_dbus_property(self, value=None):

1481

1001

if value is None: # get

1482

return dbus.UInt64(timedelta_to_milliseconds(

1002

return dbus.UInt64(self._timedelta_to_milliseconds(

1483

1003

self.approval_duration))

1484

1004

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

1005

# Emit D-Bus signal

1006

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

1007

dbus.UInt64(value, variant_level=1))

1485

1008

1486

1009

# Name - property

1487

1010

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

1499

1022

def Host_dbus_property(self, value=None):

1500

1023

if value is None: # get

1501

1024

return dbus.String(self.host)

1502

self.host = unicode(value)

1025

self.host = value

1026

# Emit D-Bus signal

1027

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

1028

dbus.String(value, variant_level=1))

1503

1029

1504

1030

# Created - property

1505

1031

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

1506

1032

def Created_dbus_property(self):

1507

return datetime_to_dbus(self.created)

1033

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

1508

1034

1509

1035

# LastEnabled - property

1510

1036

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

1511

1037

def LastEnabled_dbus_property(self):

1512

return datetime_to_dbus(self.last_enabled)

1038

if self.last_enabled is None:

1039

return dbus.String("")

1040

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

1513

1041

1514

1042

# Enabled - property

1515

1043

@dbus_service_property(_interface, signature="b",

1529

1057

if value is not None:

1530

1058

self.checked_ok()

1531

1059

return

1532

return datetime_to_dbus(self.last_checked_ok)

1533

1534

# LastCheckerStatus - property

1535

@dbus_service_property(_interface, signature="n",

1536

access="read")

1537

def LastCheckerStatus_dbus_property(self):

1538

return dbus.Int16(self.last_checker_status)

1539

1540

# Expires - property

1541

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

1542

def Expires_dbus_property(self):

1543

return datetime_to_dbus(self.expires)

1060

if self.last_checked_ok is None:

1061

return dbus.String("")

1062

return dbus.String(self._datetime_to_dbus(self

1063

.last_checked_ok))

1544

1064

1545

1065

# LastApprovalRequest - property

1546

1066

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

1547

1067

def LastApprovalRequest_dbus_property(self):

1548

return datetime_to_dbus(self.last_approval_request)

1068

if self.last_approval_request is None:

1069

return dbus.String("")

1070

return dbus.String(self.

1071

_datetime_to_dbus(self

1072

.last_approval_request))

1549

1073

1550

1074

# Timeout - property

1551

1075

@dbus_service_property(_interface, signature="t",

1553

1077

def Timeout_dbus_property(self, value=None):

1554

1078

if value is None: # get

1555

1079

return dbus.UInt64(self.timeout_milliseconds())

1556

old_timeout = self.timeout

1557

1080

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

1558

# Reschedule disabling

1559

if self.enabled:

1560

now = datetime.datetime.utcnow()

1561

self.expires += self.timeout - old_timeout

1562

if self.expires <= now:

1563

# The timeout has passed

1564

self.disable()

1565

else:

1566

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

1567

is None):

1568

return

1569

gobject.source_remove(self.disable_initiator_tag)

1570

self.disable_initiator_tag = (

1571

gobject.timeout_add(

1572

timedelta_to_milliseconds(self.expires - now),

1573

self.disable))

1574

1575

# ExtendedTimeout - property

1576

@dbus_service_property(_interface, signature="t",

1577

access="readwrite")

1578

def ExtendedTimeout_dbus_property(self, value=None):

1579

if value is None: # get

1580

return dbus.UInt64(self.extended_timeout_milliseconds())

1581

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

1081

# Emit D-Bus signal

1082

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

1083

dbus.UInt64(value, variant_level=1))

1084

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

1085

return

1086

# Reschedule timeout

1087

gobject.source_remove(self.disable_initiator_tag)

1088

self.disable_initiator_tag = None

1089

time_to_die = (self.

1090

_timedelta_to_milliseconds((self

1091

.last_checked_ok

1092

+ self.timeout)

1093

- datetime.datetime

1094

.utcnow()))

1095

if time_to_die <= 0:

1096

# The timeout has passed

1097

self.disable()

1098

else:

1099

self.disable_initiator_tag = (gobject.timeout_add

1100

(time_to_die, self.disable))

1582

1101

1583

1102

# Interval - property

1584

1103

@dbus_service_property(_interface, signature="t",

1587

1106

if value is None: # get

1588

1107

return dbus.UInt64(self.interval_milliseconds())

1589

1108

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

1109

# Emit D-Bus signal

1110

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

1111

dbus.UInt64(value, variant_level=1))

1590

1112

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

1591

1113

return

1592

if self.enabled:

1593

# Reschedule checker run

1594

gobject.source_remove(self.checker_initiator_tag)

1595

self.checker_initiator_tag = (gobject.timeout_add

1596

(value, self.start_checker))

1597

self.start_checker() # Start one now, too

1598

1114

# Reschedule checker run

1115

gobject.source_remove(self.checker_initiator_tag)

1116

self.checker_initiator_tag = (gobject.timeout_add

1117

(value, self.start_checker))

1118

self.start_checker() # Start one now, too

1119

1599

1120

# Checker - property

1600

1121

@dbus_service_property(_interface, signature="s",

1601

1122

access="readwrite")

1602

1123

def Checker_dbus_property(self, value=None):

1603

1124

if value is None: # get

1604

1125

return dbus.String(self.checker_command)

1605

self.checker_command = unicode(value)

1126

self.checker_command = value

1127

# Emit D-Bus signal

1128

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

1129

dbus.String(self.checker_command,

1130

variant_level=1))

1606

1131

1607

1132

# CheckerRunning - property

1608

1133

@dbus_service_property(_interface, signature="b",

1635

1160

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

1636

1161

if not self._pipe.recv():

1637

1162

raise KeyError()

1638

1163

1639

1164

def __getattribute__(self, name):

1640

if name == '_pipe':

1165

if(name == '_pipe'):

1641

1166

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

1642

1167

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

1643

1168

data = self._pipe.recv()

1648

1173

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

1649

1174

return self._pipe.recv()[1]

1650

1175

return func

1651

1176

1652

1177

def __setattr__(self, name, value):

1653

if name == '_pipe':

1178

if(name == '_pipe'):

1654

1179

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

1655

1180

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

1656

1181

1667

1192

unicode(self.client_address))

1668

1193

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

1669

1194

self.server.child_pipe.fileno())

1670

1195

1671

1196

session = (gnutls.connection

1672

1197

.ClientSession(self.request,

1673

1198

gnutls.connection

1674

1199

.X509Credentials()))

1675

1200

1676

1201

# Note: gnutls.connection.X509Credentials is really a

1677

1202

# generic GnuTLS certificate credentials object so long as

1678

1203

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

1679

1204

# here despite using OpenPGP certificates.

1680

1205

1681

1206

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

1682

1207

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

1683

1208

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

1689

1214

(gnutls.library.functions

1690

1215

.gnutls_priority_set_direct(session._c_object,

1691

1216

priority, None))

1692

1217

1693

1218

# Start communication using the Mandos protocol

1694

1219

# Get protocol number

1695

1220

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

1700

1225

except (ValueError, IndexError, RuntimeError) as error:

1701

1226

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

1702

1227

return

1703

1228

1704

1229

# Start GnuTLS connection

1705

1230

try:

1706

1231

session.handshake()

1710

1235

# established. Just abandon the request.

1711

1236

return

1712

1237

logger.debug("Handshake succeeded")

1713

1238

1714

1239

approval_required = False

1715

1240

try:

1716

1241

try:

1721

1246

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

1722

1247

return

1723

1248

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

1724

1249

1725

1250

try:

1726

1251

client = ProxyClient(child_pipe, fpr,

1727

1252

self.client_address)

1735

1260

1736

1261

while True:

1737

1262

if not client.enabled:

1738

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

1263

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

1739

1264

client.name)

1740

1265

if self.server.use_dbus:

1741

1266

# Emit D-Bus signal

1742

client.Rejected("Disabled")

1267

client.Rejected("Disabled")

1743

1268

return

1744

1269

1745

if client.approved or not client.approval_delay:

1270

if client._approved or not client.approval_delay:

1746

1271

#We are approved or approval is disabled

1747

1272

break

1748

elif client.approved is None:

1273

elif client._approved is None:

1749

1274

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

1750

1275

client.name)

1751

1276

if self.server.use_dbus:

1762

1287

return

1763

1288

1764

1289

#wait until timeout or approved

1290

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

1765

1291

time = datetime.datetime.now()

1766

1292

client.changedstate.acquire()

1767

client.changedstate.wait(

1768

float(timedelta_to_milliseconds(delay)

1769

/ 1000))

1293

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

1770

1294

client.changedstate.release()

1771

1295

time2 = datetime.datetime.now()

1772

1296

if (time2 - time) >= delay:

1788

1312

try:

1789

1313

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

1790

1314

except gnutls.errors.GNUTLSError as error:

1791

logger.warning("gnutls send failed",

1792

exc_info=error)

1315

logger.warning("gnutls send failed")

1793

1316

return

1794

1317

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

1795

1318

sent, len(client.secret)

1796

1319

- (sent_size + sent))

1797

1320

sent_size += sent

1798

1321

1799

1322

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

1800

# bump the timeout using extended_timeout

1801

client.bump_timeout(client.extended_timeout)

1323

# bump the timeout as if seen

1324

client.checked_ok()

1802

1325

if self.server.use_dbus:

1803

1326

# Emit D-Bus signal

1804

1327

client.GotSecret()

1809

1332

try:

1810

1333

session.bye()

1811

1334

except gnutls.errors.GNUTLSError as error:

1812

logger.warning("GnuTLS bye failed",

1813

exc_info=error)

1335

logger.warning("GnuTLS bye failed")

1814

1336

1815

1337

@staticmethod

1816

1338

def peer_certificate(session):

1872

1394

# Convert the buffer to a Python bytestring

1873

1395

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

1874

1396

# Convert the bytestring to hexadecimal notation

1875

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

1397

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

1876

1398

return hex_fpr

1877

1399

1878

1400

1881

1403

def sub_process_main(self, request, address):

1882

1404

try:

1883

1405

self.finish_request(request, address)

1884

except Exception:

1406

except:

1885

1407

self.handle_error(request, address)

1886

1408

self.close_request(request)

1887

1409

1888

1410

def process_request(self, request, address):

1889

1411

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

1890

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

1891

args = (request, address))

1892

proc.start()

1893

return proc

1894

1412

multiprocessing.Process(target = self.sub_process_main,

1413

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

1895

1414

1896

1415

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1897

1416

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

1901

1420

This function creates a new pipe in self.pipe

1902

1421

"""

1903

1422

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1904

1905

proc = MultiprocessingMixIn.process_request(self, request,

1906

client_address)

1423

1424

super(MultiprocessingMixInWithPipe,

1425

self).process_request(request, client_address)

1907

1426

self.child_pipe.close()

1908

self.add_pipe(parent_pipe, proc)

1909

1910

def add_pipe(self, parent_pipe, proc):

1427

self.add_pipe(parent_pipe)

1428

1429

def add_pipe(self, parent_pipe):

1911

1430

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

1912

1431

raise NotImplementedError

1913

1432

1914

1915

1433

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1916

1434

socketserver.TCPServer, object):

1917

1435

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

1922

1440

use_ipv6: Boolean; to use IPv6 or not

1923

1441

"""

1924

1442

def __init__(self, server_address, RequestHandlerClass,

1925

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

1926

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

1927

creating a new one with socket.socket().

1928

"""

1443

interface=None, use_ipv6=True):

1929

1444

self.interface = interface

1930

1445

if use_ipv6:

1931

1446

self.address_family = socket.AF_INET6

1932

if socketfd is not None:

1933

# Save the file descriptor

1934

self.socketfd = socketfd

1935

# Save the original socket.socket() function

1936

self.socket_socket = socket.socket

1937

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

1938

#

1939

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

1940

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

1941

# patching socket.socket.)

1942

#

1943

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

1944

@functools.wraps(socket.socket)

1945

def socket_wrapper(*args, **kwargs):

1946

# Restore original function so subsequent calls are

1947

# not affected.

1948

socket.socket = self.socket_socket

1949

del self.socket_socket

1950

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

1951

# saved file descriptor.

1952

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

1953

# Replace socket.socket() function with wrapper

1954

socket.socket = socket_wrapper

1955

# The socketserver.TCPServer.__init__ will call

1956

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

1957

# socket_wrapper(), if socketfd was set.

1958

1447

socketserver.TCPServer.__init__(self, server_address,

1959

1448

RequestHandlerClass)

1960

1961

1449

def server_bind(self):

1962

1450

"""This overrides the normal server_bind() function

1963

1451

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

1971

1459

try:

1972

1460

self.socket.setsockopt(socket.SOL_SOCKET,

1973

1461

SO_BINDTODEVICE,

1974

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

1462

str(self.interface

1463

+ '\0'))

1975

1464

except socket.error as error:

1976

if error.errno == errno.EPERM:

1977

logger.error("No permission to bind to"

1978

" interface %s", self.interface)

1979

elif error.errno == errno.ENOPROTOOPT:

1465

if error[0] == errno.EPERM:

1466

logger.error("No permission to"

1467

" bind to interface %s",

1468

self.interface)

1469

elif error[0] == errno.ENOPROTOOPT:

1980

1470

logger.error("SO_BINDTODEVICE not available;"

1981

1471

" cannot bind to interface %s",

1982

1472

self.interface)

1983

elif error.errno == errno.ENODEV:

1984

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

1985

" cannot bind", self.interface)

1986

1473

else:

1987

1474

raise

1988

1475

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

1991

1478

if self.address_family == socket.AF_INET6:

1992

1479

any_address = "::" # in6addr_any

1993

1480

else:

1994

any_address = "0.0.0.0" # INADDR_ANY

1481

any_address = socket.INADDR_ANY

1995

1482

self.server_address = (any_address,

1996

1483

self.server_address[1])

1997

1484

elif not self.server_address[1]:

2018

1505

"""

2019

1506

def __init__(self, server_address, RequestHandlerClass,

2020

1507

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

2021

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

1508

gnutls_priority=None, use_dbus=True):

2022

1509

self.enabled = False

2023

1510

self.clients = clients

2024

1511

if self.clients is None:

2025

self.clients = {}

1512

self.clients = set()

2026

1513

self.use_dbus = use_dbus

2027

1514

self.gnutls_priority = gnutls_priority

2028

1515

IPv6_TCPServer.__init__(self, server_address,

2029

1516

RequestHandlerClass,

2030

1517

interface = interface,

2031

use_ipv6 = use_ipv6,

2032

socketfd = socketfd)

1518

use_ipv6 = use_ipv6)

2033

1519

def server_activate(self):

2034

1520

if self.enabled:

2035

1521

return socketserver.TCPServer.server_activate(self)

2036

2037

1522

def enable(self):

2038

1523

self.enabled = True

2039

2040

def add_pipe(self, parent_pipe, proc):

1524

def add_pipe(self, parent_pipe):

2041

1525

# Call "handle_ipc" for both data and EOF events

2042

1526

gobject.io_add_watch(parent_pipe.fileno(),

2043

1527

gobject.IO_IN | gobject.IO_HUP,

2044

1528

functools.partial(self.handle_ipc,

2045

parent_pipe =

2046

parent_pipe,

2047

proc = proc))

2048

1529

parent_pipe = parent_pipe))

1530

2049

1531

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

2050

proc = None, client_object=None):

2051

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

2052

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

2053

# Wait for other process to exit

2054

proc.join()

1532

client_object=None):

1533

condition_names = {

1534

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

1535

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

1536

# blocking).

1537

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

1538

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

1539

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

1540

# broken, usually for pipes and

1541

# sockets).

1542

}

1543

conditions_string = ' | '.join(name

1544

for cond, name in

1545

condition_names.iteritems()

1546

if cond & condition)

1547

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

1548

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

2055

1549

return False

2056

1550

2057

1551

# Read a request from the child

2062

1556

fpr = request[1]

2063

1557

address = request[2]

2064

1558

2065

for c in self.clients.itervalues():

1559

for c in self.clients:

2066

1560

if c.fingerprint == fpr:

2067

1561

client = c

2068

1562

break

2069

1563

else:

2070

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

2071

"dress: %s", fpr, address)

1564

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

1565

"dress: %s", fpr, address)

2072

1566

if self.use_dbus:

2073

1567

# Emit D-Bus signal

2074

mandos_dbus_service.ClientNotFound(fpr,

2075

address[0])

1568

mandos_dbus_service.ClientNotFound(fpr, address[0])

2076

1569

parent_pipe.send(False)

2077

1570

return False

2078

1571

2079

1572

gobject.io_add_watch(parent_pipe.fileno(),

2080

1573

gobject.IO_IN | gobject.IO_HUP,

2081

1574

functools.partial(self.handle_ipc,

2082

parent_pipe =

2083

parent_pipe,

2084

proc = proc,

2085

client_object =

2086

client))

1575

parent_pipe = parent_pipe,

1576

client_object = client))

2087

1577

parent_pipe.send(True)

2088

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

2089

# same fileno

1578

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

2090

1579

return False

2091

1580

if command == 'funcall':

2092

1581

funcname = request[1]

2093

1582

args = request[2]

2094

1583

kwargs = request[3]

2095

1584

2096

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

2097

funcname)(*args,

2098

**kwargs)))

2099

1585

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

1586

2100

1587

if command == 'getattr':

2101

1588

attrname = request[1]

2102

1589

if callable(client_object.__getattribute__(attrname)):

2103

1590

parent_pipe.send(('function',))

2104

1591

else:

2105

parent_pipe.send(('data', client_object

2106

.__getattribute__(attrname)))

1592

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

2107

1593

2108

1594

if command == 'setattr':

2109

1595

attrname = request[1]

2110

1596

value = request[2]

2111

1597

setattr(client_object, attrname, value)

2112

1598

2113

1599

return True

2114

1600

2115

1601

2116

def rfc3339_duration_to_delta(duration):

2117

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

2118

2119

>>> rfc3339_duration_to_delta("P7D")

2120

datetime.timedelta(7)

2121

>>> rfc3339_duration_to_delta("PT60S")

2122

datetime.timedelta(0, 60)

2123

>>> rfc3339_duration_to_delta("PT60M")

2124

datetime.timedelta(0, 3600)

2125

>>> rfc3339_duration_to_delta("PT24H")

2126

datetime.timedelta(1)

2127

>>> rfc3339_duration_to_delta("P1W")

2128

datetime.timedelta(7)

2129

>>> rfc3339_duration_to_delta("PT5M30S")

2130

datetime.timedelta(0, 330)

2131

>>> rfc3339_duration_to_delta("P1DT3M20S")

2132

datetime.timedelta(1, 200)

2133

"""

2134

2135

# Parsing an RFC 3339 duration with regular expressions is not

2136

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

2137

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

2138

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

2139

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

2140

# avoid excessive use of external libraries.

2141

2142

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

2143

Token = collections.namedtuple("Token",

2144

("regexp", # To match token; if

2145

# "value" is not None,

2146

# must have a "group"

2147

# containing digits

2148

"value", # datetime.timedelta or

2149

# None

2150

"followers")) # Tokens valid after

2151

# this token

2152

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

2153

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

2154

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

2155

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

2156

datetime.timedelta(seconds=1),

2157

frozenset((token_end,)))

2158

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

2159

datetime.timedelta(minutes=1),

2160

frozenset((token_second, token_end)))

2161

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

2162

datetime.timedelta(hours=1),

2163

frozenset((token_minute, token_end)))

2164

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

2165

None,

2166

frozenset((token_hour, token_minute,

2167

token_second)))

2168

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

2169

datetime.timedelta(days=1),

2170

frozenset((token_time, token_end)))

2171

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

2172

datetime.timedelta(weeks=4),

2173

frozenset((token_day, token_end)))

2174

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

2175

datetime.timedelta(weeks=52),

2176

frozenset((token_month, token_end)))

2177

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

2178

datetime.timedelta(weeks=1),

2179

frozenset((token_end,)))

2180

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

2181

frozenset((token_year, token_month,

2182

token_day, token_time,

2183

token_week))),

2184

# Define starting values

2185

value = datetime.timedelta() # Value so far

2186

found_token = None

2187

followers = frozenset(token_duration,) # Following valid tokens

2188

s = duration # String left to parse

2189

# Loop until end token is found

2190

while found_token is not token_end:

2191

# Search for any currently valid tokens

2192

for token in followers:

2193

match = token.regexp.match(s)

2194

if match is not None:

2195

# Token found

2196

if token.value is not None:

2197

# Value found, parse digits

2198

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

2199

# Add to value so far

2200

value += factor * token.value

2201

# Strip token from string

2202

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

2203

# Go to found token

2204

found_token = token

2205

# Set valid next tokens

2206

followers = found_token.followers

2207

break

2208

else:

2209

# No currently valid tokens were found

2210

raise ValueError("Invalid RFC 3339 duration")

2211

# End token found

2212

return value

2213

2214

2215

1602

def string_to_delta(interval):

2216

1603

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

2217

1604

2228

1615

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

2229

1616

datetime.timedelta(0, 330)

2230

1617

"""

2231

2232

try:

2233

return rfc3339_duration_to_delta(interval)

2234

except ValueError:

2235

pass

2236

2237

1618

timevalue = datetime.timedelta(0)

2238

1619

for s in interval.split():

2239

1620

try:

2250

1631

elif suffix == "w":

2251

1632

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

2252

1633

else:

2253

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

2254

.format(suffix))

1634

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

2255

1635

except (ValueError, IndexError) as e:

2256

1636

raise ValueError(*(e.args))

2257

1637

timevalue += delta

2258

1638

return timevalue

2259

1639

2260

1640

1641

def if_nametoindex(interface):

1642

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

1643

1644

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

1645

global if_nametoindex

1646

try:

1647

if_nametoindex = (ctypes.cdll.LoadLibrary

1648

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

1649

.if_nametoindex)

1650

except (OSError, AttributeError):

1651

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

1652

def if_nametoindex(interface):

1653

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

1654

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

1655

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

1656

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1657

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

1658

interface))

1659

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

1660

ifreq[16:20])[0]

1661

return interface_index

1662

return if_nametoindex(interface)

1663

1664

2261

1665

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

2262

1666

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

2263

1667

2271

1675

sys.exit()

2272

1676

if not noclose:

2273

1677

# Close all standard open file descriptors

2274

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

1678

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

2275

1679

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

2276

1680

raise OSError(errno.ENODEV,

2277

"{0} not a character device"

2278

.format(os.devnull))

1681

"%s not a character device"

1682

% os.path.devnull)

2279

1683

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

2280

1684

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

2281

1685

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

2290

1694

2291

1695

parser = argparse.ArgumentParser()

2292

1696

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

2293

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

1697

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

2294

1698

help="show version number and exit")

2295

1699

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

2296

1700

help="Bind to interface IF")

2302

1706

help="Run self-test")

2303

1707

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

2304

1708

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

2305

" to terminal", default=None)

1709

" to terminal")

2306

1710

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

2307

1711

help="Debug level for stdout output")

2308

1712

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

2315

1719

" files")

2316

1720

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

2317

1721

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

2318

" system bus interface", default=None)

1722

" system bus interface")

2319

1723

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

2320

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

2321

default=None)

2322

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

2323

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

2324

" state", default=None)

2325

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

2326

help="Specify a file descriptor to a network"

2327

" socket to use instead of creating one")

2328

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

2329

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

2330

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

2331

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

2332

1724

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

2333

1725

options = parser.parse_args()

2334

1726

2335

1727

if options.check:

2343

1735

"port": "",

2344

1736

"debug": "False",

2345

1737

"priority":

2346

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

1738

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

2347

1739

"servicename": "Mandos",

2348

1740

"use_dbus": "True",

2349

1741

"use_ipv6": "True",

2350

1742

"debuglevel": "",

2351

"restore": "True",

2352

"socket": "",

2353

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

2354

"foreground": "False",

2355

1743

}

2356

1744

2357

1745

# Parse config file for server-global settings

2362

1750

# Convert the SafeConfigParser object to a dict

2363

1751

server_settings = server_config.defaults()

2364

1752

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

2365

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

1753

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

2366

1754

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

2367

1755

option)

2368

1756

if server_settings["port"]:

2369

1757

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

2370

1758

"port")

2371

if server_settings["socket"]:

2372

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

2373

"socket")

2374

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

2375

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

2376

# happen with a supplied network socket.

2377

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

2378

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

2379

["socket"])

2380

1759

del server_config

2381

1760

2382

1761

# Override the settings from the config file with command line

2383

1762

# options, if set.

2384

1763

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

2385

1764

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

2386

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

2387

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

1765

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

2388

1766

value = getattr(options, option)

2389

1767

if value is not None:

2390

1768

server_settings[option] = value

2393

1771

for option in server_settings.keys():

2394

1772

if type(server_settings[option]) is str:

2395

1773

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

2396

# Force all boolean options to be boolean

2397

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

2398

"foreground"):

2399

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

2400

# Debug implies foreground

2401

if server_settings["debug"]:

2402

server_settings["foreground"] = True

2403

1774

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

2404

1775

2405

1776

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

2409

1780

debuglevel = server_settings["debuglevel"]

2410

1781

use_dbus = server_settings["use_dbus"]

2411

1782

use_ipv6 = server_settings["use_ipv6"]

2412

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

2413

stored_state_file)

2414

foreground = server_settings["foreground"]

2415

2416

if debug:

2417

initlogger(debug, logging.DEBUG)

2418

else:

2419

if not debuglevel:

2420

initlogger(debug)

2421

else:

2422

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

2423

initlogger(debug, level)

2424

1783

2425

1784

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

2426

1785

syslogger.setFormatter(logging.Formatter

2427

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

2428

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

2429

.format(server_settings

2430

["servicename"])))

1786

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

1787

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

1788

% server_settings["servicename"]))

2431

1789

2432

1790

# Parse config file with clients

2433

client_config = configparser.SafeConfigParser(Client

2434

.client_defaults)

1791

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

1792

"interval": "5m",

1793

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

1794

"host": "",

1795

"approval_delay": "0s",

1796

"approval_duration": "1s",

1797

}

1798

client_config = configparser.SafeConfigParser(client_defaults)

2435

1799

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

2436

1800

"clients.conf"))

2437

1801

2446

1810

use_ipv6=use_ipv6,

2447

1811

gnutls_priority=

2448

1812

server_settings["priority"],

2449

use_dbus=use_dbus,

2450

socketfd=(server_settings["socket"]

2451

or None))

2452

if not foreground:

1813

use_dbus=use_dbus)

1814

if not debug:

2453

1815

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

2454

pidfile = None

2455

1816

try:

2456

1817

pidfile = open(pidfilename, "w")

2457

except IOError as e:

2458

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

2459

exc_info=e)

1818

except IOError:

1819

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

2460

1820

2461

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

1821

try:

1822

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

1823

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

1824

except KeyError:

2462

1825

try:

2463

uid = pwd.getpwnam(name).pw_uid

2464

gid = pwd.getpwnam(name).pw_gid

2465

break

1826

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

1827

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

2466

1828

except KeyError:

2467

continue

2468

else:

2469

uid = 65534

2470

gid = 65534

1829

try:

1830

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

1831

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

1832

except KeyError:

1833

uid = 65534

1834

gid = 65534

2471

1835

try:

2472

1836

os.setgid(gid)

2473

1837

os.setuid(uid)

2474

1838

except OSError as error:

2475

if error.errno != errno.EPERM:

1839

if error[0] != errno.EPERM:

2476

1840

raise error

2477

1841

1842

if not debug and not debuglevel:

1843

syslogger.setLevel(logging.WARNING)

1844

console.setLevel(logging.WARNING)

1845

if debuglevel:

1846

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

1847

syslogger.setLevel(level)

1848

console.setLevel(level)

1849

2478

1850

if debug:

2479

1851

# Enable all possible GnuTLS debugging

2480

1852

2490

1862

.gnutls_global_set_log_function(debug_gnutls))

2491

1863

2492

1864

# Redirect stdin so all checkers get /dev/null

2493

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

1865

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

2494

1866

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

2495

1867

if null > 2:

2496

1868

os.close(null)

1869

else:

1870

# No console logging

1871

logger.removeHandler(console)

2497

1872

2498

1873

# Need to fork before connecting to D-Bus

2499

if not foreground:

1874

if not debug:

2500

1875

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

2501

1876

daemon()

2502

1877

2503

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

2504

# need to inform gobject that threads will be used.

2505

gobject.threads_init()

2506

2507

1878

global main_loop

2508

1879

# From the Avahi example code

2509

DBusGMainLoop(set_as_default=True)

1880

DBusGMainLoop(set_as_default=True )

2510

1881

main_loop = gobject.MainLoop()

2511

1882

bus = dbus.SystemBus()

2512

1883

# End of Avahi example code

2513

1884

if use_dbus:

2514

1885

try:

2515

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

1886

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

2516

1887

bus, do_not_queue=True)

2517

old_bus_name = (dbus.service.BusName

2518

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

2519

do_not_queue=True))

2520

1888

except dbus.exceptions.NameExistsException as e:

2521

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

1889

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

2522

1890

use_dbus = False

2523

1891

server_settings["use_dbus"] = False

2524

1892

tcp_server.use_dbus = False

2525

1893

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2526

service = AvahiServiceToSyslog(name =

2527

server_settings["servicename"],

2528

servicetype = "_mandos._tcp",

2529

protocol = protocol, bus = bus)

1894

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

1895

servicetype = "_mandos._tcp",

1896

protocol = protocol, bus = bus)

2530

1897

if server_settings["interface"]:

2531

1898

service.interface = (if_nametoindex

2532

1899

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

2537

1904

client_class = Client

2538

1905

if use_dbus:

2539

1906

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

2540

2541

client_settings = Client.config_parser(client_config)

2542

old_client_settings = {}

2543

clients_data = {}

2544

2545

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

2546

global wnull

2547

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

2548

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

2549

# mode

2550

if debug or not foreground:

2551

wnull.close()

2552

2553

# Get client data and settings from last running state.

2554

if server_settings["restore"]:

2555

try:

2556

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

2557

clients_data, old_client_settings = (pickle.load

2558

(stored_state))

2559

os.remove(stored_state_path)

2560

except IOError as e:

2561

if e.errno == errno.ENOENT:

2562

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

2563

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

2564

else:

2565

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

2566

exc_info=e)

2567

raise

2568

except EOFError as e:

2569

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

2570

"EOFError:", exc_info=e)

2571

2572

with PGPEngine() as pgp:

2573

for client_name, client in clients_data.iteritems():

2574

# Skip removed clients

2575

if client_name not in client_settings:

2576

continue

2577

2578

# Decide which value to use after restoring saved state.

2579

# We have three different values: Old config file,

2580

# new config file, and saved state.

2581

# New config value takes precedence if it differs from old

2582

# config value, otherwise use saved state.

2583

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

2584

try:

2585

# For each value in new config, check if it

2586

# differs from the old config value (Except for

2587

# the "secret" attribute)

2588

if (name != "secret" and

2589

value != old_client_settings[client_name]

2590

[name]):

2591

client[name] = value

2592

except KeyError:

2593

pass

2594

2595

# Clients who has passed its expire date can still be

2596

# enabled if its last checker was successful. Clients

2597

# whose checker succeeded before we stored its state is

2598

# assumed to have successfully run all checkers during

2599

# downtime.

2600

if client["enabled"]:

2601

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

2602

if not client["last_checked_ok"]:

2603

logger.warning(

2604

"disabling client {0} - Client never "

2605

"performed a successful checker"

2606

.format(client_name))

2607

client["enabled"] = False

2608

elif client["last_checker_status"] != 0:

2609

logger.warning(

2610

"disabling client {0} - Client "

2611

"last checker failed with error code {1}"

2612

.format(client_name,

2613

client["last_checker_status"]))

2614

client["enabled"] = False

2615

else:

2616

client["expires"] = (datetime.datetime

2617

.utcnow()

2618

+ client["timeout"])

2619

logger.debug("Last checker succeeded,"

2620

" keeping {0} enabled"

2621

.format(client_name))

1907

def client_config_items(config, section):

1908

special_settings = {

1909

"approved_by_default":

1910

lambda: config.getboolean(section,

1911

"approved_by_default"),

1912

}

1913

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

2622

1914

try:

2623

client["secret"] = (

2624

pgp.decrypt(client["encrypted_secret"],

2625

client_settings[client_name]

2626

["secret"]))

2627

except PGPError:

2628

# If decryption fails, we use secret from new settings

2629

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

2630

.format(client_name))

2631

client["secret"] = (

2632

client_settings[client_name]["secret"])

2633

2634

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

2635

for client_name in (set(old_client_settings)

2636

- set(client_settings)):

2637

del clients_data[client_name]

2638

for client_name in (set(client_settings)

2639

- set(old_client_settings)):

2640

clients_data[client_name] = client_settings[client_name]

2641

2642

# Create all client objects

2643

for client_name, client in clients_data.iteritems():

2644

tcp_server.clients[client_name] = client_class(

2645

name = client_name, settings = client,

2646

server_settings = server_settings)

2647

1915

yield (name, special_settings[name]())

1916

except KeyError:

1917

yield (name, value)

1918

1919

tcp_server.clients.update(set(

1920

client_class(name = section,

1921

config= dict(client_config_items(

1922

client_config, section)))

1923

for section in client_config.sections()))

2648

1924

if not tcp_server.clients:

2649

1925

logger.warning("No clients defined")

2650

2651

if not foreground:

2652

if pidfile is not None:

2653

try:

2654

with pidfile:

2655

pid = os.getpid()

2656

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

2657

except IOError:

2658

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

2659

pidfilename, pid)

2660

del pidfile

1926

1927

if not debug:

1928

try:

1929

with pidfile:

1930

pid = os.getpid()

1931

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

1932

del pidfile

1933

except IOError:

1934

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

1935

pidfilename, pid)

1936

except NameError:

1937

# "pidfile" was never created

1938

pass

2661

1939

del pidfilename

2662

1940

1941

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

1942

2663

1943

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

2664

1944

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

2665

1945

2666

1946

if use_dbus:

2667

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

2668

"se.bsnet.fukt.Mandos"})

2669

class MandosDBusService(DBusObjectWithProperties):

1947

class MandosDBusService(dbus.service.Object):

2670

1948

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

2671

1949

def __init__(self):

2672

1950

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

2673

_interface = "se.recompile.Mandos"

2674

2675

@dbus_interface_annotations(_interface)

2676

def _foo(self):

2677

return { "org.freedesktop.DBus.Property"

2678

".EmitsChangedSignal":

2679

"false"}

1951

_interface = "se.bsnet.fukt.Mandos"

2680

1952

2681

1953

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

2682

1954

def ClientAdded(self, objpath):

2697

1969

def GetAllClients(self):

2698

1970

"D-Bus method"

2699

1971

return dbus.Array(c.dbus_object_path

2700

for c in

2701

tcp_server.clients.itervalues())

1972

for c in tcp_server.clients)

2702

1973

2703

1974

@dbus.service.method(_interface,

2704

1975

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

2706

1977

"D-Bus method"

2707

1978

return dbus.Dictionary(

2708

1979

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

2709

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

1980

for c in tcp_server.clients),

2710

1981

signature="oa{sv}")

2711

1982

2712

1983

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

2713

1984

def RemoveClient(self, object_path):

2714

1985

"D-Bus method"

2715

for c in tcp_server.clients.itervalues():

1986

for c in tcp_server.clients:

2716

1987

if c.dbus_object_path == object_path:

2717

del tcp_server.clients[c.name]

1988

tcp_server.clients.remove(c)

2718

1989

c.remove_from_connection()

2719

1990

# Don't signal anything except ClientRemoved

2720

1991

c.disable(quiet=True)

2731

2002

"Cleanup function; run on exit"

2732

2003

service.cleanup()

2733

2004

2734

multiprocessing.active_children()

2735

wnull.close()

2736

if not (tcp_server.clients or client_settings):

2737

return

2738

2739

# Store client before exiting. Secrets are encrypted with key

2740

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

2741

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

2742

clients = {}

2743

with PGPEngine() as pgp:

2744

for client in tcp_server.clients.itervalues():

2745

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

2746

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

2747

key)

2748

client_dict = {}

2749

2750

# A list of attributes that can not be pickled

2751

# + secret.

2752

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

2753

"checker", "server_settings"))

2754

for name, typ in (inspect.getmembers

2755

(dbus.service.Object)):

2756

exclude.add(name)

2757

2758

client_dict["encrypted_secret"] = (client

2759

.encrypted_secret)

2760

for attr in client.client_structure:

2761

if attr not in exclude:

2762

client_dict[attr] = getattr(client, attr)

2763

2764

clients[client.name] = client_dict

2765

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

2766

2767

try:

2768

with (tempfile.NamedTemporaryFile

2769

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

2770

dir=os.path.dirname(stored_state_path),

2771

delete=False)) as stored_state:

2772

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

2773

tempname=stored_state.name

2774

os.rename(tempname, stored_state_path)

2775

except (IOError, OSError) as e:

2776

if not debug:

2777

try:

2778

os.remove(tempname)

2779

except NameError:

2780

pass

2781

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

2782

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

2783

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

2784

else:

2785

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

2786

exc_info=e)

2787

raise e

2788

2789

# Delete all clients, and settings from config

2790

2005

while tcp_server.clients:

2791

name, client = tcp_server.clients.popitem()

2006

client = tcp_server.clients.pop()

2792

2007

if use_dbus:

2793

2008

client.remove_from_connection()

2009

client.disable_hook = None

2794

2010

# Don't signal anything except ClientRemoved

2795

2011

client.disable(quiet=True)

2796

2012

if use_dbus:

2797

2013

# Emit D-Bus signal

2798

mandos_dbus_service.ClientRemoved(client

2799

.dbus_object_path,

2014

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2800

2015

client.name)

2801

client_settings.clear()

2802

2016

2803

2017

atexit.register(cleanup)

2804

2018

2805

for client in tcp_server.clients.itervalues():

2019

for client in tcp_server.clients:

2806

2020

if use_dbus:

2807

2021

# Emit D-Bus signal

2808

2022

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2809

# Need to initiate checking of clients

2810

if client.enabled:

2811

client.init_checker()

2023

client.enable()

2812

2024

2813

2025

tcp_server.enable()

2814

2026

tcp_server.server_activate()

2817

2029

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

2818

2030

if use_ipv6:

2819

2031

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

2820

" flowinfo %d, scope_id %d",

2821

*tcp_server.socket.getsockname())

2032

" flowinfo %d, scope_id %d"

2033

% tcp_server.socket.getsockname())

2822

2034

else: # IPv4

2823

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

2824

*tcp_server.socket.getsockname())

2035

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

2036

% tcp_server.socket.getsockname())

2825

2037

2826

2038

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

2827

2039

2830

2042

try:

2831

2043

service.activate()

2832

2044

except dbus.exceptions.DBusException as error:

2833

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

2045

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

2834

2046

cleanup()

2835

2047

sys.exit(1)

2836

2048

# End of Avahi example code

2843

2055

logger.debug("Starting main loop")

2844

2056

main_loop.run()

2845

2057

except AvahiError as error:

2846

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

2058

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

2847

2059

cleanup()

2848

2060

sys.exit(1)

2849

2061

except KeyboardInterrupt: