/mandos/trunk : revision 518.1.3

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

#

4

# Mandos server - give out binary blobs to connecting clients.

5

#

6

# This program is partly derived from an example program for an Avahi

7

# service publisher, downloaded from

8

# <http://avahi.org/wiki/PythonPublishExample>. This includes the

9

# methods "add", "remove", "server_state_changed",

10

# "entry_group_state_changed", "cleanup", and "activate" in the

11

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

12

#

13

# Everything else is

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

19

# the Free Software Foundation, either version 3 of the License, or

20

# (at your option) any later version.

21

#

22

# This program is distributed in the hope that it will be useful,

23

# but WITHOUT ANY WARRANTY; without even the implied warranty of

24

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

25

# GNU General Public License for more details.

26

#

27

# You should have received a copy of the GNU General Public License

28

# along with this program. If not, see

29

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

30

#

31

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

32

#

33

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

import SocketServer as socketserver

38

import socket

39

import argparse

40

import datetime

41

import errno

42

import gnutls.crypto

43

import gnutls.connection

44

import gnutls.errors

45

import gnutls.library.functions

46

import gnutls.library.constants

47

import gnutls.library.types

48

import ConfigParser as configparser

49

import sys

50

import re

51

import os

52

import signal

53

import subprocess

54

import atexit

55

import stat

56

import logging

57

import logging.handlers

58

import pwd

59

import contextlib

60

import struct

61

import fcntl

62

import functools

63

import cPickle as pickle

64

import multiprocessing

65

import types

66

import hashlib

67

68

import dbus

69

import dbus.service

70

import gobject

71

import avahi

72

from dbus.mainloop.glib import DBusGMainLoop

73

import ctypes

74

import ctypes.util

75

import xml.dom.minidom

76

import inspect

77

import Crypto.Cipher.AES

78

79

try:

80

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

81

except AttributeError:

82

try:

83

from IN import SO_BINDTODEVICE

84

except ImportError:

85

SO_BINDTODEVICE = None

86

87

88

version = "1.4.1"

89

90

logger = logging.getLogger()

91

stored_state_path = "/var/lib/mandos/clients.pickle"

92

93

syslogger = (logging.handlers.SysLogHandler

94

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

95

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

96

syslogger.setFormatter(logging.Formatter

97

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

98

' %(message)s'))

99

logger.addHandler(syslogger)

100

101

console = logging.StreamHandler()

102

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

103

' [%(process)d]:'

104

' %(levelname)s:'

105

' %(message)s'))

106

logger.addHandler(console)

107

108

109

class AvahiError(Exception):

110

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

111

self.value = value

112

super(AvahiError, self).__init__(value, *args, **kwargs)

113

def __unicode__(self):

114

return unicode(repr(self.value))

115

116

class AvahiServiceError(AvahiError):

117

pass

118

119

class AvahiGroupError(AvahiError):

120

pass

121

122

123

class AvahiService(object):

124

"""An Avahi (Zeroconf) service.

125

126

Attributes:

127

interface: integer; avahi.IF_UNSPEC or an interface index.

128

Used to optionally bind to the specified interface.

129

name: string; Example: 'Mandos'

130

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

131

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

132

port: integer; what port to announce

133

TXT: list of strings; TXT record for the service

134

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

135

host: string; Host to publish records for, default is localhost

136

max_renames: integer; maximum number of renames

137

rename_count: integer; counter so we only rename after collisions

138

a sensible number of times

139

group: D-Bus Entry Group

140

server: D-Bus Server

141

bus: dbus.SystemBus()

142

"""

143

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

144

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

145

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

146

protocol = avahi.PROTO_UNSPEC, bus = None):

147

self.interface = interface

148

self.name = name

149

self.type = servicetype

150

self.port = port

151

self.TXT = TXT if TXT is not None else []

152

self.domain = domain

153

self.host = host

154

self.rename_count = 0

155

self.max_renames = max_renames

156

self.protocol = protocol

157

self.group = None # our entry group

158

self.server = None

159

self.bus = bus

160

self.entry_group_state_changed_match = None

161

def rename(self):

162

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

163

if self.rename_count >= self.max_renames:

164

logger.critical("No suitable Zeroconf service name found"

165

" after %i retries, exiting.",

166

self.rename_count)

167

raise AvahiServiceError("Too many renames")

168

self.name = unicode(self.server

169

.GetAlternativeServiceName(self.name))

170

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

171

self.name)

172

self.remove()

173

try:

174

self.add()

175

except dbus.exceptions.DBusException as error:

176

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

177

self.cleanup()

178

os._exit(1)

179

self.rename_count += 1

180

def remove(self):

181

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

182

if self.entry_group_state_changed_match is not None:

183

self.entry_group_state_changed_match.remove()

184

self.entry_group_state_changed_match = None

185

if self.group is not None:

186

self.group.Reset()

187

def add(self):

188

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

189

self.remove()

190

if self.group is None:

191

self.group = dbus.Interface(

192

self.bus.get_object(avahi.DBUS_NAME,

193

self.server.EntryGroupNew()),

194

avahi.DBUS_INTERFACE_ENTRY_GROUP)

195

self.entry_group_state_changed_match = (

196

self.group.connect_to_signal(

197

'StateChanged', self.entry_group_state_changed))

198

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

199

self.name, self.type)

200

self.group.AddService(

201

self.interface,

202

self.protocol,

203

dbus.UInt32(0), # flags

204

self.name, self.type,

205

self.domain, self.host,

206

dbus.UInt16(self.port),

207

avahi.string_array_to_txt_array(self.TXT))

208

self.group.Commit()

209

def entry_group_state_changed(self, state, error):

210

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

211

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

212

213

if state == avahi.ENTRY_GROUP_ESTABLISHED:

214

logger.debug("Zeroconf service established.")

215

elif state == avahi.ENTRY_GROUP_COLLISION:

216

logger.info("Zeroconf service name collision.")

217

self.rename()

218

elif state == avahi.ENTRY_GROUP_FAILURE:

219

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

220

unicode(error))

221

raise AvahiGroupError("State changed: %s"

222

% unicode(error))

223

def cleanup(self):

224

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

225

if self.group is not None:

226

try:

227

self.group.Free()

228

except (dbus.exceptions.UnknownMethodException,

229

dbus.exceptions.DBusException) as e:

230

pass

231

self.group = None

232

self.remove()

233

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

234

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

235

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

236

bad_states = { avahi.SERVER_INVALID:

237

"Zeroconf server invalid",

238

avahi.SERVER_REGISTERING: None,

239

avahi.SERVER_COLLISION:

240

"Zeroconf server name collision",

241

avahi.SERVER_FAILURE:

242

"Zeroconf server failure" }

243

if state in bad_states:

244

if bad_states[state] is not None:

245

if error is None:

246

logger.error(bad_states[state])

247

else:

248

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

249

self.cleanup()

250

elif state == avahi.SERVER_RUNNING:

251

self.add()

252

else:

253

if error is None:

254

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

255

else:

256

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

257

def activate(self):

258

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

259

if self.server is None:

260

self.server = dbus.Interface(

261

self.bus.get_object(avahi.DBUS_NAME,

262

avahi.DBUS_PATH_SERVER,

263

follow_name_owner_changes=True),

264

avahi.DBUS_INTERFACE_SERVER)

265

self.server.connect_to_signal("StateChanged",

266

self.server_state_changed)

267

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

268

269

class AvahiServiceToSyslog(AvahiService):

270

def rename(self):

271

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

272

ret = AvahiService.rename(self)

273

syslogger.setFormatter(logging.Formatter

274

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

275

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

276

% self.name))

277

return ret

278

279

def _timedelta_to_milliseconds(td):

280

"Convert a datetime.timedelta() to milliseconds"

281

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

282

+ (td.seconds * 1000)

283

+ (td.microseconds // 1000))

284

285

class Client(object):

286

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

287

288

Attributes:

289

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

290

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

291

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

292

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

293

to see if the client lives.

294

'None' if no process is running.

295

checker_callback_tag: a gobject event source tag, or None

296

checker_command: string; External command which is run to check

297

if client lives. %() expansions are done at

298

runtime with vars(self) as dict, so that for

299

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

300

checker_initiator_tag: a gobject event source tag, or None

301

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

302

client_structure: Object describing what attributes a client has

303

and is used for storing the client at exit

304

current_checker_command: string; current running checker_command

305

disable_initiator_tag: a gobject event source tag, or None

306

enabled: bool()

307

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

308

uniquely identify the client

309

host: string; available for use by the checker command

310

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

311

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

312

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

313

last_checker_status: integer between 0 and 255 reflecting exit status

314

of last checker. -1 reflect crashed checker,

315

or None.

316

last_enabled: datetime.datetime(); (UTC)

317

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

318

D-Bus identifiers

319

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

320

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

321

until this client is disabled

322

extended_timeout: extra long timeout when password has been sent

323

runtime_expansions: Allowed attributes for runtime expansion.

324

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

325

disabled, or None

326

"""

327

328

runtime_expansions = ("approval_delay", "approval_duration",

329

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

330

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

331

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

332

333

def timeout_milliseconds(self):

334

"Return the 'timeout' attribute in milliseconds"

335

return _timedelta_to_milliseconds(self.timeout)

336

337

def extended_timeout_milliseconds(self):

338

"Return the 'extended_timeout' attribute in milliseconds"

339

return _timedelta_to_milliseconds(self.extended_timeout)

340

341

def interval_milliseconds(self):

342

"Return the 'interval' attribute in milliseconds"

343

return _timedelta_to_milliseconds(self.interval)

344

345

def approval_delay_milliseconds(self):

346

return _timedelta_to_milliseconds(self.approval_delay)

347

348

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

349

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

350

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

351

attribute."""

352

self.name = name

353

if config is None:

354

config = {}

355

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

356

# Uppercase and remove spaces from fingerprint for later

357

# comparison purposes with return value from the fingerprint()

358

# function

359

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

360

.replace(" ", ""))

361

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

362

if "secret" in config:

363

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

364

elif "secfile" in config:

365

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

366

(config["secfile"])),

367

"rb") as secfile:

368

self.secret = secfile.read()

369

else:

370

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

371

% self.name)

372

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

373

self.created = datetime.datetime.utcnow()

374

self.enabled = True

375

self.last_approval_request = None

376

self.last_enabled = datetime.datetime.utcnow()

377

self.last_checked_ok = None

378

self.last_checker_status = None

379

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

380

self.extended_timeout = string_to_delta(config

381

["extended_timeout"])

382

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

383

self.checker = None

384

self.checker_initiator_tag = None

385

self.disable_initiator_tag = None

386

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

387

self.checker_callback_tag = None

388

self.checker_command = config["checker"]

389

self.current_checker_command = None

390

self._approved = None

391

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

392

True)

393

self.approvals_pending = 0

394

self.approval_delay = string_to_delta(

395

config["approval_delay"])

396

self.approval_duration = string_to_delta(

397

config["approval_duration"])

398

self.changedstate = (multiprocessing_manager

399

.Condition(multiprocessing_manager

400

.Lock()))

401

self.client_structure = [attr for attr in self.__dict__.iterkeys() if not attr.startswith("_")]

402

self.client_structure.append("client_structure")

403

404

405

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

406

lambda obj: isinstance(obj, property)):

407

if not name.startswith("_"):

408

self.client_structure.append(name)

409

410

# Send notice to process children that client state has changed

411

def send_changedstate(self):

412

with self.changedstate:

413

self.changedstate.notify_all()

414

415

def enable(self):

416

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

417

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

418

# Already enabled

419

return

420

self.send_changedstate()

421

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

422

self.enabled = True

423

self.last_enabled = datetime.datetime.utcnow()

424

self.init_checker()

425

426

def disable(self, quiet=True):

427

"""Disable this client."""

428

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

429

return False

430

if not quiet:

431

self.send_changedstate()

432

if not quiet:

433

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

434

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

435

gobject.source_remove(self.disable_initiator_tag)

436

self.disable_initiator_tag = None

437

self.expires = None

438

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

439

gobject.source_remove(self.checker_initiator_tag)

440

self.checker_initiator_tag = None

441

self.stop_checker()

442

self.enabled = False

443

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

444

return False

445

446

def __del__(self):

447

self.disable()

448

449

def init_checker(self):

450

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

451

# and every interval from then on.

452

self.checker_initiator_tag = (gobject.timeout_add

453

(self.interval_milliseconds(),

454

self.start_checker))

455

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

456

self.disable_initiator_tag = (gobject.timeout_add

457

(self.timeout_milliseconds(),

458

self.disable))

459

# Also start a new checker *right now*.

460

self.start_checker()

461

462

463

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

464

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

465

self.checker_callback_tag = None

466

self.checker = None

467

if os.WIFEXITED(condition):

468

self.last_checker_status = os.WEXITSTATUS(condition)

469

if self.last_checker_status == 0:

470

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

471

vars(self))

472

self.checked_ok()

473

else:

474

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

475

vars(self))

476

else:

477

self.last_checker_status = -1

478

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

479

vars(self))

480

481

def checked_ok(self, timeout=None):

482

"""Bump up the timeout for this client.

483

484

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

485

alive and well.

486

"""

487

if timeout is None:

488

timeout = self.timeout

489

self.last_checked_ok = datetime.datetime.utcnow()

490

if self.disable_initiator_tag is not None:

491

gobject.source_remove(self.disable_initiator_tag)

492

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

493

self.disable_initiator_tag = (gobject.timeout_add

494

(_timedelta_to_milliseconds

495

(timeout), self.disable))

496

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

497

498

def need_approval(self):

499

self.last_approval_request = datetime.datetime.utcnow()

500

501

def start_checker(self):

502

"""Start a new checker subprocess if one is not running.

503

504

If a checker already exists, leave it running and do

505

nothing."""

506

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

507

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

508

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

509

# client would inevitably timeout, since no checker would get

510

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

511

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

512

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

513

# should be.

514

515

# If a checker exists, make sure it is not a zombie

516

try:

517

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

518

except (AttributeError, OSError) as error:

519

if (isinstance(error, OSError)

520

and error.errno != errno.ECHILD):

521

raise error

522

else:

523

if pid:

524

logger.warning("Checker was a zombie")

525

gobject.source_remove(self.checker_callback_tag)

526

self.checker_callback(pid, status,

527

self.current_checker_command)

528

# Start a new checker if needed

529

if self.checker is None:

530

try:

531

# In case checker_command has exactly one % operator

532

command = self.checker_command % self.host

533

except TypeError:

534

# Escape attributes for the shell

535

escaped_attrs = dict(

536

(attr,

537

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

538

errors=

539

'replace')))

540

for attr in

541

self.runtime_expansions)

542

543

try:

544

command = self.checker_command % escaped_attrs

545

except TypeError as error:

546

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

547

' %s', self.checker_command, error)

548

return True # Try again later

549

self.current_checker_command = command

550

try:

551

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

552

command, self.name)

553

# We don't need to redirect stdout and stderr, since

554

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

555

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

556

# always replaced by /dev/null.)

557

self.checker = subprocess.Popen(command,

558

close_fds=True,

559

shell=True, cwd="/")

560

self.checker_callback_tag = (gobject.child_watch_add

561

(self.checker.pid,

562

self.checker_callback,

563

data=command))

564

# The checker may have completed before the gobject

565

# watch was added. Check for this.

566

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

567

if pid:

568

gobject.source_remove(self.checker_callback_tag)

569

self.checker_callback(pid, status, command)

570

except OSError as error:

571

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

572

error)

573

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

574

return True

575

576

def stop_checker(self):

577

"""Force the checker process, if any, to stop."""

578

if self.checker_callback_tag:

579

gobject.source_remove(self.checker_callback_tag)

580

self.checker_callback_tag = None

581

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

582

return

583

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

584

try:

585

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

586

#time.sleep(0.5)

587

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

588

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

589

except OSError as error:

590

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

591

raise

592

self.checker = None

593

594

# Encrypts a client secret and stores it in a varible encrypted_secret

595

def encrypt_secret(self, key):

596

# Encryption-key need to be of a specific size, so we hash inputed key

597

hasheng = hashlib.sha256()

598

hasheng.update(key)

599

encryptionkey = hasheng.digest()

600

601

# Create validation hash so we know at decryption if it was sucessful

602

hasheng = hashlib.sha256()

603

hasheng.update(self.secret)

604

validationhash = hasheng.digest()

605

606

# Encrypt secret

607

iv = os.urandom(Crypto.Cipher.AES.block_size)

608

ciphereng = Crypto.Cipher.AES.new(encryptionkey,

609

Crypto.Cipher.AES.MODE_CFB, iv)

610

ciphertext = ciphereng.encrypt(validationhash+self.secret)

611

self.encrypted_secret = (ciphertext, iv)

612

613

# Decrypt a encrypted client secret

614

def decrypt_secret(self, key):

615

# Decryption-key need to be of a specific size, so we hash inputed key

616

hasheng = hashlib.sha256()

617

hasheng.update(key)

618

encryptionkey = hasheng.digest()

619

620

# Decrypt encrypted secret

621

ciphertext, iv = self.encrypted_secret

622

ciphereng = Crypto.Cipher.AES.new(encryptionkey,

623

Crypto.Cipher.AES.MODE_CFB, iv)

624

plain = ciphereng.decrypt(ciphertext)

625

626

# Validate decrypted secret to know if it was succesful

627

hasheng = hashlib.sha256()

628

validationhash = plain[:hasheng.digest_size]

629

secret = plain[hasheng.digest_size:]

630

hasheng.update(secret)

631

632

# if validation fails, we use key as new secret. Otherwhise, we use

633

# the decrypted secret

634

if hasheng.digest() == validationhash:

635

self.secret = secret

636

else:

637

self.secret = key

638

del self.encrypted_secret

639

640

641

def dbus_service_property(dbus_interface, signature="v",

642

access="readwrite", byte_arrays=False):

643

"""Decorators for marking methods of a DBusObjectWithProperties to

644

become properties on the D-Bus.

645

646

The decorated method will be called with no arguments by "Get"

647

and with one argument by "Set".

648

649

The parameters, where they are supported, are the same as

650

dbus.service.method, except there is only "signature", since the

651

type from Get() and the type sent to Set() is the same.

652

"""

653

# Encoding deeply encoded byte arrays is not supported yet by the

654

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

655

if byte_arrays and signature != "ay":

656

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

657

" signature %r" % signature)

658

def decorator(func):

659

func._dbus_is_property = True

660

func._dbus_interface = dbus_interface

661

func._dbus_signature = signature

662

func._dbus_access = access

663

func._dbus_name = func.__name__

664

if func._dbus_name.endswith("_dbus_property"):

665

func._dbus_name = func._dbus_name[:-14]

666

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

667

return func

668

return decorator

669

670

671

class DBusPropertyException(dbus.exceptions.DBusException):

672

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

673

"""

674

def __unicode__(self):

675

return unicode(str(self))

676

677

678

class DBusPropertyAccessException(DBusPropertyException):

679

"""A property's access permissions disallows an operation.

680

"""

681

pass

682

683

684

class DBusPropertyNotFound(DBusPropertyException):

685

"""An attempt was made to access a non-existing property.

686

"""

687

pass

688

689

690

class DBusObjectWithProperties(dbus.service.Object):

691

"""A D-Bus object with properties.

692

693

Classes inheriting from this can use the dbus_service_property

694

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

695

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

696

"""

697

698

@staticmethod

699

def _is_dbus_property(obj):

700

return getattr(obj, "_dbus_is_property", False)

701

702

def _get_all_dbus_properties(self):

703

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

704

"""

705

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

706

for cls in self.__class__.__mro__

707

for name, prop in

708

inspect.getmembers(cls, self._is_dbus_property))

709

710

def _get_dbus_property(self, interface_name, property_name):

711

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

712

property with the specified name and interface.

713

"""

714

for cls in self.__class__.__mro__:

715

for name, value in (inspect.getmembers

716

(cls, self._is_dbus_property)):

717

if (value._dbus_name == property_name

718

and value._dbus_interface == interface_name):

719

return value.__get__(self)

720

721

# No such property

722

raise DBusPropertyNotFound(self.dbus_object_path + ":"

723

+ interface_name + "."

724

+ property_name)

725

726

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

727

out_signature="v")

728

def Get(self, interface_name, property_name):

729

"""Standard D-Bus property Get() method, see D-Bus standard.

730

"""

731

prop = self._get_dbus_property(interface_name, property_name)

732

if prop._dbus_access == "write":

733

raise DBusPropertyAccessException(property_name)

734

value = prop()

735

if not hasattr(value, "variant_level"):

736

return value

737

return type(value)(value, variant_level=value.variant_level+1)

738

739

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")

740

def Set(self, interface_name, property_name, value):

741

"""Standard D-Bus property Set() method, see D-Bus standard.

742

"""

743

prop = self._get_dbus_property(interface_name, property_name)

744

if prop._dbus_access == "read":

745

raise DBusPropertyAccessException(property_name)

746

if prop._dbus_get_args_options["byte_arrays"]:

747

# The byte_arrays option is not supported yet on

748

# signatures other than "ay".

749

if prop._dbus_signature != "ay":

750

raise ValueError

751

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

752

for byte in value))

753

prop(value)

754

755

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

756

out_signature="a{sv}")

757

def GetAll(self, interface_name):

758

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

759

standard.

760

761

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

762

"""

763

all = {}

764

for name, prop in self._get_all_dbus_properties():

765

if (interface_name

766

and interface_name != prop._dbus_interface):

767

# Interface non-empty but did not match

768

continue

769

# Ignore write-only properties

770

if prop._dbus_access == "write":

771

continue

772

value = prop()

773

if not hasattr(value, "variant_level"):

774

all[name] = value

775

continue

776

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

777

value.variant_level+1)

778

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

779

780

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

781

out_signature="s",

782

path_keyword='object_path',

783

connection_keyword='connection')

784

def Introspect(self, object_path, connection):

785

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

786

"""

787

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

788

connection)

789

try:

790

document = xml.dom.minidom.parseString(xmlstring)

791

def make_tag(document, name, prop):

792

e = document.createElement("property")

793

e.setAttribute("name", name)

794

e.setAttribute("type", prop._dbus_signature)

795

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

796

return e

797

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

798

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

799

for name, prop

800

in self._get_all_dbus_properties()

801

if prop._dbus_interface

802

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

803

if_tag.appendChild(tag)

804

# Add the names to the return values for the

805

# "org.freedesktop.DBus.Properties" methods

806

if (if_tag.getAttribute("name")

807

== "org.freedesktop.DBus.Properties"):

808

for cn in if_tag.getElementsByTagName("method"):

809

if cn.getAttribute("name") == "Get":

810

for arg in cn.getElementsByTagName("arg"):

811

if (arg.getAttribute("direction")

812

== "out"):

813

arg.setAttribute("name", "value")

814

elif cn.getAttribute("name") == "GetAll":

815

for arg in cn.getElementsByTagName("arg"):

816

if (arg.getAttribute("direction")

817

== "out"):

818

arg.setAttribute("name", "props")

819

xmlstring = document.toxml("utf-8")

820

document.unlink()

821

except (AttributeError, xml.dom.DOMException,

822

xml.parsers.expat.ExpatError) as error:

823

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

824

error)

825

return xmlstring

826

827

828

def datetime_to_dbus (dt, variant_level=0):

829

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

830

if dt is None:

831

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

832

return dbus.String(dt.isoformat(),

833

variant_level=variant_level)

834

835

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

836

.__metaclass__):

837

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

838

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

839

"""

840

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

841

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

842

# methods, signals, or properties in them

843

for base in (b for b in bases

844

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

845

# Go though all attributes of the base class

846

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

847

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

848

# with the wrong interface name

849

if (not hasattr(attribute, "_dbus_interface")

850

or not attribute._dbus_interface

851

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

852

continue

853

# Create an alternate D-Bus interface name based on

854

# the current name

855

alt_interface = (attribute._dbus_interface

856

.replace("se.recompile.Mandos",

857

"se.bsnet.fukt.Mandos"))

858

# Is this a D-Bus signal?

859

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

860

# Extract the original non-method function by

861

# black magic

862

nonmethod_func = (dict(

863

zip(attribute.func_code.co_freevars,

864

attribute.__closure__))["func"]

865

.cell_contents)

866

# Create a new, but exactly alike, function

867

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

868

# with the alternate D-Bus interface name

869

new_function = (dbus.service.signal

870

(alt_interface,

871

attribute._dbus_signature)

872

(types.FunctionType(

873

nonmethod_func.func_code,

874

nonmethod_func.func_globals,

875

nonmethod_func.func_name,

876

nonmethod_func.func_defaults,

877

nonmethod_func.func_closure)))

878

# Define a creator of a function to call both the

879

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

880

# signals gets sent when the function is called

881

def fixscope(func1, func2):

882

"""This function is a scope container to pass

883

func1 and func2 to the "call_both" function

884

outside of its arguments"""

885

def call_both(*args, **kwargs):

886

"""This function will emit two D-Bus

887

signals by calling func1 and func2"""

888

func1(*args, **kwargs)

889

func2(*args, **kwargs)

890

return call_both

891

# Create the "call_both" function and add it to

892

# the class

893

attr[attrname] = fixscope(attribute,

894

new_function)

895

# Is this a D-Bus method?

896

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

897

# Create a new, but exactly alike, function

898

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

899

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

900

# to the class.

901

attr[attrname] = (dbus.service.method

902

(alt_interface,

903

attribute._dbus_in_signature,

904

attribute._dbus_out_signature)

905

(types.FunctionType

906

(attribute.func_code,

907

attribute.func_globals,

908

attribute.func_name,

909

attribute.func_defaults,

910

attribute.func_closure)))

911

# Is this a D-Bus property?

912

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

913

# Create a new, but exactly alike, function

914

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

915

# property with the alternate D-Bus interface

916

# name. Add it to the class.

917

attr[attrname] = (dbus_service_property

918

(alt_interface,

919

attribute._dbus_signature,

920

attribute._dbus_access,

921

attribute

922

._dbus_get_args_options

923

["byte_arrays"])

924

(types.FunctionType

925

(attribute.func_code,

926

attribute.func_globals,

927

attribute.func_name,

928

attribute.func_defaults,

929

attribute.func_closure)))

930

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

931

932

class ClientDBus(Client, DBusObjectWithProperties):

933

"""A Client class using D-Bus

934

935

Attributes:

936

dbus_object_path: dbus.ObjectPath

937

bus: dbus.SystemBus()

938

"""

939

940

runtime_expansions = (Client.runtime_expansions

941

+ ("dbus_object_path",))

942

943

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

944

945

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

946

self.bus = bus

947

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

948

949

self._approvals_pending = 0

950

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

951

# the D-Bus

952

client_object_name = unicode(self.name).translate(

953

{ord("."): ord("_"),

954

ord("-"): ord("_")})

955

self.dbus_object_path = (dbus.ObjectPath

956

("/clients/" + client_object_name))

957

DBusObjectWithProperties.__init__(self, self.bus,

958

self.dbus_object_path)

959

960

def notifychangeproperty(transform_func,

961

dbus_name, type_func=lambda x: x,

962

variant_level=1):

963

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

964

its changes to DBus.

965

966

transform_fun: Function that takes a value and a variant_level

967

and transforms it to a D-Bus type.

968

dbus_name: D-Bus name of the variable

969

type_func: Function that transform the value before sending it

970

to the D-Bus. Default: no transform

971

variant_level: D-Bus variant level. Default: 1

972

"""

973

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

974

def setter(self, value):

975

if hasattr(self, "dbus_object_path"):

976

if (not hasattr(self, attrname) or

977

type_func(getattr(self, attrname, None))

978

!= type_func(value)):

979

dbus_value = transform_func(type_func(value),

980

variant_level

981

=variant_level)

982

self.PropertyChanged(dbus.String(dbus_name),

983

dbus_value)

984

setattr(self, attrname, value)

985

986

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

987

988

989

expires = notifychangeproperty(datetime_to_dbus, "Expires")

990

approvals_pending = notifychangeproperty(dbus.Boolean,

991

"ApprovalPending",

992

type_func = bool)

993

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

994

last_enabled = notifychangeproperty(datetime_to_dbus,

995

"LastEnabled")

996

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

997

type_func = lambda checker:

998

checker is not None)

999

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1000

"LastCheckedOK")

1001

last_approval_request = notifychangeproperty(

1002

datetime_to_dbus, "LastApprovalRequest")

1003

approved_by_default = notifychangeproperty(dbus.Boolean,

1004

"ApprovedByDefault")

1005

approval_delay = notifychangeproperty(dbus.UInt16,

1006

"ApprovalDelay",

1007

type_func =

1008

_timedelta_to_milliseconds)

1009

approval_duration = notifychangeproperty(

1010

dbus.UInt16, "ApprovalDuration",

1011

type_func = _timedelta_to_milliseconds)

1012

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

1013

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

1014

type_func =

1015

_timedelta_to_milliseconds)

1016

extended_timeout = notifychangeproperty(

1017

dbus.UInt16, "ExtendedTimeout",

1018

type_func = _timedelta_to_milliseconds)

1019

interval = notifychangeproperty(dbus.UInt16,

1020

"Interval",

1021

type_func =

1022

_timedelta_to_milliseconds)

1023

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

1024

1025

del notifychangeproperty

1026

1027

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

1028

try:

1029

self.remove_from_connection()

1030

except LookupError:

1031

pass

1032

if hasattr(DBusObjectWithProperties, "__del__"):

1033

DBusObjectWithProperties.__del__(self, *args, **kwargs)

1034

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

1035

1036

def checker_callback(self, pid, condition, command,

1037

*args, **kwargs):

1038

self.checker_callback_tag = None

1039

self.checker = None

1040

if os.WIFEXITED(condition):

1041

exitstatus = os.WEXITSTATUS(condition)

1042

# Emit D-Bus signal

1043

self.CheckerCompleted(dbus.Int16(exitstatus),

1044

dbus.Int64(condition),

1045

dbus.String(command))

1046

else:

1047

# Emit D-Bus signal

1048

self.CheckerCompleted(dbus.Int16(-1),

1049

dbus.Int64(condition),

1050

dbus.String(command))

1051

1052

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

1053

*args, **kwargs)

1054

1055

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

1056

old_checker = self.checker

1057

if self.checker is not None:

1058

old_checker_pid = self.checker.pid

1059

else:

1060

old_checker_pid = None

1061

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

1062

# Only if new checker process was started

1063

if (self.checker is not None

1064

and old_checker_pid != self.checker.pid):

1065

# Emit D-Bus signal

1066

self.CheckerStarted(self.current_checker_command)

1067

return r

1068

1069

def _reset_approved(self):

1070

self._approved = None

1071

return False

1072

1073

def approve(self, value=True):

1074

self.send_changedstate()

1075

self._approved = value

1076

gobject.timeout_add(_timedelta_to_milliseconds

1077

(self.approval_duration),

1078

self._reset_approved)

1079

1080

1081

## D-Bus methods, signals & properties

1082

_interface = "se.recompile.Mandos.Client"

1083

1084

## Signals

1085

1086

# CheckerCompleted - signal

1087

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

1088

def CheckerCompleted(self, exitcode, waitstatus, command):

1089

"D-Bus signal"

1090

pass

1091

1092

# CheckerStarted - signal

1093

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

1094

def CheckerStarted(self, command):

1095

"D-Bus signal"

1096

pass

1097

1098

# PropertyChanged - signal

1099

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

1100

def PropertyChanged(self, property, value):

1101

"D-Bus signal"

1102

pass

1103

1104

# GotSecret - signal

1105

@dbus.service.signal(_interface)

1106

def GotSecret(self):

1107

"""D-Bus signal

1108

Is sent after a successful transfer of secret from the Mandos

1109

server to mandos-client

1110

"""

1111

pass

1112

1113

# Rejected - signal

1114

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

1115

def Rejected(self, reason):

1116

"D-Bus signal"

1117

pass

1118

1119

# NeedApproval - signal

1120

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

1121

def NeedApproval(self, timeout, default):

1122

"D-Bus signal"

1123

return self.need_approval()

1124

1125

# NeRwequest - signal

1126

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

1127

def NewRequest(self, ip):

1128

"""D-Bus signal

1129

Is sent after a client request a password.

1130

"""

1131

pass

1132

1133

## Methods

1134

1135

# Approve - method

1136

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

1137

def Approve(self, value):

1138

self.approve(value)

1139

1140

# CheckedOK - method

1141

@dbus.service.method(_interface)

1142

def CheckedOK(self):

1143

self.checked_ok()

1144

1145

# Enable - method

1146

@dbus.service.method(_interface)

1147

def Enable(self):

1148

"D-Bus method"

1149

self.enable()

1150

1151

# StartChecker - method

1152

@dbus.service.method(_interface)

1153

def StartChecker(self):

1154

"D-Bus method"

1155

self.start_checker()

1156

1157

# Disable - method

1158

@dbus.service.method(_interface)

1159

def Disable(self):

1160

"D-Bus method"

1161

self.disable()

1162

1163

# StopChecker - method

1164

@dbus.service.method(_interface)

1165

def StopChecker(self):

1166

self.stop_checker()

1167

1168

## Properties

1169

1170

# ApprovalPending - property

1171

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

1172

def ApprovalPending_dbus_property(self):

1173

return dbus.Boolean(bool(self.approvals_pending))

1174

1175

# ApprovedByDefault - property

1176

@dbus_service_property(_interface, signature="b",

1177

access="readwrite")

1178

def ApprovedByDefault_dbus_property(self, value=None):

1179

if value is None: # get

1180

return dbus.Boolean(self.approved_by_default)

1181

self.approved_by_default = bool(value)

1182

1183

# ApprovalDelay - property

1184

@dbus_service_property(_interface, signature="t",

1185

access="readwrite")

1186

def ApprovalDelay_dbus_property(self, value=None):

1187

if value is None: # get

1188

return dbus.UInt64(self.approval_delay_milliseconds())

1189

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

1190

1191

# ApprovalDuration - property

1192

@dbus_service_property(_interface, signature="t",

1193

access="readwrite")

1194

def ApprovalDuration_dbus_property(self, value=None):

1195

if value is None: # get

1196

return dbus.UInt64(_timedelta_to_milliseconds(

1197

self.approval_duration))

1198

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

1199

1200

# Name - property

1201

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

1202

def Name_dbus_property(self):

1203

return dbus.String(self.name)

1204

1205

# Fingerprint - property

1206

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

1207

def Fingerprint_dbus_property(self):

1208

return dbus.String(self.fingerprint)

1209

1210

# Host - property

1211

@dbus_service_property(_interface, signature="s",

1212

access="readwrite")

1213

def Host_dbus_property(self, value=None):

1214

if value is None: # get

1215

return dbus.String(self.host)

1216

self.host = value

1217

1218

# Created - property

1219

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

1220

def Created_dbus_property(self):

1221

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

1222

1223

# LastEnabled - property

1224

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

1225

def LastEnabled_dbus_property(self):

1226

return datetime_to_dbus(self.last_enabled)

1227

1228

# Enabled - property

1229

@dbus_service_property(_interface, signature="b",

1230

access="readwrite")

1231

def Enabled_dbus_property(self, value=None):

1232

if value is None: # get

1233

return dbus.Boolean(self.enabled)

1234

if value:

1235

self.enable()

1236

else:

1237

self.disable()

1238

1239

# LastCheckedOK - property

1240

@dbus_service_property(_interface, signature="s",

1241

access="readwrite")

1242

def LastCheckedOK_dbus_property(self, value=None):

1243

if value is not None:

1244

self.checked_ok()

1245

return

1246

return datetime_to_dbus(self.last_checked_ok)

1247

1248

# Expires - property

1249

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

1250

def Expires_dbus_property(self):

1251

return datetime_to_dbus(self.expires)

1252

1253

# LastApprovalRequest - property

1254

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

1255

def LastApprovalRequest_dbus_property(self):

1256

return datetime_to_dbus(self.last_approval_request)

1257

1258

# Timeout - property

1259

@dbus_service_property(_interface, signature="t",

1260

access="readwrite")

1261

def Timeout_dbus_property(self, value=None):

1262

if value is None: # get

1263

return dbus.UInt64(self.timeout_milliseconds())

1264

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

1265

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

1266

return

1267

# Reschedule timeout

1268

gobject.source_remove(self.disable_initiator_tag)

1269

self.disable_initiator_tag = None

1270

self.expires = None

1271

time_to_die = _timedelta_to_milliseconds((self

1272

.last_checked_ok

1273

+ self.timeout)

1274

- datetime.datetime

1275

.utcnow())

1276

if time_to_die <= 0:

1277

# The timeout has passed

1278

self.disable()

1279

else:

1280

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

1281

+ datetime.timedelta(milliseconds =

1282

time_to_die))

1283

self.disable_initiator_tag = (gobject.timeout_add

1284

(time_to_die, self.disable))

1285

1286

# ExtendedTimeout - property

1287

@dbus_service_property(_interface, signature="t",

1288

access="readwrite")

1289

def ExtendedTimeout_dbus_property(self, value=None):

1290

if value is None: # get

1291

return dbus.UInt64(self.extended_timeout_milliseconds())

1292

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

1293

1294

# Interval - property

1295

@dbus_service_property(_interface, signature="t",

1296

access="readwrite")

1297

def Interval_dbus_property(self, value=None):

1298

if value is None: # get

1299

return dbus.UInt64(self.interval_milliseconds())

1300

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

1301

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

1302

return

1303

# Reschedule checker run

1304

gobject.source_remove(self.checker_initiator_tag)

1305

self.checker_initiator_tag = (gobject.timeout_add

1306

(value, self.start_checker))

1307

self.start_checker() # Start one now, too

1308

1309

# Checker - property

1310

@dbus_service_property(_interface, signature="s",

1311

access="readwrite")

1312

def Checker_dbus_property(self, value=None):

1313

if value is None: # get

1314

return dbus.String(self.checker_command)

1315

self.checker_command = value

1316

1317

# CheckerRunning - property

1318

@dbus_service_property(_interface, signature="b",

1319

access="readwrite")

1320

def CheckerRunning_dbus_property(self, value=None):

1321

if value is None: # get

1322

return dbus.Boolean(self.checker is not None)

1323

if value:

1324

self.start_checker()

1325

else:

1326

self.stop_checker()

1327

1328

# ObjectPath - property

1329

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

1330

def ObjectPath_dbus_property(self):

1331

return self.dbus_object_path # is already a dbus.ObjectPath

1332

1333

# Secret = property

1334

@dbus_service_property(_interface, signature="ay",

1335

access="write", byte_arrays=True)

1336

def Secret_dbus_property(self, value):

1337

self.secret = str(value)

1338

1339

del _interface

1340

1341

1342

class ProxyClient(object):

1343

def __init__(self, child_pipe, fpr, address):

1344

self._pipe = child_pipe

1345

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

1346

if not self._pipe.recv():

1347

raise KeyError()

1348

1349

def __getattribute__(self, name):

1350

if(name == '_pipe'):

1351

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

1352

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

1353

data = self._pipe.recv()

1354

if data[0] == 'data':

1355

return data[1]

1356

if data[0] == 'function':

1357

def func(*args, **kwargs):

1358

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

1359

return self._pipe.recv()[1]

1360

return func

1361

1362

def __setattr__(self, name, value):

1363

if(name == '_pipe'):

1364

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

1365

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

1366

1367

class ClientDBusTransitional(ClientDBus):

1368

__metaclass__ = AlternateDBusNamesMetaclass

1369

1370

class ClientHandler(socketserver.BaseRequestHandler, object):

1371

"""A class to handle client connections.

1372

1373

Instantiated once for each connection to handle it.

1374

Note: This will run in its own forked process."""

1375

1376

def handle(self):

1377

with contextlib.closing(self.server.child_pipe) as child_pipe:

1378

logger.info("TCP connection from: %s",

1379

unicode(self.client_address))

1380

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

1381

self.server.child_pipe.fileno())

1382

1383

session = (gnutls.connection

1384

.ClientSession(self.request,

1385

gnutls.connection

1386

.X509Credentials()))

1387

1388

# Note: gnutls.connection.X509Credentials is really a

1389

# generic GnuTLS certificate credentials object so long as

1390

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

1391

# here despite using OpenPGP certificates.

1392

1393

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

1394

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

1395

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

1396

# "+DHE-DSS"))

1397

# Use a fallback default, since this MUST be set.

1398

priority = self.server.gnutls_priority

1399

if priority is None:

1400

priority = "NORMAL"

1401

(gnutls.library.functions

1402

.gnutls_priority_set_direct(session._c_object,

1403

priority, None))

1404

1405

# Start communication using the Mandos protocol

1406

# Get protocol number

1407

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

1408

logger.debug("Protocol version: %r", line)

1409

try:

1410

if int(line.strip().split()[0]) > 1:

1411

raise RuntimeError

1412

except (ValueError, IndexError, RuntimeError) as error:

1413

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

1414

return

1415

1416

# Start GnuTLS connection

1417

try:

1418

session.handshake()

1419

except gnutls.errors.GNUTLSError as error:

1420

logger.warning("Handshake failed: %s", error)

1421

# Do not run session.bye() here: the session is not

1422

# established. Just abandon the request.

1423

return

1424

logger.debug("Handshake succeeded")

1425

1426

approval_required = False

1427

try:

1428

try:

1429

fpr = self.fingerprint(self.peer_certificate

1430

(session))

1431

except (TypeError,

1432

gnutls.errors.GNUTLSError) as error:

1433

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

1434

return

1435

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

1436

if self.server.use_dbus:

1437

# Emit D-Bus signal

1438

client.NewRequest(str(self.client_address))

1439

1440

try:

1441

client = ProxyClient(child_pipe, fpr,

1442

self.client_address)

1443

except KeyError:

1444

return

1445

1446

if client.approval_delay:

1447

delay = client.approval_delay

1448

client.approvals_pending += 1

1449

approval_required = True

1450

1451

while True:

1452

if not client.enabled:

1453

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

1454

client.name)

1455

if self.server.use_dbus:

1456

# Emit D-Bus signal

1457

client.Rejected("Disabled")

1458

return

1459

1460

if client._approved or not client.approval_delay:

1461

#We are approved or approval is disabled

1462

break

1463

elif client._approved is None:

1464

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

1465

client.name)

1466

if self.server.use_dbus:

1467

# Emit D-Bus signal

1468

client.NeedApproval(

1469

client.approval_delay_milliseconds(),

1470

client.approved_by_default)

1471

else:

1472

logger.warning("Client %s was not approved",

1473

client.name)

1474

if self.server.use_dbus:

1475

# Emit D-Bus signal

1476

client.Rejected("Denied")

1477

return

1478

1479

#wait until timeout or approved

1480

time = datetime.datetime.now()

1481

client.changedstate.acquire()

1482

(client.changedstate.wait

1483

(float(client._timedelta_to_milliseconds(delay)

1484

/ 1000)))

1485

client.changedstate.release()

1486

time2 = datetime.datetime.now()

1487

if (time2 - time) >= delay:

1488

if not client.approved_by_default:

1489

logger.warning("Client %s timed out while"

1490

" waiting for approval",

1491

client.name)

1492

if self.server.use_dbus:

1493

# Emit D-Bus signal

1494

client.Rejected("Approval timed out")

1495

return

1496

else:

1497

break

1498

else:

1499

delay -= time2 - time

1500

1501

sent_size = 0

1502

while sent_size < len(client.secret):

1503

try:

1504

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

1505

except gnutls.errors.GNUTLSError as error:

1506

logger.warning("gnutls send failed")

1507

return

1508

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

1509

sent, len(client.secret)

1510

- (sent_size + sent))

1511

sent_size += sent

1512

1513

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

1514

# bump the timeout using extended_timeout

1515

client.checked_ok(client.extended_timeout)

1516

if self.server.use_dbus:

1517

# Emit D-Bus signal

1518

client.GotSecret()

1519

1520

finally:

1521

if approval_required:

1522

client.approvals_pending -= 1

1523

try:

1524

session.bye()

1525

except gnutls.errors.GNUTLSError as error:

1526

logger.warning("GnuTLS bye failed")

1527

1528

@staticmethod

1529

def peer_certificate(session):

1530

"Return the peer's OpenPGP certificate as a bytestring"

1531

# If not an OpenPGP certificate...

1532

if (gnutls.library.functions

1533

.gnutls_certificate_type_get(session._c_object)

1534

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1535

# ...do the normal thing

1536

return session.peer_certificate

1537

list_size = ctypes.c_uint(1)

1538

cert_list = (gnutls.library.functions

1539

.gnutls_certificate_get_peers

1540

(session._c_object, ctypes.byref(list_size)))

1541

if not bool(cert_list) and list_size.value != 0:

1542

raise gnutls.errors.GNUTLSError("error getting peer"

1543

" certificate")

1544

if list_size.value == 0:

1545

return None

1546

cert = cert_list[0]

1547

return ctypes.string_at(cert.data, cert.size)

1548

1549

@staticmethod

1550

def fingerprint(openpgp):

1551

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

1552

# New GnuTLS "datum" with the OpenPGP public key

1553

datum = (gnutls.library.types

1554

.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),

1555

ctypes.POINTER

1556

(ctypes.c_ubyte)),

1557

ctypes.c_uint(len(openpgp))))

1558

# New empty GnuTLS certificate

1559

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1560

(gnutls.library.functions

1561

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

1562

# Import the OpenPGP public key into the certificate

1563

(gnutls.library.functions

1564

.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),

1565

gnutls.library.constants

1566

.GNUTLS_OPENPGP_FMT_RAW))

1567

# Verify the self signature in the key

1568

crtverify = ctypes.c_uint()

1569

(gnutls.library.functions

1570

.gnutls_openpgp_crt_verify_self(crt, 0,

1571

ctypes.byref(crtverify)))

1572

if crtverify.value != 0:

1573

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1574

raise (gnutls.errors.CertificateSecurityError

1575

("Verify failed"))

1576

# New buffer for the fingerprint

1577

buf = ctypes.create_string_buffer(20)

1578

buf_len = ctypes.c_size_t()

1579

# Get the fingerprint from the certificate into the buffer

1580

(gnutls.library.functions

1581

.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),

1582

ctypes.byref(buf_len)))

1583

# Deinit the certificate

1584

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1585

# Convert the buffer to a Python bytestring

1586

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

1587

# Convert the bytestring to hexadecimal notation

1588

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

1589

return hex_fpr

1590

1591

1592

class MultiprocessingMixIn(object):

1593

"""Like socketserver.ThreadingMixIn, but with multiprocessing"""

1594

def sub_process_main(self, request, address):

1595

try:

1596

self.finish_request(request, address)

1597

except:

1598

self.handle_error(request, address)

1599

self.close_request(request)

1600

1601

def process_request(self, request, address):

1602

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

1603

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

1604

args = (request,

1605

address))

1606

proc.start()

1607

return proc

1608

1609

1610

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1611

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

1612

def process_request(self, request, client_address):

1613

"""Overrides and wraps the original process_request().

1614

1615

This function creates a new pipe in self.pipe

1616

"""

1617

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1618

1619

proc = MultiprocessingMixIn.process_request(self, request,

1620

client_address)

1621

self.child_pipe.close()

1622

self.add_pipe(parent_pipe, proc)

1623

1624

def add_pipe(self, parent_pipe, proc):

1625

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

1626

raise NotImplementedError

1627

1628

1629

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1630

socketserver.TCPServer, object):

1631

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

1632

1633

Attributes:

1634

enabled: Boolean; whether this server is activated yet

1635

interface: None or a network interface name (string)

1636

use_ipv6: Boolean; to use IPv6 or not

1637

"""

1638

def __init__(self, server_address, RequestHandlerClass,

1639

interface=None, use_ipv6=True):

1640

self.interface = interface

1641

if use_ipv6:

1642

self.address_family = socket.AF_INET6

1643

socketserver.TCPServer.__init__(self, server_address,

1644

RequestHandlerClass)

1645

def server_bind(self):

1646

"""This overrides the normal server_bind() function

1647

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

1648

bind to an address or port if they were not specified."""

1649

if self.interface is not None:

1650

if SO_BINDTODEVICE is None:

1651

logger.error("SO_BINDTODEVICE does not exist;"

1652

" cannot bind to interface %s",

1653

self.interface)

1654

else:

1655

try:

1656

self.socket.setsockopt(socket.SOL_SOCKET,

1657

SO_BINDTODEVICE,

1658

str(self.interface

1659

+ '\0'))

1660

except socket.error as error:

1661

if error[0] == errno.EPERM:

1662

logger.error("No permission to"

1663

" bind to interface %s",

1664

self.interface)

1665

elif error[0] == errno.ENOPROTOOPT:

1666

logger.error("SO_BINDTODEVICE not available;"

1667

" cannot bind to interface %s",

1668

self.interface)

1669

else:

1670

raise

1671

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

1672

if self.server_address[0] or self.server_address[1]:

1673

if not self.server_address[0]:

1674

if self.address_family == socket.AF_INET6:

1675

any_address = "::" # in6addr_any

1676

else:

1677

any_address = socket.INADDR_ANY

1678

self.server_address = (any_address,

1679

self.server_address[1])

1680

elif not self.server_address[1]:

1681

self.server_address = (self.server_address[0],

1682

0)

1683

# if self.interface:

1684

# self.server_address = (self.server_address[0],

1685

# 0, # port

1686

# 0, # flowinfo

1687

# if_nametoindex

1688

# (self.interface))

1689

return socketserver.TCPServer.server_bind(self)

1690

1691

1692

class MandosServer(IPv6_TCPServer):

1693

"""Mandos server.

1694

1695

Attributes:

1696

clients: set of Client objects

1697

gnutls_priority GnuTLS priority string

1698

use_dbus: Boolean; to emit D-Bus signals or not

1699

1700

Assumes a gobject.MainLoop event loop.

1701

"""

1702

def __init__(self, server_address, RequestHandlerClass,

1703

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

1704

gnutls_priority=None, use_dbus=True):

1705

self.enabled = False

1706

self.clients = clients

1707

if self.clients is None:

1708

self.clients = {}

1709

self.use_dbus = use_dbus

1710

self.gnutls_priority = gnutls_priority

1711

IPv6_TCPServer.__init__(self, server_address,

1712

RequestHandlerClass,

1713

interface = interface,

1714

use_ipv6 = use_ipv6)

1715

def server_activate(self):

1716

if self.enabled:

1717

return socketserver.TCPServer.server_activate(self)

1718

1719

def enable(self):

1720

self.enabled = True

1721

1722

def add_pipe(self, parent_pipe, proc):

1723

# Call "handle_ipc" for both data and EOF events

1724

gobject.io_add_watch(parent_pipe.fileno(),

1725

gobject.IO_IN | gobject.IO_HUP,

1726

functools.partial(self.handle_ipc,

1727

parent_pipe =

1728

parent_pipe,

1729

proc = proc))

1730

1731

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

1732

proc = None, client_object=None):

1733

condition_names = {

1734

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

1735

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

1736

# blocking).

1737

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

1738

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

1739

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

1740

# broken, usually for pipes and

1741

# sockets).

1742

}

1743

conditions_string = ' | '.join(name

1744

for cond, name in

1745

condition_names.iteritems()

1746

if cond & condition)

1747

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

1748

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

1749

# Wait for other process to exit

1750

proc.join()

1751

return False

1752

1753

# Read a request from the child

1754

request = parent_pipe.recv()

1755

command = request[0]

1756

1757

if command == 'init':

1758

fpr = request[1]

1759

address = request[2]

1760

1761

for c in self.clients.itervalues():

1762

if c.fingerprint == fpr:

1763

client = c

1764

break

1765

else:

1766

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

1767

"dress: %s", fpr, address)

1768

if self.use_dbus:

1769

# Emit D-Bus signal

1770

mandos_dbus_service.ClientNotFound(fpr,

1771

address[0])

1772

parent_pipe.send(False)

1773

return False

1774

1775

gobject.io_add_watch(parent_pipe.fileno(),

1776

gobject.IO_IN | gobject.IO_HUP,

1777

functools.partial(self.handle_ipc,

1778

parent_pipe =

1779

parent_pipe,

1780

proc = proc,

1781

client_object =

1782

client))

1783

parent_pipe.send(True)

1784

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

1785

# same fileno

1786

return False

1787

if command == 'funcall':

1788

funcname = request[1]

1789

args = request[2]

1790

kwargs = request[3]

1791

1792

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

1793

funcname)(*args,

1794

**kwargs)))

1795

1796

if command == 'getattr':

1797

attrname = request[1]

1798

if callable(client_object.__getattribute__(attrname)):

1799

parent_pipe.send(('function',))

1800

else:

1801

parent_pipe.send(('data', client_object

1802

.__getattribute__(attrname)))

1803

1804

if command == 'setattr':

1805

attrname = request[1]

1806

value = request[2]

1807

setattr(client_object, attrname, value)

1808

1809

return True

1810

1811

1812

def string_to_delta(interval):

1813

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

1814

1815

>>> string_to_delta('7d')

1816

datetime.timedelta(7)

1817

>>> string_to_delta('60s')

1818

datetime.timedelta(0, 60)

1819

>>> string_to_delta('60m')

1820

datetime.timedelta(0, 3600)

1821

>>> string_to_delta('24h')

1822

datetime.timedelta(1)

1823

>>> string_to_delta('1w')

1824

datetime.timedelta(7)

1825

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

1826

datetime.timedelta(0, 330)

1827

"""

1828

timevalue = datetime.timedelta(0)

1829

for s in interval.split():

1830

try:

1831

suffix = unicode(s[-1])

1832

value = int(s[:-1])

1833

if suffix == "d":

1834

delta = datetime.timedelta(value)

1835

elif suffix == "s":

1836

delta = datetime.timedelta(0, value)

1837

elif suffix == "m":

1838

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

1839

elif suffix == "h":

1840

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

1841

elif suffix == "w":

1842

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

1843

else:

1844

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

1845

except (ValueError, IndexError) as e:

1846

raise ValueError(*(e.args))

1847

timevalue += delta

1848

return timevalue

1849

1850

1851

def if_nametoindex(interface):

1852

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

1853

1854

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

1855

global if_nametoindex

1856

try:

1857

if_nametoindex = (ctypes.cdll.LoadLibrary

1858

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

1859

.if_nametoindex)

1860

except (OSError, AttributeError):

1861

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

1862

def if_nametoindex(interface):

1863

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

1864

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

1865

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

1866

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1867

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

1868

interface))

1869

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

1870

ifreq[16:20])[0]

1871

return interface_index

1872

return if_nametoindex(interface)

1873

1874

1875

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

1876

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

1877

1878

This should really exist as os.daemon, but it doesn't (yet)."""

1879

if os.fork():

1880

sys.exit()

1881

os.setsid()

1882

if not nochdir:

1883

os.chdir("/")

1884

if os.fork():

1885

sys.exit()

1886

if not noclose:

1887

# Close all standard open file descriptors

1888

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

1889

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

1890

raise OSError(errno.ENODEV,

1891

"%s not a character device"

1892

% os.path.devnull)

1893

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

1894

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

1895

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

1896

if null > 2:

1897

os.close(null)

1898

1899

1900

def main():

1901

1902

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

1903

# Parsing of options, both command line and config file

1904

1905

parser = argparse.ArgumentParser()

1906

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

1907

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

1908

help="show version number and exit")

1909

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

1910

help="Bind to interface IF")

1911

parser.add_argument("-a", "--address",

1912

help="Address to listen for requests on")

1913

parser.add_argument("-p", "--port", type=int,

1914

help="Port number to receive requests on")

1915

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

1916

help="Run self-test")

1917

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

1918

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

1919

" to terminal")

1920

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

1921

help="Debug level for stdout output")

1922

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

1923

" priority string (see GnuTLS documentation)")

1924

parser.add_argument("--servicename",

1925

metavar="NAME", help="Zeroconf service name")

1926

parser.add_argument("--configdir",

1927

default="/etc/mandos", metavar="DIR",

1928

help="Directory to search for configuration"

1929

" files")

1930

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

1931

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

1932

" system bus interface")

1933

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

1934

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

1935

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

1936

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

1937

default=True)

1938

1939

options = parser.parse_args()

1940

1941

if options.check:

1942

import doctest

1943

doctest.testmod()

1944

sys.exit()

1945

1946

# Default values for config file for server-global settings

1947

server_defaults = { "interface": "",

1948

"address": "",

1949

"port": "",

1950

"debug": "False",

1951

"priority":

1952

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

1953

"servicename": "Mandos",

1954

"use_dbus": "True",

1955

"use_ipv6": "True",

1956

"debuglevel": "",

1957

}

1958

1959

# Parse config file for server-global settings

1960

server_config = configparser.SafeConfigParser(server_defaults)

1961

del server_defaults

1962

server_config.read(os.path.join(options.configdir,

1963

"mandos.conf"))

1964

# Convert the SafeConfigParser object to a dict

1965

server_settings = server_config.defaults()

1966

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

1967

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

1968

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

1969

option)

1970

if server_settings["port"]:

1971

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

1972

"port")

1973

del server_config

1974

1975

# Override the settings from the config file with command line

1976

# options, if set.

1977

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

1978

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

1979

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

1980

value = getattr(options, option)

1981

if value is not None:

1982

server_settings[option] = value

1983

del options

1984

# Force all strings to be unicode

1985

for option in server_settings.keys():

1986

if type(server_settings[option]) is str:

1987

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

1988

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

1989

1990

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

1991

1992

# For convenience

1993

debug = server_settings["debug"]

1994

debuglevel = server_settings["debuglevel"]

1995

use_dbus = server_settings["use_dbus"]

1996

use_ipv6 = server_settings["use_ipv6"]

1997

1998

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

1999

syslogger.setFormatter(logging.Formatter

2000

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

2001

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

2002

% server_settings["servicename"]))

2003

2004

# Parse config file with clients

2005

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

2006

"extended_timeout": "15m",

2007

"interval": "2m",

2008

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

2009

"host": "",

2010

"approval_delay": "0s",

2011

"approval_duration": "1s",

2012

}

2013

client_config = configparser.SafeConfigParser(client_defaults)

2014

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

2015

"clients.conf"))

2016

2017

global mandos_dbus_service

2018

mandos_dbus_service = None

2019

2020

tcp_server = MandosServer((server_settings["address"],

2021

server_settings["port"]),

2022

ClientHandler,

2023

interface=(server_settings["interface"]

2024

or None),

2025

use_ipv6=use_ipv6,

2026

gnutls_priority=

2027

server_settings["priority"],

2028

use_dbus=use_dbus)

2029

if not debug:

2030

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

2031

try:

2032

pidfile = open(pidfilename, "w")

2033

except IOError:

2034

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

2035

2036

try:

2037

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

2038

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

2039

except KeyError:

2040

try:

2041

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

2042

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

2043

except KeyError:

2044

try:

2045

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

2046

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

2047

except KeyError:

2048

uid = 65534

2049

gid = 65534

2050

try:

2051

os.setgid(gid)

2052

os.setuid(uid)

2053

except OSError as error:

2054

if error[0] != errno.EPERM:

2055

raise error

2056

2057

if not debug and not debuglevel:

2058

logger.setLevel(logging.WARNING)

2059

if debuglevel:

2060

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

2061

logger.setLevel(level)

2062

2063

if debug:

2064

logger.setLevel(logging.DEBUG)

2065

# Enable all possible GnuTLS debugging

2066

2067

# "Use a log level over 10 to enable all debugging options."

2068

# - GnuTLS manual

2069

gnutls.library.functions.gnutls_global_set_log_level(11)

2070

2071

@gnutls.library.types.gnutls_log_func

2072

def debug_gnutls(level, string):

2073

logger.debug("GnuTLS: %s", string[:-1])

2074

2075

(gnutls.library.functions

2076

.gnutls_global_set_log_function(debug_gnutls))

2077

2078

# Redirect stdin so all checkers get /dev/null

2079

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

2080

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

2081

if null > 2:

2082

os.close(null)

2083

else:

2084

# No console logging

2085

logger.removeHandler(console)

2086

2087

# Need to fork before connecting to D-Bus

2088

if not debug:

2089

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

2090

daemon()

2091

2092

global main_loop

2093

# From the Avahi example code

2094

DBusGMainLoop(set_as_default=True )

2095

main_loop = gobject.MainLoop()

2096

bus = dbus.SystemBus()

2097

# End of Avahi example code

2098

if use_dbus:

2099

try:

2100

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

2101

bus, do_not_queue=True)

2102

old_bus_name = (dbus.service.BusName

2103

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

2104

do_not_queue=True))

2105

except dbus.exceptions.NameExistsException as e:

2106

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

2107

use_dbus = False

2108

server_settings["use_dbus"] = False

2109

tcp_server.use_dbus = False

2110

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2111

service = AvahiServiceToSyslog(name =

2112

server_settings["servicename"],

2113

servicetype = "_mandos._tcp",

2114

protocol = protocol, bus = bus)

2115

if server_settings["interface"]:

2116

service.interface = (if_nametoindex

2117

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

2118

2119

global multiprocessing_manager

2120

multiprocessing_manager = multiprocessing.Manager()

2121

2122

client_class = Client

2123

if use_dbus:

2124

client_class = functools.partial(ClientDBusTransitional,

2125

bus = bus)

2126

2127

special_settings = {

2128

# Some settings need to be accessd by special methods;

2129

# booleans need .getboolean(), etc. Here is a list of them:

2130

"approved_by_default":

2131

lambda section:

2132

client_config.getboolean(section, "approved_by_default"),

2133

}

2134

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

2135

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

2136

# with exceptions for any special settings as defined above

2137

client_settings = dict((clientname,

2138

dict((setting,

2139

(value if setting not in special_settings

2140

else special_settings[setting](clientname)))

2141

for setting, value in client_config.items(clientname)))

2142

for clientname in client_config.sections())

2143

2144

old_client_settings = {}

2145

clients_data = []

2146

2147

# Get client data and settings from last running state.

2148

if server_settings["restore"]:

2149

try:

2150

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

2151

clients_data, old_client_settings = pickle.load(stored_state)

2152

os.remove(stored_state_path)

2153

except IOError as e:

2154

logger.warning("Could not load persistant state: {0}".format(e))

2155

if e.errno != errno.ENOENT:

2156

raise

2157

2158

for client in clients_data:

2159

client_name = client["name"]

2160

2161

# Decide which value to use after restoring saved state.

2162

# We have three different values: Old config file,

2163

# new config file, and saved state.

2164

# New config value takes precedence if it differs from old

2165

# config value, otherwise use saved state.

2166

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

2167

try:

2168

# For each value in new config, check if it differs

2169

# from the old config value (Except for the "secret"

2170

# attribute)

2171

if name != "secret" and value != old_client_settings[client_name][name]:

2172

setattr(client, name, value)

2173

except KeyError:

2174

pass

2175

2176

# Clients who has passed its expire date, can still be enabled if its

2177

# last checker was sucessful. Clients who checkers failed before we

2178

# stored it state is asumed to had failed checker during downtime.

2179

if client["enabled"] and client["last_checked_ok"]:

2180

if ((datetime.datetime.utcnow() - client["last_checked_ok"])

2181

> client["interval"]):

2182

if client["last_checker_status"] != 0:

2183

client["enabled"] = False

2184

else:

2185

client["expires"] = datetime.datetime.utcnow() + client["timeout"]

2186

2187

client["changedstate"] = (multiprocessing_manager

2188

.Condition(multiprocessing_manager

2189

.Lock()))

2190

if use_dbus:

2191

new_client = ClientDBusTransitional.__new__(ClientDBusTransitional)

2192

tcp_server.clients[client_name] = new_client

2193

new_client.bus = bus

2194

for name, value in client.iteritems():

2195

setattr(new_client, name, value)

2196

client_object_name = unicode(client_name).translate(

2197

{ord("."): ord("_"),

2198

ord("-"): ord("_")})

2199

new_client.dbus_object_path = (dbus.ObjectPath

2200

("/clients/" + client_object_name))

2201

DBusObjectWithProperties.__init__(new_client,

2202

new_client.bus,

2203

new_client.dbus_object_path)

2204

else:

2205

tcp_server.clients[client_name] = Client.__new__(Client)

2206

for name, value in client.iteritems():

2207

setattr(tcp_server.clients[client_name], name, value)

2208

2209

tcp_server.clients[client_name].decrypt_secret(

2210

client_settings[client_name]["secret"])

2211

2212

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

2213

for clientname in set(old_client_settings) - set(client_settings):

2214

del tcp_server.clients[clientname]

2215

for clientname in set(client_settings) - set(old_client_settings):

2216

tcp_server.clients[clientname] = (client_class(name = clientname,

2217

config =

2218

client_settings

2219

[clientname]))

2220

2221

2222

if not tcp_server.clients:

2223

logger.warning("No clients defined")

2224

2225

if not debug:

2226

try:

2227

with pidfile:

2228

pid = os.getpid()

2229

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

2230

del pidfile

2231

except IOError:

2232

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

2233

pidfilename, pid)

2234

except NameError:

2235

# "pidfile" was never created

2236

pass

2237

del pidfilename

2238

2239

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

2240

2241

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

2242

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

2243

2244

if use_dbus:

2245

class MandosDBusService(dbus.service.Object):

2246

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

2247

def __init__(self):

2248

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

2249

_interface = "se.recompile.Mandos"

2250

2251

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

2252

def ClientAdded(self, objpath):

2253

"D-Bus signal"

2254

pass

2255

2256

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

2257

def ClientNotFound(self, fingerprint, address):

2258

"D-Bus signal"

2259

pass

2260

2261

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

2262

def ClientRemoved(self, objpath, name):

2263

"D-Bus signal"

2264

pass

2265

2266

@dbus.service.method(_interface, out_signature="ao")

2267

def GetAllClients(self):

2268

"D-Bus method"

2269

return dbus.Array(c.dbus_object_path

2270

for c in

2271

tcp_server.clients.itervalues())

2272

2273

@dbus.service.method(_interface,

2274

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

2275

def GetAllClientsWithProperties(self):

2276

"D-Bus method"

2277

return dbus.Dictionary(

2278

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

2279

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

2280

signature="oa{sv}")

2281

2282

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

2283

def RemoveClient(self, object_path):

2284

"D-Bus method"

2285

for c in tcp_server.clients.itervalues():

2286

if c.dbus_object_path == object_path:

2287

del tcp_server.clients[c.name]

2288

c.remove_from_connection()

2289

# Don't signal anything except ClientRemoved

2290

c.disable(quiet=True)

2291

# Emit D-Bus signal

2292

self.ClientRemoved(object_path, c.name)

2293

return

2294

raise KeyError(object_path)

2295

2296

del _interface

2297

2298

class MandosDBusServiceTransitional(MandosDBusService):

2299

__metaclass__ = AlternateDBusNamesMetaclass

2300

mandos_dbus_service = MandosDBusServiceTransitional()

2301

2302

def cleanup():

2303

"Cleanup function; run on exit"

2304

service.cleanup()

2305

2306

multiprocessing.active_children()

2307

if not (tcp_server.clients or client_settings):

2308

return

2309

2310

# Store client before exiting. Secrets are encrypted with key based

2311

# on what config file has. If config file is removed/edited, old

2312

# secret will thus be unrecovable.

2313

clients = []

2314

for client in tcp_server.clients.itervalues():

2315

client.encrypt_secret(client_settings[client.name]["secret"])

2316

2317

client_dict = {}

2318

2319

# A list of attributes that will not be stored when shuting down.

2320

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

2321

for name, typ in inspect.getmembers(dbus.service.Object):

2322

exclude.add(name)

2323

2324

client_dict["encrypted_secret"] = client.encrypted_secret

2325

for attr in client.client_structure:

2326

if attr not in exclude:

2327

client_dict[attr] = getattr(client, attr)

2328

2329

clients.append(client_dict)

2330

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

2331

2332

try:

2333

with os.fdopen(os.open(stored_state_path, os.O_CREAT|os.O_WRONLY|os.O_TRUNC, 0600), "wb") as stored_state:

2334

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

2335

except IOError as e:

2336

logger.warning("Could not save persistant state: {0}".format(e))

2337

if e.errno != errno.ENOENT:

2338

raise

2339

2340

# Delete all clients, and settings from config

2341

while tcp_server.clients:

2342

name, client = tcp_server.clients.popitem()

2343

if use_dbus:

2344

client.remove_from_connection()

2345

# Don't signal anything except ClientRemoved

2346

client.disable(quiet=True)

2347

if use_dbus:

2348

# Emit D-Bus signal

2349

mandos_dbus_service.ClientRemoved(client

2350

.dbus_object_path,

2351

client.name)

2352

client_settings.clear()

2353

2354

atexit.register(cleanup)

2355

2356

for client in tcp_server.clients.itervalues():

2357

if use_dbus:

2358

# Emit D-Bus signal

2359

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2360

# Need to initiate checking of clients

2361

if client.enabled:

2362

client.init_checker()

2363

2364

2365

tcp_server.enable()

2366

tcp_server.server_activate()

2367

2368

# Find out what port we got

2369

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

2370

if use_ipv6:

2371

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

2372

" flowinfo %d, scope_id %d"

2373

% tcp_server.socket.getsockname())

2374

else: # IPv4

2375

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

2376

% tcp_server.socket.getsockname())

2377

2378

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

2379

2380

try:

2381

# From the Avahi example code

2382

try:

2383

service.activate()

2384

except dbus.exceptions.DBusException as error:

2385

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

2386

cleanup()

2387

sys.exit(1)

2388

# End of Avahi example code

2389

2390

gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,

2391

lambda *args, **kwargs:

2392

(tcp_server.handle_request

2393

(*args[2:], **kwargs) or True))

2394

2395

logger.debug("Starting main loop")

2396

main_loop.run()

2397

except AvahiError as error:

2398

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

2399

cleanup()

2400

sys.exit(1)

2401

except KeyboardInterrupt:

2402

if debug:

2403

print("", file=sys.stderr)

2404

logger.debug("Server received KeyboardInterrupt")

2405

logger.debug("Server exiting")

2406

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

2407

cleanup()

2408

2409

2410

if __name__ == '__main__':

2411

main()