/mandos/release : revision 237.11.1

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

65

63

import cPickle as pickle

66

64

import multiprocessing

67

65

import types

68

import binascii

69

import tempfile

70

import itertools

71

import collections

72

66

73

67

import dbus

74

68

import dbus.service

88

82

except ImportError:

89

83

SO_BINDTODEVICE = None

90

84

91

version = "1.6.0"

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

85

86

version = "1.3.1"

87

88

#logger = logging.getLogger('mandos')

89

logger = logging.Logger('mandos')

95

90

syslogger = (logging.handlers.SysLogHandler

96

91

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

97

92

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

93

syslogger.setFormatter(logging.Formatter

94

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

95

' %(message)s'))

96

logger.addHandler(syslogger)

97

98

console = logging.StreamHandler()

99

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

100

' %(levelname)s:'

101

' %(message)s'))

102

logger.addHandler(console)

214

103

215

104

class AvahiError(Exception):

216

105

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

234

123

Used to optionally bind to the specified interface.

235

124

name: string; Example: 'Mandos'

236

125

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

237

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

126

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

238

127

port: integer; what port to announce

239

128

TXT: list of strings; TXT record for the service

240

129

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

246

135

server: D-Bus Server

247

136

bus: dbus.SystemBus()

248

137

"""

249

250

138

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

251

139

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

252

140

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

265

153

self.server = None

266

154

self.bus = bus

267

155

self.entry_group_state_changed_match = None

268

269

156

def rename(self):

270

157

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

271

158

if self.rename_count >= self.max_renames:

273

160

" after %i retries, exiting.",

274

161

self.rename_count)

275

162

raise AvahiServiceError("Too many renames")

276

self.name = unicode(self.server

277

.GetAlternativeServiceName(self.name))

163

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

278

164

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

279

165

self.name)

166

syslogger.setFormatter(logging.Formatter

167

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

168

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

169

% self.name))

280

170

self.remove()

281

171

try:

282

172

self.add()

283

173

except dbus.exceptions.DBusException as error:

284

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

174

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

285

175

self.cleanup()

286

176

os._exit(1)

287

177

self.rename_count += 1

288

289

178

def remove(self):

290

179

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

291

180

if self.entry_group_state_changed_match is not None:

293

182

self.entry_group_state_changed_match = None

294

183

if self.group is not None:

295

184

self.group.Reset()

296

297

185

def add(self):

298

186

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

299

187

self.remove()

304

192

avahi.DBUS_INTERFACE_ENTRY_GROUP)

305

193

self.entry_group_state_changed_match = (

306

194

self.group.connect_to_signal(

307

'StateChanged', self.entry_group_state_changed))

195

'StateChanged', self .entry_group_state_changed))

308

196

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

309

197

self.name, self.type)

310

198

self.group.AddService(

316

204

dbus.UInt16(self.port),

317

205

avahi.string_array_to_txt_array(self.TXT))

318

206

self.group.Commit()

319

320

207

def entry_group_state_changed(self, state, error):

321

208

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

322

209

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

329

216

elif state == avahi.ENTRY_GROUP_FAILURE:

330

217

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

331

218

unicode(error))

332

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

333

.format(error))

334

219

raise AvahiGroupError("State changed: %s"

220

% unicode(error))

335

221

def cleanup(self):

336

222

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

337

223

if self.group is not None:

338

224

try:

339

225

self.group.Free()

340

226

except (dbus.exceptions.UnknownMethodException,

341

dbus.exceptions.DBusException):

227

dbus.exceptions.DBusException) as e:

342

228

pass

343

229

self.group = None

344

230

self.remove()

345

346

231

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

347

232

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

348

233

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

367

252

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

368

253

else:

369

254

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

370

371

255

def activate(self):

372

256

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

373

257

if self.server is None:

381

265

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

382

266

383

267

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

268

def _timedelta_to_milliseconds(td):

396

269

"Convert a datetime.timedelta() to milliseconds"

397

270

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

398

271

+ (td.seconds * 1000)

399

272

+ (td.microseconds // 1000))

400

401

273

402

274

class Client(object):

403

275

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

404

276

405

277

Attributes:

406

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

278

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

407

279

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

408

280

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

409

281

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

416

288

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

417

289

checker_initiator_tag: a gobject event source tag, or None

418

290

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

291

current_checker_command: string; current running checker_command

292

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

422

293

disable_initiator_tag: a gobject event source tag, or None

423

294

enabled: bool()

424

295

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

427

298

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

428

299

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

429

300

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

301

last_enabled: datetime.datetime(); (UTC)

434

302

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

435

303

D-Bus identifiers

436

304

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

437

305

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

438

306

until this client is disabled

439

extended_timeout: extra long timeout when secret has been sent

307

extended_timeout: extra long timeout when password has been sent

440

308

runtime_expansions: Allowed attributes for runtime expansion.

441

309

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

442

310

disabled, or None

443

server_settings: The server_settings dict from main()

444

311

"""

445

312

446

313

runtime_expansions = ("approval_delay", "approval_duration",

447

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

448

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

449

"last_approval_request", "last_checked_ok",

314

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

315

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

450

316

"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

}

461

317

462

318

def timeout_milliseconds(self):

463

319

"Return the 'timeout' attribute in milliseconds"

464

return timedelta_to_milliseconds(self.timeout)

320

return _timedelta_to_milliseconds(self.timeout)

465

321

466

322

def extended_timeout_milliseconds(self):

467

323

"Return the 'extended_timeout' attribute in milliseconds"

468

return timedelta_to_milliseconds(self.extended_timeout)

324

return _timedelta_to_milliseconds(self.extended_timeout)

469

325

470

326

def interval_milliseconds(self):

471

327

"Return the 'interval' attribute in milliseconds"

472

return timedelta_to_milliseconds(self.interval)

328

return _timedelta_to_milliseconds(self.interval)

473

329

474

330

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

331

return _timedelta_to_milliseconds(self.approval_delay)

332

333

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

334

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

335

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

336

attribute."""

525

337

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

338

if config is None:

339

config = {}

543

340

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

544

341

# Uppercase and remove spaces from fingerprint for later

545

342

# comparison purposes with return value from the fingerprint()

546

343

# function

344

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

345

.replace(" ", ""))

547

346

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

548

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

549

datetime.datetime.utcnow())

550

551

# attributes specific for this server instance

347

if "secret" in config:

348

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

349

elif "secfile" in config:

350

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

351

(config["secfile"])),

352

"rb") as secfile:

353

self.secret = secfile.read()

354

else:

355

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

356

% self.name)

357

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

358

self.created = datetime.datetime.utcnow()

359

self.enabled = False

360

self.last_approval_request = None

361

self.last_enabled = None

362

self.last_checked_ok = None

363

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

364

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

365

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

366

self.disable_hook = disable_hook

552

367

self.checker = None

553

368

self.checker_initiator_tag = None

554

369

self.disable_initiator_tag = None

370

self.expires = None

555

371

self.checker_callback_tag = None

372

self.checker_command = config["checker"]

556

373

self.current_checker_command = None

557

self.approved = None

374

self.last_connect = None

375

self._approved = None

376

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

377

True)

558

378

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)

379

self.approval_delay = string_to_delta(

380

config["approval_delay"])

381

self.approval_duration = string_to_delta(

382

config["approval_duration"])

383

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

573

384

574

# Send notice to process children that client state has changed

575

385

def send_changedstate(self):

576

with self.changedstate:

577

self.changedstate.notify_all()

578

386

self.changedstate.acquire()

387

self.changedstate.notify_all()

388

self.changedstate.release()

389

579

390

def enable(self):

580

391

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

581

392

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

582

393

# Already enabled

583

394

return

395

self.send_changedstate()

396

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

397

# and every interval from then on.

398

self.checker_initiator_tag = (gobject.timeout_add

399

(self.interval_milliseconds(),

400

self.start_checker))

401

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

584

402

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

403

self.disable_initiator_tag = (gobject.timeout_add

404

(self.timeout_milliseconds(),

405

self.disable))

585

406

self.enabled = True

586

407

self.last_enabled = datetime.datetime.utcnow()

587

self.init_checker()

588

self.send_changedstate()

408

# Also start a new checker *right now*.

409

self.start_checker()

589

410

590

411

def disable(self, quiet=True):

591

412

"""Disable this client."""

592

413

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

593

414

return False

594

415

if not quiet:

416

self.send_changedstate()

417

if not quiet:

595

418

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

596

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

419

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

597

420

gobject.source_remove(self.disable_initiator_tag)

598

421

self.disable_initiator_tag = None

599

422

self.expires = None

600

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

423

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

601

424

gobject.source_remove(self.checker_initiator_tag)

602

425

self.checker_initiator_tag = None

603

426

self.stop_checker()

427

if self.disable_hook:

428

self.disable_hook(self)

604

429

self.enabled = False

605

if not quiet:

606

self.send_changedstate()

607

430

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

608

431

return False

609

432

610

433

def __del__(self):

434

self.disable_hook = None

611

435

self.disable()

612

436

613

def init_checker(self):

614

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

615

# and every interval from then on.

616

if self.checker_initiator_tag is not None:

617

gobject.source_remove(self.checker_initiator_tag)

618

self.checker_initiator_tag = (gobject.timeout_add

619

(self.interval_milliseconds(),

620

self.start_checker))

621

# 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

self.disable_initiator_tag = (gobject.timeout_add

625

(self.timeout_milliseconds(),

626

self.disable))

627

# Also start a new checker *right now*.

628

self.start_checker()

629

630

437

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

631

438

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

632

439

self.checker_callback_tag = None

633

440

self.checker = None

634

441

if os.WIFEXITED(condition):

635

self.last_checker_status = os.WEXITSTATUS(condition)

636

if self.last_checker_status == 0:

442

exitstatus = os.WEXITSTATUS(condition)

443

if exitstatus == 0:

637

444

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

638

445

vars(self))

639

446

self.checked_ok()

641

448

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

642

449

vars(self))

643

450

else:

644

self.last_checker_status = -1

645

451

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

646

452

vars(self))

647

453

648

def checked_ok(self):

649

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

650

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

454

def checked_ok(self, timeout=None):

455

"""Bump up the timeout for this client.

456

457

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

458

alive and well.

459

"""

656

460

if timeout is None:

657

461

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

462

self.last_checked_ok = datetime.datetime.utcnow()

463

gobject.source_remove(self.disable_initiator_tag)

464

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

465

self.disable_initiator_tag = (gobject.timeout_add

466

(_timedelta_to_milliseconds(timeout),

467

self.disable))

666

468

667

469

def need_approval(self):

668

470

self.last_approval_request = datetime.datetime.utcnow()

673

475

If a checker already exists, leave it running and do

674

476

nothing."""

675

477

# 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

478

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

479

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

480

# client would inevitably timeout, since no checker would get

481

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

680

482

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

681

483

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

682

484

# should be.

696

498

self.current_checker_command)

697

499

# Start a new checker if needed

698

500

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

501

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

502

# In case checker_command has exactly one % operator

503

command = self.checker_command % self.host

504

except TypeError:

505

# Escape attributes for the shell

506

escaped_attrs = dict(

507

(attr,

508

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

509

errors=

510

'replace')))

511

for attr in

512

self.runtime_expansions)

513

514

try:

515

command = self.checker_command % escaped_attrs

516

except TypeError as error:

517

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

518

' %s', self.checker_command, error)

519

return True # Try again later

710

520

self.current_checker_command = command

711

521

try:

712

522

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

715

525

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

716

526

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

717

527

# 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

528

self.checker = subprocess.Popen(command,

727

529

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:

530

shell=True, cwd="/")

531

self.checker_callback_tag = (gobject.child_watch_add

532

(self.checker.pid,

533

self.checker_callback,

534

data=command))

535

# The checker may have completed before the gobject

536

# watch was added. Check for this.

741

537

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

538

if pid:

539

gobject.source_remove(self.checker_callback_tag)

540

self.checker_callback(pid, status, command)

742

541

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)

542

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

543

error)

752

544

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

753

545

return True

754

546

761

553

return

762

554

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

763

555

try:

764

self.checker.terminate()

556

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

765

557

#time.sleep(0.5)

766

558

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

767

# self.checker.kill()

559

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

768

560

except OSError as error:

769

561

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

770

562

raise

787

579

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

788

580

if byte_arrays and signature != "ay":

789

581

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

790

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

582

" signature %r" % signature)

791

583

def decorator(func):

792

584

func._dbus_is_property = True

793

585

func._dbus_interface = dbus_interface

801

593

return decorator

802

594

803

595

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

596

class DBusPropertyException(dbus.exceptions.DBusException):

842

597

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

843

598

"""

866

621

"""

867

622

868

623

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

624

def _is_dbus_property(obj):

625

return getattr(obj, "_dbus_is_property", False)

877

626

878

def _get_all_dbus_things(self, thing):

627

def _get_all_dbus_properties(self):

879

628

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

880

629

"""

881

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

882

name),

883

athing.__get__(self))

630

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

884

631

for cls in self.__class__.__mro__

885

for name, athing in

886

inspect.getmembers(cls,

887

self._is_dbus_thing(thing)))

632

for name, prop in inspect.getmembers(cls, self._is_dbus_property))

888

633

889

634

def _get_dbus_property(self, interface_name, property_name):

890

635

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

891

636

property with the specified name and interface.

892

637

"""

893

638

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

639

for name, value in inspect.getmembers(cls, self._is_dbus_property):

640

if value._dbus_name == property_name and value._dbus_interface == interface_name:

899

641

return value.__get__(self)

900

642

901

643

# No such property

928

670

# signatures other than "ay".

929

671

if prop._dbus_signature != "ay":

930

672

raise ValueError

931

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

932

for byte in value))

673

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

674

for byte in value))

933

675

prop(value)

934

676

935

677

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

940

682

941

683

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

942

684

"""

943

properties = {}

944

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

685

all = {}

686

for name, prop in self._get_all_dbus_properties():

945

687

if (interface_name

946

688

and interface_name != prop._dbus_interface):

947

689

# Interface non-empty but did not match

951

693

continue

952

694

value = prop()

953

695

if not hasattr(value, "variant_level"):

954

properties[name] = value

696

all[name] = value

955

697

continue

956

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

957

value.variant_level+1)

958

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

698

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

699

value.variant_level+1)

700

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

959

701

960

702

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

961

703

out_signature="s",

962

704

path_keyword='object_path',

963

705

connection_keyword='connection')

964

706

def Introspect(self, object_path, connection):

965

"""Overloading of standard D-Bus method.

966

967

Inserts property tags and interface annotation tags.

707

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

968

708

"""

969

709

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

970

710

connection)

977

717

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

978

718

return e

979

719

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

980

# Add property tags

981

720

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

982

721

for name, prop

983

in self._get_all_dbus_things("property")

722

in self._get_all_dbus_properties()

984

723

if prop._dbus_interface

985

724

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

986

725

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

726

# Add the names to the return values for the

1019

727

# "org.freedesktop.DBus.Properties" methods

1020

728

if (if_tag.getAttribute("name")

1035

743

except (AttributeError, xml.dom.DOMException,

1036

744

xml.parsers.expat.ExpatError) as error:

1037

745

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

1038

exc_info=error)

746

error)

1039

747

return xmlstring

1040

748

1041

749

1042

def datetime_to_dbus(dt, variant_level=0):

750

def datetime_to_dbus (dt, variant_level=0):

1043

751

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

1044

752

if dt is None:

1045

753

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

1046

754

return dbus.String(dt.isoformat(),

1047

755

variant_level=variant_level)

1048

756

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

757

class AlternateDBusNamesMetaclass(DBusObjectWithProperties.__metaclass__):

758

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

759

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

1072

760

"""

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

761

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

762

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

763

# methods, signals, or properties in them

764

for base in (b for b in bases

765

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

766

# Go though all attributes of the base class

767

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

1080

768

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

1081

769

# with the wrong interface name

1082

770

if (not hasattr(attribute, "_dbus_interface")

1083

771

or not attribute._dbus_interface

1084

.startswith(orig_interface_name)):

772

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

1085

773

continue

1086

774

# Create an alternate D-Bus interface name based on

1087

775

# the current name

1088

776

alt_interface = (attribute._dbus_interface

1089

.replace(orig_interface_name,

1090

alt_interface_name))

1091

interface_names.add(alt_interface)

777

.replace("se.recompile.Mandos",

778

"se.bsnet.fukt.Mandos"))

1092

779

# Is this a D-Bus signal?

1093

780

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

1094

# Extract the original non-method undecorated

1095

# function by black magic

781

# Extract the original non-method function by

782

# black magic

1096

783

nonmethod_func = (dict(

1097

784

zip(attribute.func_code.co_freevars,

1098

785

attribute.__closure__))["func"]

1109

796

nonmethod_func.func_name,

1110

797

nonmethod_func.func_defaults,

1111

798

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

799

# 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

800

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

801

# signals gets sent when the function is called

1122

802

def fixscope(func1, func2):

1123

803

"""This function is a scope container to pass

1124

804

func1 and func2 to the "call_both" function

1131

811

return call_both

1132

812

# Create the "call_both" function and add it to

1133

813

# the class

1134

attr[attrname] = fixscope(attribute, new_function)

814

attr[attrname] = fixscope(attribute,

815

new_function)

1135

816

# Is this a D-Bus method?

1136

817

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

1137

818

# Create a new, but exactly alike, function

1148

829

attribute.func_name,

1149

830

attribute.func_defaults,

1150

831

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

832

# Is this a D-Bus property?

1158

833

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

1159

834

# Create a new, but exactly alike, function

1173

848

attribute.func_name,

1174

849

attribute.func_defaults,

1175

850

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

851

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

852

1221

853

class ClientDBus(Client, DBusObjectWithProperties):

1222

854

"""A Client class using D-Bus

1223

855

1232

864

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

1233

865

1234

866

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

867

self._approvals_pending = 0

1235

868

self.bus = bus

1236

869

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

1237

870

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

1243

876

("/clients/" + client_object_name))

1244

877

DBusObjectWithProperties.__init__(self, self.bus,

1245

878

self.dbus_object_path)

1246

879

1247

880

def notifychangeproperty(transform_func,

1248

881

dbus_name, type_func=lambda x: x,

1249

882

variant_level=1):

1250

883

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

1251

884

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.

885

886

transform_fun: Function that takes a value and transforms it

887

to a D-Bus type.

1255

888

dbus_name: D-Bus name of the variable

1256

889

type_func: Function that transform the value before sending it

1257

890

to the D-Bus. Default: no transform

1258

891

variant_level: D-Bus variant level. Default: 1

1259

892

"""

1260

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

893

real_value = [None,]

1261

894

def setter(self, value):

895

old_value = real_value[0]

896

real_value[0] = value

1262

897

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)

898

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

899

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

900

variant_level)

1269

901

self.PropertyChanged(dbus.String(dbus_name),

1270

902

dbus_value)

1271

setattr(self, attrname, value)

1272

903

1273

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

904

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

905

1274

906

1275

907

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1276

908

approvals_pending = notifychangeproperty(dbus.Boolean,

1280

912

last_enabled = notifychangeproperty(datetime_to_dbus,

1281

913

"LastEnabled")

1282

914

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

1283

type_func = lambda checker:

1284

checker is not None)

915

type_func = lambda checker: checker is not None)

1285

916

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1286

917

"LastCheckedOK")

1287

last_checker_status = notifychangeproperty(dbus.Int16,

1288

"LastCheckerStatus")

1289

last_approval_request = notifychangeproperty(

1290

datetime_to_dbus, "LastApprovalRequest")

918

last_approval_request = notifychangeproperty(datetime_to_dbus,

919

"LastApprovalRequest")

1291

920

approved_by_default = notifychangeproperty(dbus.Boolean,

1292

921

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

922

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

923

type_func = _timedelta_to_milliseconds)

924

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

925

type_func = _timedelta_to_milliseconds)

1300

926

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)

927

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

928

type_func = _timedelta_to_milliseconds)

929

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

930

type_func = _timedelta_to_milliseconds)

931

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

932

type_func = _timedelta_to_milliseconds)

1311

933

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

1312

934

1313

935

del notifychangeproperty

1355

977

return r

1356

978

1357

979

def _reset_approved(self):

1358

self.approved = None

980

self._approved = None

1359

981

return False

1360

982

1361

983

def approve(self, value=True):

1362

self.approved = value

1363

gobject.timeout_add(timedelta_to_milliseconds

984

self.send_changedstate()

985

self._approved = value

986

gobject.timeout_add(_timedelta_to_milliseconds

1364

987

(self.approval_duration),

1365

988

self._reset_approved)

1366

self.send_changedstate()

989

1367

990

1368

991

## D-Bus methods, signals & properties

1369

992

_interface = "se.recompile.Mandos.Client"

1370

993

1371

## Interfaces

1372

1373

@dbus_interface_annotations(_interface)

1374

def _foo(self):

1375

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

1376

"false"}

1377

1378

994

## Signals

1379

995

1380

996

# CheckerCompleted - signal

1479

1095

access="readwrite")

1480

1096

def ApprovalDuration_dbus_property(self, value=None):

1481

1097

if value is None: # get

1482

return dbus.UInt64(timedelta_to_milliseconds(

1098

return dbus.UInt64(_timedelta_to_milliseconds(

1483

1099

self.approval_duration))

1484

1100

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

1485

1101

1499

1115

def Host_dbus_property(self, value=None):

1500

1116

if value is None: # get

1501

1117

return dbus.String(self.host)

1502

self.host = unicode(value)

1118

self.host = value

1503

1119

1504

1120

# Created - property

1505

1121

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

1506

1122

def Created_dbus_property(self):

1507

return datetime_to_dbus(self.created)

1123

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

1508

1124

1509

1125

# LastEnabled - property

1510

1126

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

1531

1147

return

1532

1148

return datetime_to_dbus(self.last_checked_ok)

1533

1149

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

1150

# Expires - property

1541

1151

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

1542

1152

def Expires_dbus_property(self):

1553

1163

def Timeout_dbus_property(self, value=None):

1554

1164

if value is None: # get

1555

1165

return dbus.UInt64(self.timeout_milliseconds())

1556

old_timeout = self.timeout

1557

1166

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

1167

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

1168

return

1169

# Reschedule timeout

1170

gobject.source_remove(self.disable_initiator_tag)

1171

self.disable_initiator_tag = None

1172

self.expires = None

1173

time_to_die = (self.

1174

_timedelta_to_milliseconds((self

1175

.last_checked_ok

1176

+ self.timeout)

1177

- datetime.datetime

1178

.utcnow()))

1179

if time_to_die <= 0:

1180

# The timeout has passed

1181

self.disable()

1182

else:

1183

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

1184

+ datetime.timedelta(milliseconds = time_to_die))

1185

self.disable_initiator_tag = (gobject.timeout_add

1186

(time_to_die, self.disable))

1574

1187

1575

1188

# ExtendedTimeout - property

1576

1189

@dbus_service_property(_interface, signature="t",

1589

1202

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

1590

1203

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

1591

1204

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

1205

# Reschedule checker run

1206

gobject.source_remove(self.checker_initiator_tag)

1207

self.checker_initiator_tag = (gobject.timeout_add

1208

(value, self.start_checker))

1209

self.start_checker() # Start one now, too

1598

1210

1599

1211

# Checker - property

1600

1212

@dbus_service_property(_interface, signature="s",

1602

1214

def Checker_dbus_property(self, value=None):

1603

1215

if value is None: # get

1604

1216

return dbus.String(self.checker_command)

1605

self.checker_command = unicode(value)

1217

self.checker_command = value

1606

1218

1607

1219

# CheckerRunning - property

1608

1220

@dbus_service_property(_interface, signature="b",

1637

1249

raise KeyError()

1638

1250

1639

1251

def __getattribute__(self, name):

1640

if name == '_pipe':

1252

if(name == '_pipe'):

1641

1253

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

1642

1254

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

1643

1255

data = self._pipe.recv()

1650

1262

return func

1651

1263

1652

1264

def __setattr__(self, name, value):

1653

if name == '_pipe':

1265

if(name == '_pipe'):

1654

1266

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

1655

1267

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

1656

1268

1269

class ClientDBusTransitional(ClientDBus):

1270

__metaclass__ = AlternateDBusNamesMetaclass

1657

1271

1658

1272

class ClientHandler(socketserver.BaseRequestHandler, object):

1659

1273

"""A class to handle client connections.

1739

1353

client.name)

1740

1354

if self.server.use_dbus:

1741

1355

# Emit D-Bus signal

1742

client.Rejected("Disabled")

1356

client.Rejected("Disabled")

1743

1357

return

1744

1358

1745

if client.approved or not client.approval_delay:

1359

if client._approved or not client.approval_delay:

1746

1360

#We are approved or approval is disabled

1747

1361

break

1748

elif client.approved is None:

1362

elif client._approved is None:

1749

1363

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

1750

1364

client.name)

1751

1365

if self.server.use_dbus:

1762

1376

return

1763

1377

1764

1378

#wait until timeout or approved

1379

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

1765

1380

time = datetime.datetime.now()

1766

1381

client.changedstate.acquire()

1767

client.changedstate.wait(

1768

float(timedelta_to_milliseconds(delay)

1769

/ 1000))

1382

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

1770

1383

client.changedstate.release()

1771

1384

time2 = datetime.datetime.now()

1772

1385

if (time2 - time) >= delay:

1788

1401

try:

1789

1402

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

1790

1403

except gnutls.errors.GNUTLSError as error:

1791

logger.warning("gnutls send failed",

1792

exc_info=error)

1404

logger.warning("gnutls send failed")

1793

1405

return

1794

1406

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

1795

1407

sent, len(client.secret)

1797

1409

sent_size += sent

1798

1410

1799

1411

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

1800

# bump the timeout using extended_timeout

1801

client.bump_timeout(client.extended_timeout)

1412

# bump the timeout as if seen

1413

client.checked_ok(client.extended_timeout)

1802

1414

if self.server.use_dbus:

1803

1415

# Emit D-Bus signal

1804

1416

client.GotSecret()

1809

1421

try:

1810

1422

session.bye()

1811

1423

except gnutls.errors.GNUTLSError as error:

1812

logger.warning("GnuTLS bye failed",

1813

exc_info=error)

1424

logger.warning("GnuTLS bye failed")

1814

1425

1815

1426

@staticmethod

1816

1427

def peer_certificate(session):

1872

1483

# Convert the buffer to a Python bytestring

1873

1484

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

1874

1485

# Convert the bytestring to hexadecimal notation

1875

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

1486

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

1876

1487

return hex_fpr

1877

1488

1878

1489

1881

1492

def sub_process_main(self, request, address):

1882

1493

try:

1883

1494

self.finish_request(request, address)

1884

except Exception:

1495

except:

1885

1496

self.handle_error(request, address)

1886

1497

self.close_request(request)

1887

1498

1888

1499

def process_request(self, request, address):

1889

1500

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

1501

multiprocessing.Process(target = self.sub_process_main,

1502

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

1894

1503

1895

1504

1896

1505

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1902

1511

"""

1903

1512

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1904

1513

1905

proc = MultiprocessingMixIn.process_request(self, request,

1906

client_address)

1514

super(MultiprocessingMixInWithPipe,

1515

self).process_request(request, client_address)

1907

1516

self.child_pipe.close()

1908

self.add_pipe(parent_pipe, proc)

1517

self.add_pipe(parent_pipe)

1909

1518

1910

def add_pipe(self, parent_pipe, proc):

1519

def add_pipe(self, parent_pipe):

1911

1520

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

1912

1521

raise NotImplementedError

1913

1522

1922

1531

use_ipv6: Boolean; to use IPv6 or not

1923

1532

"""

1924

1533

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

"""

1534

interface=None, use_ipv6=True):

1929

1535

self.interface = interface

1930

1536

if use_ipv6:

1931

1537

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

1538

socketserver.TCPServer.__init__(self, server_address,

1959

1539

RequestHandlerClass)

1960

1961

1540

def server_bind(self):

1962

1541

"""This overrides the normal server_bind() function

1963

1542

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

1971

1550

try:

1972

1551

self.socket.setsockopt(socket.SOL_SOCKET,

1973

1552

SO_BINDTODEVICE,

1974

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

1553

str(self.interface

1554

+ '\0'))

1975

1555

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:

1556

if error[0] == errno.EPERM:

1557

logger.error("No permission to"

1558

" bind to interface %s",

1559

self.interface)

1560

elif error[0] == errno.ENOPROTOOPT:

1980

1561

logger.error("SO_BINDTODEVICE not available;"

1981

1562

" cannot bind to interface %s",

1982

1563

self.interface)

1983

elif error.errno == errno.ENODEV:

1984

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

1985

" cannot bind", self.interface)

1986

1564

else:

1987

1565

raise

1988

1566

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

1991

1569

if self.address_family == socket.AF_INET6:

1992

1570

any_address = "::" # in6addr_any

1993

1571

else:

1994

any_address = "0.0.0.0" # INADDR_ANY

1572

any_address = socket.INADDR_ANY

1995

1573

self.server_address = (any_address,

1996

1574

self.server_address[1])

1997

1575

elif not self.server_address[1]:

2018

1596

"""

2019

1597

def __init__(self, server_address, RequestHandlerClass,

2020

1598

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

2021

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

1599

gnutls_priority=None, use_dbus=True):

2022

1600

self.enabled = False

2023

1601

self.clients = clients

2024

1602

if self.clients is None:

2025

self.clients = {}

1603

self.clients = set()

2026

1604

self.use_dbus = use_dbus

2027

1605

self.gnutls_priority = gnutls_priority

2028

1606

IPv6_TCPServer.__init__(self, server_address,

2029

1607

RequestHandlerClass,

2030

1608

interface = interface,

2031

use_ipv6 = use_ipv6,

2032

socketfd = socketfd)

1609

use_ipv6 = use_ipv6)

2033

1610

def server_activate(self):

2034

1611

if self.enabled:

2035

1612

return socketserver.TCPServer.server_activate(self)

2036

2037

1613

def enable(self):

2038

1614

self.enabled = True

2039

2040

def add_pipe(self, parent_pipe, proc):

1615

def add_pipe(self, parent_pipe):

2041

1616

# Call "handle_ipc" for both data and EOF events

2042

1617

gobject.io_add_watch(parent_pipe.fileno(),

2043

1618

gobject.IO_IN | gobject.IO_HUP,

2044

1619

functools.partial(self.handle_ipc,

2045

parent_pipe =

2046

parent_pipe,

2047

proc = proc))

2048

1620

parent_pipe = parent_pipe))

1621

2049

1622

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

1623

client_object=None):

1624

condition_names = {

1625

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

1626

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

1627

# blocking).

1628

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

1629

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

1630

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

1631

# broken, usually for pipes and

1632

# sockets).

1633

}

1634

conditions_string = ' | '.join(name

1635

for cond, name in

1636

condition_names.iteritems()

1637

if cond & condition)

1638

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

1639

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

2055

1640

return False

2056

1641

2057

1642

# Read a request from the child

2062

1647

fpr = request[1]

2063

1648

address = request[2]

2064

1649

2065

for c in self.clients.itervalues():

1650

for c in self.clients:

2066

1651

if c.fingerprint == fpr:

2067

1652

client = c

2068

1653

break

2071

1656

"dress: %s", fpr, address)

2072

1657

if self.use_dbus:

2073

1658

# Emit D-Bus signal

2074

mandos_dbus_service.ClientNotFound(fpr,

2075

address[0])

1659

mandos_dbus_service.ClientNotFound(fpr, address[0])

2076

1660

parent_pipe.send(False)

2077

1661

return False

2078

1662

2079

1663

gobject.io_add_watch(parent_pipe.fileno(),

2080

1664

gobject.IO_IN | gobject.IO_HUP,

2081

1665

functools.partial(self.handle_ipc,

2082

parent_pipe =

2083

parent_pipe,

2084

proc = proc,

2085

client_object =

2086

client))

1666

parent_pipe = parent_pipe,

1667

client_object = client))

2087

1668

parent_pipe.send(True)

2088

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

2089

# same fileno

1669

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

2090

1670

return False

2091

1671

if command == 'funcall':

2092

1672

funcname = request[1]

2093

1673

args = request[2]

2094

1674

kwargs = request[3]

2095

1675

2096

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

2097

funcname)(*args,

2098

**kwargs)))

1676

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

2099

1677

2100

1678

if command == 'getattr':

2101

1679

attrname = request[1]

2102

1680

if callable(client_object.__getattribute__(attrname)):

2103

1681

parent_pipe.send(('function',))

2104

1682

else:

2105

parent_pipe.send(('data', client_object

2106

.__getattribute__(attrname)))

1683

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

2107

1684

2108

1685

if command == 'setattr':

2109

1686

attrname = request[1]

2113

1690

return True

2114

1691

2115

1692

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

1693

def string_to_delta(interval):

2216

1694

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

2217

1695

2228

1706

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

2229

1707

datetime.timedelta(0, 330)

2230

1708

"""

2231

2232

try:

2233

return rfc3339_duration_to_delta(interval)

2234

except ValueError:

2235

pass

2236

2237

1709

timevalue = datetime.timedelta(0)

2238

1710

for s in interval.split():

2239

1711

try:

2250

1722

elif suffix == "w":

2251

1723

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

2252

1724

else:

2253

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

2254

.format(suffix))

1725

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

2255

1726

except (ValueError, IndexError) as e:

2256

1727

raise ValueError(*(e.args))

2257

1728

timevalue += delta

2258

1729

return timevalue

2259

1730

2260

1731

1732

def if_nametoindex(interface):

1733

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

1734

1735

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

1736

global if_nametoindex

1737

try:

1738

if_nametoindex = (ctypes.cdll.LoadLibrary

1739

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

1740

.if_nametoindex)

1741

except (OSError, AttributeError):

1742

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

1743

def if_nametoindex(interface):

1744

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

1745

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

1746

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

1747

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1748

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

1749

interface))

1750

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

1751

ifreq[16:20])[0]

1752

return interface_index

1753

return if_nametoindex(interface)

1754

1755

2261

1756

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

2262

1757

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

2263

1758

2271

1766

sys.exit()

2272

1767

if not noclose:

2273

1768

# Close all standard open file descriptors

2274

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

1769

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

2275

1770

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

2276

1771

raise OSError(errno.ENODEV,

2277

"{0} not a character device"

2278

.format(os.devnull))

1772

"%s not a character device"

1773

% os.path.devnull)

2279

1774

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

2280

1775

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

2281

1776

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

2290

1785

2291

1786

parser = argparse.ArgumentParser()

2292

1787

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

2293

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

1788

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

2294

1789

help="show version number and exit")

2295

1790

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

2296

1791

help="Bind to interface IF")

2302

1797

help="Run self-test")

2303

1798

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

2304

1799

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

2305

" to terminal", default=None)

1800

" to terminal")

2306

1801

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

2307

1802

help="Debug level for stdout output")

2308

1803

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

2315

1810

" files")

2316

1811

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

2317

1812

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

2318

" system bus interface", default=None)

1813

" system bus interface")

2319

1814

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

1815

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

2333

1816

options = parser.parse_args()

2334

1817

2335

1818

if options.check:

2343

1826

"port": "",

2344

1827

"debug": "False",

2345

1828

"priority":

2346

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

1829

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

2347

1830

"servicename": "Mandos",

2348

1831

"use_dbus": "True",

2349

1832

"use_ipv6": "True",

2350

1833

"debuglevel": "",

2351

"restore": "True",

2352

"socket": "",

2353

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

2354

"foreground": "False",

2355

1834

}

2356

1835

2357

1836

# Parse config file for server-global settings

2362

1841

# Convert the SafeConfigParser object to a dict

2363

1842

server_settings = server_config.defaults()

2364

1843

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

2365

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

1844

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

2366

1845

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

2367

1846

option)

2368

1847

if server_settings["port"]:

2369

1848

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

2370

1849

"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

1850

del server_config

2381

1851

2382

1852

# Override the settings from the config file with command line

2383

1853

# options, if set.

2384

1854

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

2385

1855

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

2386

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

2387

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

1856

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

2388

1857

value = getattr(options, option)

2389

1858

if value is not None:

2390

1859

server_settings[option] = value

2393

1862

for option in server_settings.keys():

2394

1863

if type(server_settings[option]) is str:

2395

1864

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

1865

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

2404

1866

2405

1867

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

2409

1871

debuglevel = server_settings["debuglevel"]

2410

1872

use_dbus = server_settings["use_dbus"]

2411

1873

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

1874

2425

1875

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

2426

1876

syslogger.setFormatter(logging.Formatter

2427

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

2428

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

2429

.format(server_settings

2430

["servicename"])))

1877

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

1878

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

1879

% server_settings["servicename"]))

2431

1880

2432

1881

# Parse config file with clients

2433

client_config = configparser.SafeConfigParser(Client

2434

.client_defaults)

1882

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

1883

"extended_timeout": "15m",

1884

"interval": "2m",

1885

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

1886

"host": "",

1887

"approval_delay": "0s",

1888

"approval_duration": "1s",

1889

}

1890

client_config = configparser.SafeConfigParser(client_defaults)

2435

1891

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

2436

1892

"clients.conf"))

2437

1893

2446

1902

use_ipv6=use_ipv6,

2447

1903

gnutls_priority=

2448

1904

server_settings["priority"],

2449

use_dbus=use_dbus,

2450

socketfd=(server_settings["socket"]

2451

or None))

2452

if not foreground:

1905

use_dbus=use_dbus)

1906

if not debug:

2453

1907

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

2454

pidfile = None

2455

1908

try:

2456

1909

pidfile = open(pidfilename, "w")

2457

except IOError as e:

2458

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

2459

exc_info=e)

1910

except IOError:

1911

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

2460

1912

2461

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

1913

try:

1914

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

1915

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

1916

except KeyError:

2462

1917

try:

2463

uid = pwd.getpwnam(name).pw_uid

2464

gid = pwd.getpwnam(name).pw_gid

2465

break

1918

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

1919

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

2466

1920

except KeyError:

2467

continue

2468

else:

2469

uid = 65534

2470

gid = 65534

1921

try:

1922

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

1923

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

1924

except KeyError:

1925

uid = 65534

1926

gid = 65534

2471

1927

try:

2472

1928

os.setgid(gid)

2473

1929

os.setuid(uid)

2474

1930

except OSError as error:

2475

if error.errno != errno.EPERM:

1931

if error[0] != errno.EPERM:

2476

1932

raise error

2477

1933

1934

if not debug and not debuglevel:

1935

syslogger.setLevel(logging.WARNING)

1936

console.setLevel(logging.WARNING)

1937

if debuglevel:

1938

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

1939

syslogger.setLevel(level)

1940

console.setLevel(level)

1941

2478

1942

if debug:

2479

1943

# Enable all possible GnuTLS debugging

2480

1944

2490

1954

.gnutls_global_set_log_function(debug_gnutls))

2491

1955

2492

1956

# Redirect stdin so all checkers get /dev/null

2493

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

1957

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

2494

1958

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

2495

1959

if null > 2:

2496

1960

os.close(null)

1961

else:

1962

# No console logging

1963

logger.removeHandler(console)

2497

1964

2498

1965

# Need to fork before connecting to D-Bus

2499

if not foreground:

1966

if not debug:

2500

1967

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

2501

1968

daemon()

2502

1969

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

1970

global main_loop

2508

1971

# From the Avahi example code

2509

DBusGMainLoop(set_as_default=True)

1972

DBusGMainLoop(set_as_default=True )

2510

1973

main_loop = gobject.MainLoop()

2511

1974

bus = dbus.SystemBus()

2512

1975

# End of Avahi example code

2514

1977

try:

2515

1978

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

2516

1979

bus, do_not_queue=True)

2517

old_bus_name = (dbus.service.BusName

2518

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

2519

do_not_queue=True))

1980

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

1981

bus, do_not_queue=True)

2520

1982

except dbus.exceptions.NameExistsException as e:

2521

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

1983

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

2522

1984

use_dbus = False

2523

1985

server_settings["use_dbus"] = False

2524

1986

tcp_server.use_dbus = False

2525

1987

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)

1988

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

1989

servicetype = "_mandos._tcp",

1990

protocol = protocol, bus = bus)

2530

1991

if server_settings["interface"]:

2531

1992

service.interface = (if_nametoindex

2532

1993

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

2536

1997

2537

1998

client_class = Client

2538

1999

if use_dbus:

2539

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

2000

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

2001

def client_config_items(config, section):

2002

special_settings = {

2003

"approved_by_default":

2004

lambda: config.getboolean(section,

2005

"approved_by_default"),

2006

}

2007

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

2622

2008

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

2009

yield (name, special_settings[name]())

2010

except KeyError:

2011

yield (name, value)

2012

2013

tcp_server.clients.update(set(

2014

client_class(name = section,

2015

config= dict(client_config_items(

2016

client_config, section)))

2017

for section in client_config.sections()))

2648

2018

if not tcp_server.clients:

2649

2019

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

2020

2021

if not debug:

2022

try:

2023

with pidfile:

2024

pid = os.getpid()

2025

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

2026

del pidfile

2027

except IOError:

2028

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

2029

pidfilename, pid)

2030

except NameError:

2031

# "pidfile" was never created

2032

pass

2661

2033

del pidfilename

2034

2035

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

2662

2036

2663

2037

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

2664

2038

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

2665

2039

2666

2040

if use_dbus:

2667

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

2668

"se.bsnet.fukt.Mandos"})

2669

class MandosDBusService(DBusObjectWithProperties):

2041

class MandosDBusService(dbus.service.Object):

2670

2042

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

2671

2043

def __init__(self):

2672

2044

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

2673

2045

_interface = "se.recompile.Mandos"

2674

2046

2675

@dbus_interface_annotations(_interface)

2676

def _foo(self):

2677

return { "org.freedesktop.DBus.Property"

2678

".EmitsChangedSignal":

2679

"false"}

2680

2681

2047

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

2682

2048

def ClientAdded(self, objpath):

2683

2049

"D-Bus signal"

2697

2063

def GetAllClients(self):

2698

2064

"D-Bus method"

2699

2065

return dbus.Array(c.dbus_object_path

2700

for c in

2701

tcp_server.clients.itervalues())

2066

for c in tcp_server.clients)

2702

2067

2703

2068

@dbus.service.method(_interface,

2704

2069

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

2706

2071

"D-Bus method"

2707

2072

return dbus.Dictionary(

2708

2073

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

2709

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

2074

for c in tcp_server.clients),

2710

2075

signature="oa{sv}")

2711

2076

2712

2077

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

2713

2078

def RemoveClient(self, object_path):

2714

2079

"D-Bus method"

2715

for c in tcp_server.clients.itervalues():

2080

for c in tcp_server.clients:

2716

2081

if c.dbus_object_path == object_path:

2717

del tcp_server.clients[c.name]

2082

tcp_server.clients.remove(c)

2718

2083

c.remove_from_connection()

2719

2084

# Don't signal anything except ClientRemoved

2720

2085

c.disable(quiet=True)

2725

2090

2726

2091

del _interface

2727

2092

2728

mandos_dbus_service = MandosDBusService()

2093

class MandosDBusServiceTransitional(MandosDBusService):

2094

__metaclass__ = AlternateDBusNamesMetaclass

2095

mandos_dbus_service = MandosDBusServiceTransitional()

2729

2096

2730

2097

def cleanup():

2731

2098

"Cleanup function; run on exit"

2732

2099

service.cleanup()

2733

2100

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

2101

while tcp_server.clients:

2791

name, client = tcp_server.clients.popitem()

2102

client = tcp_server.clients.pop()

2792

2103

if use_dbus:

2793

2104

client.remove_from_connection()

2105

client.disable_hook = None

2794

2106

# Don't signal anything except ClientRemoved

2795

2107

client.disable(quiet=True)

2796

2108

if use_dbus:

2797

2109

# Emit D-Bus signal

2798

mandos_dbus_service.ClientRemoved(client

2799

.dbus_object_path,

2110

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2800

2111

client.name)

2801

client_settings.clear()

2802

2112

2803

2113

atexit.register(cleanup)

2804

2114

2805

for client in tcp_server.clients.itervalues():

2115

for client in tcp_server.clients:

2806

2116

if use_dbus:

2807

2117

# Emit D-Bus signal

2808

2118

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2809

# Need to initiate checking of clients

2810

if client.enabled:

2811

client.init_checker()

2119

client.enable()

2812

2120

2813

2121

tcp_server.enable()

2814

2122

tcp_server.server_activate()

2817

2125

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

2818

2126

if use_ipv6:

2819

2127

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

2820

" flowinfo %d, scope_id %d",

2821

*tcp_server.socket.getsockname())

2128

" flowinfo %d, scope_id %d"

2129

% tcp_server.socket.getsockname())

2822

2130

else: # IPv4

2823

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

2824

*tcp_server.socket.getsockname())

2131

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

2132

% tcp_server.socket.getsockname())

2825

2133

2826

2134

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

2827

2135

2830

2138

try:

2831

2139

service.activate()

2832

2140

except dbus.exceptions.DBusException as error:

2833

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

2141

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

2834

2142

cleanup()

2835

2143

sys.exit(1)

2836

2144

# End of Avahi example code

2843

2151

logger.debug("Starting main loop")

2844

2152

main_loop.run()

2845

2153

except AvahiError as error:

2846

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

2154

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

2847

2155

cleanup()

2848

2156

sys.exit(1)

2849

2157

except KeyboardInterrupt:

2854

2162

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

2855

2163

cleanup()

2856

2164

2165

2857

2166

if __name__ == '__main__':

2858

2167

main()