/mandos/trunk : revision 520

28

# along with this program. If not, see

29

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

30

#

31

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

31

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

32

#

33

34

from __future__ import (division, absolute_import, print_function,

36

37

import SocketServer as socketserver

38

import socket

39

import optparse

39

import argparse

40

import datetime

41

import errno

42

import gnutls.crypto

62

import functools

63

import cPickle as pickle

64

import multiprocessing

65

import types

66

import hashlib

65

67

66

68

import dbus

67

69

import dbus.service

72

74

import ctypes.util

73

75

import xml.dom.minidom

74

76

import inspect

77

import Crypto.Cipher.AES

75

78

76

79

try:

77

80

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

82

85

SO_BINDTODEVICE = None

83

86

84

87

85

version = "1.2.3"

86

87

#logger = logging.getLogger('mandos')

88

logger = logging.Logger('mandos')

88

version = "1.4.1"

89

90

logger = logging.getLogger()

91

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

92

89

93

syslogger = (logging.handlers.SysLogHandler

90

94

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

91

95

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

95

99

logger.addHandler(syslogger)

96

100

97

101

console = logging.StreamHandler()

98

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

102

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

103

' [%(process)d]:'

99

104

' %(levelname)s:'

100

105

' %(message)s'))

101

106

logger.addHandler(console)

102

107

108

103

109

class AvahiError(Exception):

104

110

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

105

111

self.value = value

151

157

self.group = None # our entry group

152

158

self.server = None

153

159

self.bus = bus

160

self.entry_group_state_changed_match = None

154

161

def rename(self):

155

162

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

156

163

if self.rename_count >= self.max_renames:

158

165

" after %i retries, exiting.",

159

166

self.rename_count)

160

167

raise AvahiServiceError("Too many renames")

161

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

168

self.name = unicode(self.server

169

.GetAlternativeServiceName(self.name))

162

170

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

163

171

self.name)

164

syslogger.setFormatter(logging.Formatter

165

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

166

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

167

% self.name))

168

172

self.remove()

169

173

try:

170

174

self.add()

171

except dbus.exceptions.DBusException, error:

175

except dbus.exceptions.DBusException as error:

172

176

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

173

177

self.cleanup()

174

178

os._exit(1)

175

179

self.rename_count += 1

176

180

def remove(self):

177

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

178

185

if self.group is not None:

179

186

self.group.Reset()

180

187

def add(self):

181

188

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

189

self.remove()

182

190

if self.group is None:

183

191

self.group = dbus.Interface(

184

192

self.bus.get_object(avahi.DBUS_NAME,

185

193

self.server.EntryGroupNew()),

186

194

avahi.DBUS_INTERFACE_ENTRY_GROUP)

187

self.group.connect_to_signal('StateChanged',

188

self

189

.entry_group_state_changed)

195

self.entry_group_state_changed_match = (

196

self.group.connect_to_signal(

197

'StateChanged', self.entry_group_state_changed))

190

198

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

191

199

self.name, self.type)

192

200

self.group.AddService(

215

223

def cleanup(self):

216

224

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

217

225

if self.group is not None:

218

self.group.Free()

226

try:

227

self.group.Free()

228

except (dbus.exceptions.UnknownMethodException,

229

dbus.exceptions.DBusException) as e:

230

pass

219

231

self.group = None

220

def server_state_changed(self, state):

232

self.remove()

233

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

221

234

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

222

235

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

223

if state == avahi.SERVER_COLLISION:

224

logger.error("Zeroconf server name collision")

225

self.remove()

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

226

250

elif state == avahi.SERVER_RUNNING:

227

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)

228

257

def activate(self):

229

258

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

230

259

if self.server is None:

231

260

self.server = dbus.Interface(

232

261

self.bus.get_object(avahi.DBUS_NAME,

233

avahi.DBUS_PATH_SERVER),

262

avahi.DBUS_PATH_SERVER,

263

follow_name_owner_changes=True),

234

264

avahi.DBUS_INTERFACE_SERVER)

235

265

self.server.connect_to_signal("StateChanged",

236

266

self.server_state_changed)

237

267

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

238

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

239

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

240

285

class Client(object):

241

286

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

242

287

254

299

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

255

300

checker_initiator_tag: a gobject event source tag, or None

256

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

257

304

current_checker_command: string; current running checker_command

258

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

259

305

disable_initiator_tag: a gobject event source tag, or None

260

306

enabled: bool()

261

307

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

264

310

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

265

311

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

266

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.

267

316

last_enabled: datetime.datetime(); (UTC)

268

317

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

269

318

D-Bus identifiers

270

319

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

271

320

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

272

321

until this client is disabled

322

extended_timeout: extra long timeout when password has been sent

273

323

runtime_expansions: Allowed attributes for runtime expansion.

324

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

325

disabled, or None

274

326

"""

275

327

276

328

runtime_expansions = ("approval_delay", "approval_duration",

278

330

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

279

331

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

280

332

281

@staticmethod

282

def _timedelta_to_milliseconds(td):

283

"Convert a datetime.timedelta() to milliseconds"

284

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

285

+ (td.seconds * 1000)

286

+ (td.microseconds // 1000))

287

288

333

def timeout_milliseconds(self):

289

334

"Return the 'timeout' attribute in milliseconds"

290

return self._timedelta_to_milliseconds(self.timeout)

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)

291

340

292

341

def interval_milliseconds(self):

293

342

"Return the 'interval' attribute in milliseconds"

294

return self._timedelta_to_milliseconds(self.interval)

295

343

return _timedelta_to_milliseconds(self.interval)

344

296

345

def approval_delay_milliseconds(self):

297

return self._timedelta_to_milliseconds(self.approval_delay)

346

return _timedelta_to_milliseconds(self.approval_delay)

298

347

299

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

348

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

300

349

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

301

350

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

302

351

attribute."""

322

371

% self.name)

323

372

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

324

373

self.created = datetime.datetime.utcnow()

325

self.enabled = False

374

self.enabled = True

326

375

self.last_approval_request = None

327

self.last_enabled = None

376

self.last_enabled = datetime.datetime.utcnow()

328

377

self.last_checked_ok = None

378

self.last_checker_status = None

329

379

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

380

self.extended_timeout = string_to_delta(config

381

["extended_timeout"])

330

382

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

331

self.disable_hook = disable_hook

332

383

self.checker = None

333

384

self.checker_initiator_tag = None

334

385

self.disable_initiator_tag = None

386

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

335

387

self.checker_callback_tag = None

336

388

self.checker_command = config["checker"]

337

389

self.current_checker_command = None

338

self.last_connect = None

339

390

self._approved = None

340

391

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

341

392

True)

344

395

config["approval_delay"])

345

396

self.approval_duration = string_to_delta(

346

397

config["approval_duration"])

347

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

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)

348

409

410

# Send notice to process children that client state has changed

349

411

def send_changedstate(self):

350

self.changedstate.acquire()

351

self.changedstate.notify_all()

352

self.changedstate.release()

353

412

with self.changedstate:

413

self.changedstate.notify_all()

414

354

415

def enable(self):

355

416

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

356

417

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

357

418

# Already enabled

358

419

return

359

420

self.send_changedstate()

421

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

422

self.enabled = True

360

423

self.last_enabled = datetime.datetime.utcnow()

361

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

362

# and every interval from then on.

363

self.checker_initiator_tag = (gobject.timeout_add

364

(self.interval_milliseconds(),

365

self.start_checker))

366

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

367

self.disable_initiator_tag = (gobject.timeout_add

368

(self.timeout_milliseconds(),

369

self.disable))

370

self.enabled = True

371

# Also start a new checker *right now*.

372

self.start_checker()

424

self.init_checker()

373

425

374

426

def disable(self, quiet=True):

375

427

"""Disable this client."""

382

434

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

383

435

gobject.source_remove(self.disable_initiator_tag)

384

436

self.disable_initiator_tag = None

437

self.expires = None

385

438

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

386

439

gobject.source_remove(self.checker_initiator_tag)

387

440

self.checker_initiator_tag = None

388

441

self.stop_checker()

389

if self.disable_hook:

390

self.disable_hook(self)

391

442

self.enabled = False

392

443

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

393

444

return False

394

445

395

446

def __del__(self):

396

self.disable_hook = None

397

447

self.disable()

398

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

399

463

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

400

464

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

401

465

self.checker_callback_tag = None

402

466

self.checker = None

403

467

if os.WIFEXITED(condition):

404

exitstatus = os.WEXITSTATUS(condition)

405

if exitstatus == 0:

468

self.last_checker_status = os.WEXITSTATUS(condition)

469

if self.last_checker_status == 0:

406

470

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

407

471

vars(self))

408

472

self.checked_ok()

410

474

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

411

475

vars(self))

412

476

else:

477

self.last_checker_status = -1

413

478

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

414

479

vars(self))

415

480

416

def checked_ok(self):

481

def checked_ok(self, timeout=None):

417

482

"""Bump up the timeout for this client.

418

483

419

484

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

420

485

alive and well.

421

486

"""

487

if timeout is None:

488

timeout = self.timeout

422

489

self.last_checked_ok = datetime.datetime.utcnow()

423

gobject.source_remove(self.disable_initiator_tag)

424

self.disable_initiator_tag = (gobject.timeout_add

425

(self.timeout_milliseconds(),

426

self.disable))

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

427

497

428

498

def need_approval(self):

429

499

self.last_approval_request = datetime.datetime.utcnow()

445

515

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

446

516

try:

447

517

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

448

except (AttributeError, OSError), error:

518

except (AttributeError, OSError) as error:

449

519

if (isinstance(error, OSError)

450

520

and error.errno != errno.ECHILD):

451

521

raise error

469

539

'replace')))

470

540

for attr in

471

541

self.runtime_expansions)

472

542

473

543

try:

474

544

command = self.checker_command % escaped_attrs

475

except TypeError, error:

545

except TypeError as error:

476

546

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

477

547

' %s', self.checker_command, error)

478

548

return True # Try again later

497

567

if pid:

498

568

gobject.source_remove(self.checker_callback_tag)

499

569

self.checker_callback(pid, status, command)

500

except OSError, error:

570

except OSError as error:

501

571

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

502

572

error)

503

573

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

516

586

#time.sleep(0.5)

517

587

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

518

588

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

519

except OSError, error:

589

except OSError as error:

520

590

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

521

591

raise

522

592

self.checker = None

523

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

524

641

def dbus_service_property(dbus_interface, signature="v",

525

642

access="readwrite", byte_arrays=False):

526

643

"""Decorators for marking methods of a DBusObjectWithProperties to

572

689

573

690

class DBusObjectWithProperties(dbus.service.Object):

574

691

"""A D-Bus object with properties.

575

692

576

693

Classes inheriting from this can use the dbus_service_property

577

694

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

578

695

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

585

702

def _get_all_dbus_properties(self):

586

703

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

587

704

"""

588

return ((prop._dbus_name, prop)

705

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

706

for cls in self.__class__.__mro__

589

707

for name, prop in

590

inspect.getmembers(self, self._is_dbus_property))

708

inspect.getmembers(cls, self._is_dbus_property))

591

709

592

710

def _get_dbus_property(self, interface_name, property_name):

593

711

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

594

712

property with the specified name and interface.

595

713

"""

596

for name in (property_name,

597

property_name + "_dbus_property"):

598

prop = getattr(self, name, None)

599

if (prop is None

600

or not self._is_dbus_property(prop)

601

or prop._dbus_name != property_name

602

or (interface_name and prop._dbus_interface

603

and interface_name != prop._dbus_interface)):

604

continue

605

return prop

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

606

721

# No such property

607

722

raise DBusPropertyNotFound(self.dbus_object_path + ":"

608

723

+ interface_name + "."

642

757

def GetAll(self, interface_name):

643

758

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

644

759

standard.

645

760

646

761

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

647

762

"""

648

763

all = {}

704

819

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

705

820

document.unlink()

706

821

except (AttributeError, xml.dom.DOMException,

707

xml.parsers.expat.ExpatError), error:

822

xml.parsers.expat.ExpatError) as error:

708

823

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

709

824

error)

710

825

return xmlstring

711

826

712

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

713

932

class ClientDBus(Client, DBusObjectWithProperties):

714

933

"""A Client class using D-Bus

715

934

724

943

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

725

944

726

945

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

946

self.bus = bus

947

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

948

727

949

self._approvals_pending = 0

728

self.bus = bus

729

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

730

950

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

731

951

# the D-Bus

732

952

client_object_name = unicode(self.name).translate(

737

957

DBusObjectWithProperties.__init__(self, self.bus,

738

958

self.dbus_object_path)

739

959

740

def _get_approvals_pending(self):

741

return self._approvals_pending

742

def _set_approvals_pending(self, value):

743

old_value = self._approvals_pending

744

self._approvals_pending = value

745

bval = bool(value)

746

if (hasattr(self, "dbus_object_path")

747

and bval is not bool(old_value)):

748

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

749

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

750

dbus_bool)

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.

751

965

752

approvals_pending = property(_get_approvals_pending,

753

_set_approvals_pending)

754

del _get_approvals_pending, _set_approvals_pending

755

756

@staticmethod

757

def _datetime_to_dbus(dt, variant_level=0):

758

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

759

return dbus.String(dt.isoformat(),

760

variant_level=variant_level)

761

762

def enable(self):

763

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

764

r = Client.enable(self)

765

if oldstate != self.enabled:

766

# Emit D-Bus signals

767

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

768

dbus.Boolean(True, variant_level=1))

769

self.PropertyChanged(

770

dbus.String("LastEnabled"),

771

self._datetime_to_dbus(self.last_enabled,

772

variant_level=1))

773

return r

774

775

def disable(self, quiet = False):

776

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

777

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

778

if not quiet and oldstate != self.enabled:

779

# Emit D-Bus signal

780

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

781

dbus.Boolean(False, variant_level=1))

782

return r

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

783

1026

784

1027

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

785

1028

try:

794

1037

*args, **kwargs):

795

1038

self.checker_callback_tag = None

796

1039

self.checker = None

797

# Emit D-Bus signal

798

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

799

dbus.Boolean(False, variant_level=1))

800

1040

if os.WIFEXITED(condition):

801

1041

exitstatus = os.WEXITSTATUS(condition)

802

1042

# Emit D-Bus signal

812

1052

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

813

1053

*args, **kwargs)

814

1054

815

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

816

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

817

# Emit D-Bus signal

818

self.PropertyChanged(

819

dbus.String("LastCheckedOK"),

820

(self._datetime_to_dbus(self.last_checked_ok,

821

variant_level=1)))

822

return r

823

824

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

825

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

826

# Emit D-Bus signal

827

self.PropertyChanged(

828

dbus.String("LastApprovalRequest"),

829

(self._datetime_to_dbus(self.last_approval_request,

830

variant_level=1)))

831

return r

832

833

1055

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

834

1056

old_checker = self.checker

835

1057

if self.checker is not None:

842

1064

and old_checker_pid != self.checker.pid):

843

1065

# Emit D-Bus signal

844

1066

self.CheckerStarted(self.current_checker_command)

845

self.PropertyChanged(

846

dbus.String("CheckerRunning"),

847

dbus.Boolean(True, variant_level=1))

848

1067

return r

849

1068

850

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

851

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

852

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

853

if (old_checker is not None

854

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

855

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

856

dbus.Boolean(False, variant_level=1))

857

return r

858

859

1069

def _reset_approved(self):

860

1070

self._approved = None

861

1071

return False

863

1073

def approve(self, value=True):

864

1074

self.send_changedstate()

865

1075

self._approved = value

866

gobject.timeout_add(self._timedelta_to_milliseconds

1076

gobject.timeout_add(_timedelta_to_milliseconds

867

1077

(self.approval_duration),

868

1078

self._reset_approved)

869

1079

870

1080

871

1081

## D-Bus methods, signals & properties

872

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

1082

_interface = "se.recompile.Mandos.Client"

873

1083

874

1084

## Signals

875

1085

922

1132

# CheckedOK - method

923

1133

@dbus.service.method(_interface)

924

1134

def CheckedOK(self):

925

return self.checked_ok()

1135

self.checked_ok()

926

1136

927

1137

# Enable - method

928

1138

@dbus.service.method(_interface)

961

1171

if value is None: # get

962

1172

return dbus.Boolean(self.approved_by_default)

963

1173

self.approved_by_default = bool(value)

964

# Emit D-Bus signal

965

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

966

dbus.Boolean(value, variant_level=1))

967

1174

968

1175

# ApprovalDelay - property

969

1176

@dbus_service_property(_interface, signature="t",

972

1179

if value is None: # get

973

1180

return dbus.UInt64(self.approval_delay_milliseconds())

974

1181

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

975

# Emit D-Bus signal

976

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

977

dbus.UInt64(value, variant_level=1))

978

1182

979

1183

# ApprovalDuration - property

980

1184

@dbus_service_property(_interface, signature="t",

981

1185

access="readwrite")

982

1186

def ApprovalDuration_dbus_property(self, value=None):

983

1187

if value is None: # get

984

return dbus.UInt64(self._timedelta_to_milliseconds(

1188

return dbus.UInt64(_timedelta_to_milliseconds(

985

1189

self.approval_duration))

986

1190

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

987

# Emit D-Bus signal

988

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

989

dbus.UInt64(value, variant_level=1))

990

1191

991

1192

# Name - property

992

1193

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

1005

1206

if value is None: # get

1006

1207

return dbus.String(self.host)

1007

1208

self.host = value

1008

# Emit D-Bus signal

1009

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

1010

dbus.String(value, variant_level=1))

1011

1209

1012

1210

# Created - property

1013

1211

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

1014

1212

def Created_dbus_property(self):

1015

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

1213

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

1016

1214

1017

1215

# LastEnabled - property

1018

1216

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

1019

1217

def LastEnabled_dbus_property(self):

1020

if self.last_enabled is None:

1021

return dbus.String("")

1022

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

1218

return datetime_to_dbus(self.last_enabled)

1023

1219

1024

1220

# Enabled - property

1025

1221

@dbus_service_property(_interface, signature="b",

1039

1235

if value is not None:

1040

1236

self.checked_ok()

1041

1237

return

1042

if self.last_checked_ok is None:

1043

return dbus.String("")

1044

return dbus.String(self._datetime_to_dbus(self

1045

.last_checked_ok))

1238

return datetime_to_dbus(self.last_checked_ok)

1239

1240

# Expires - property

1241

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

1242

def Expires_dbus_property(self):

1243

return datetime_to_dbus(self.expires)

1046

1244

1047

1245

# LastApprovalRequest - property

1048

1246

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

1049

1247

def LastApprovalRequest_dbus_property(self):

1050

if self.last_approval_request is None:

1051

return dbus.String("")

1052

return dbus.String(self.

1053

_datetime_to_dbus(self

1054

.last_approval_request))

1248

return datetime_to_dbus(self.last_approval_request)

1055

1249

1056

1250

# Timeout - property

1057

1251

@dbus_service_property(_interface, signature="t",

1060

1254

if value is None: # get

1061

1255

return dbus.UInt64(self.timeout_milliseconds())

1062

1256

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

1063

# Emit D-Bus signal

1064

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

1065

dbus.UInt64(value, variant_level=1))

1066

1257

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

1067

1258

return

1068

1259

# Reschedule timeout

1069

1260

gobject.source_remove(self.disable_initiator_tag)

1070

1261

self.disable_initiator_tag = None

1071

time_to_die = (self.

1072

_timedelta_to_milliseconds((self

1073

.last_checked_ok

1074

+ self.timeout)

1075

- datetime.datetime

1076

.utcnow()))

1262

self.expires = None

1263

time_to_die = _timedelta_to_milliseconds((self

1264

.last_checked_ok

1265

+ self.timeout)

1266

- datetime.datetime

1267

.utcnow())

1077

1268

if time_to_die <= 0:

1078

1269

# The timeout has passed

1079

1270

self.disable()

1080

1271

else:

1272

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

1273

+ datetime.timedelta(milliseconds =

1274

time_to_die))

1081

1275

self.disable_initiator_tag = (gobject.timeout_add

1082

1276

(time_to_die, self.disable))

1083

1277

1278

# ExtendedTimeout - property

1279

@dbus_service_property(_interface, signature="t",

1280

access="readwrite")

1281

def ExtendedTimeout_dbus_property(self, value=None):

1282

if value is None: # get

1283

return dbus.UInt64(self.extended_timeout_milliseconds())

1284

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

1285

1084

1286

# Interval - property

1085

1287

@dbus_service_property(_interface, signature="t",

1086

1288

access="readwrite")

1088

1290

if value is None: # get

1089

1291

return dbus.UInt64(self.interval_milliseconds())

1090

1292

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

1091

# Emit D-Bus signal

1092

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

1093

dbus.UInt64(value, variant_level=1))

1094

1293

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

1095

1294

return

1096

1295

# Reschedule checker run

1098

1297

self.checker_initiator_tag = (gobject.timeout_add

1099

1298

(value, self.start_checker))

1100

1299

self.start_checker() # Start one now, too

1101

1300

1102

1301

# Checker - property

1103

1302

@dbus_service_property(_interface, signature="s",

1104

1303

access="readwrite")

1106

1305

if value is None: # get

1107

1306

return dbus.String(self.checker_command)

1108

1307

self.checker_command = value

1109

# Emit D-Bus signal

1110

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

1111

dbus.String(self.checker_command,

1112

variant_level=1))

1113

1308

1114

1309

# CheckerRunning - property

1115

1310

@dbus_service_property(_interface, signature="b",

1142

1337

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

1143

1338

if not self._pipe.recv():

1144

1339

raise KeyError()

1145

1340

1146

1341

def __getattribute__(self, name):

1147

1342

if(name == '_pipe'):

1148

1343

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

1155

1350

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

1156

1351

return self._pipe.recv()[1]

1157

1352

return func

1158

1353

1159

1354

def __setattr__(self, name, value):

1160

1355

if(name == '_pipe'):

1161

1356

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

1162

1357

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

1163

1358

1359

class ClientDBusTransitional(ClientDBus):

1360

__metaclass__ = AlternateDBusNamesMetaclass

1164

1361

1165

1362

class ClientHandler(socketserver.BaseRequestHandler, object):

1166

1363

"""A class to handle client connections.

1174

1371

unicode(self.client_address))

1175

1372

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

1176

1373

self.server.child_pipe.fileno())

1177

1374

1178

1375

session = (gnutls.connection

1179

1376

.ClientSession(self.request,

1180

1377

gnutls.connection

1181

1378

.X509Credentials()))

1182

1379

1183

1380

# Note: gnutls.connection.X509Credentials is really a

1184

1381

# generic GnuTLS certificate credentials object so long as

1185

1382

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

1186

1383

# here despite using OpenPGP certificates.

1187

1384

1188

1385

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

1189

1386

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

1190

1387

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

1196

1393

(gnutls.library.functions

1197

1394

.gnutls_priority_set_direct(session._c_object,

1198

1395

priority, None))

1199

1396

1200

1397

# Start communication using the Mandos protocol

1201

1398

# Get protocol number

1202

1399

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

1204

1401

try:

1205

1402

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

1206

1403

raise RuntimeError

1207

except (ValueError, IndexError, RuntimeError), error:

1404

except (ValueError, IndexError, RuntimeError) as error:

1208

1405

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

1209

1406

return

1210

1407

1211

1408

# Start GnuTLS connection

1212

1409

try:

1213

1410

session.handshake()

1214

except gnutls.errors.GNUTLSError, error:

1411

except gnutls.errors.GNUTLSError as error:

1215

1412

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

1216

1413

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

1217

1414

# established. Just abandon the request.

1218

1415

return

1219

1416

logger.debug("Handshake succeeded")

1220

1417

1221

1418

approval_required = False

1222

1419

try:

1223

1420

try:

1224

1421

fpr = self.fingerprint(self.peer_certificate

1225

1422

(session))

1226

except (TypeError, gnutls.errors.GNUTLSError), error:

1423

except (TypeError,

1424

gnutls.errors.GNUTLSError) as error:

1227

1425

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

1228

1426

return

1229

1427

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

1230

1428

1231

1429

try:

1232

1430

client = ProxyClient(child_pipe, fpr,

1233

1431

self.client_address)

1241

1439

1242

1440

while True:

1243

1441

if not client.enabled:

1244

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

1442

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

1245

1443

client.name)

1246

1444

if self.server.use_dbus:

1247

1445

# Emit D-Bus signal

1248

client.Rejected("Disabled")

1446

client.Rejected("Disabled")

1249

1447

return

1250

1448

1251

1449

if client._approved or not client.approval_delay:

1268

1466

return

1269

1467

1270

1468

#wait until timeout or approved

1271

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

1272

1469

time = datetime.datetime.now()

1273

1470

client.changedstate.acquire()

1274

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

1471

(client.changedstate.wait

1472

(float(client._timedelta_to_milliseconds(delay)

1473

/ 1000)))

1275

1474

client.changedstate.release()

1276

1475

time2 = datetime.datetime.now()

1277

1476

if (time2 - time) >= delay:

1292

1491

while sent_size < len(client.secret):

1293

1492

try:

1294

1493

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

1295

except (gnutls.errors.GNUTLSError), error:

1494

except gnutls.errors.GNUTLSError as error:

1296

1495

logger.warning("gnutls send failed")

1297

1496

return

1298

1497

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

1299

1498

sent, len(client.secret)

1300

1499

- (sent_size + sent))

1301

1500

sent_size += sent

1302

1501

1303

1502

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

1304

# bump the timeout as if seen

1305

client.checked_ok()

1503

# bump the timeout using extended_timeout

1504

client.checked_ok(client.extended_timeout)

1306

1505

if self.server.use_dbus:

1307

1506

# Emit D-Bus signal

1308

1507

client.GotSecret()

1312

1511

client.approvals_pending -= 1

1313

1512

try:

1314

1513

session.bye()

1315

except (gnutls.errors.GNUTLSError), error:

1514

except gnutls.errors.GNUTLSError as error:

1316

1515

logger.warning("GnuTLS bye failed")

1317

1516

1318

1517

@staticmethod

1387

1586

except:

1388

1587

self.handle_error(request, address)

1389

1588

self.close_request(request)

1390

1589

1391

1590

def process_request(self, request, address):

1392

1591

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

1393

multiprocessing.Process(target = self.sub_process_main,

1394

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

1592

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

1593

args = (request,

1594

address))

1595

proc.start()

1596

return proc

1597

1395

1598

1396

1599

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1397

1600

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

1401

1604

This function creates a new pipe in self.pipe

1402

1605

"""

1403

1606

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1404

1405

super(MultiprocessingMixInWithPipe,

1406

self).process_request(request, client_address)

1607

1608

proc = MultiprocessingMixIn.process_request(self, request,

1609

client_address)

1407

1610

self.child_pipe.close()

1408

self.add_pipe(parent_pipe)

1409

1410

def add_pipe(self, parent_pipe):

1611

self.add_pipe(parent_pipe, proc)

1612

1613

def add_pipe(self, parent_pipe, proc):

1411

1614

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

1412

1615

raise NotImplementedError

1413

1616

1617

1414

1618

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1415

1619

socketserver.TCPServer, object):

1416

1620

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

1442

1646

SO_BINDTODEVICE,

1443

1647

str(self.interface

1444

1648

+ '\0'))

1445

except socket.error, error:

1649

except socket.error as error:

1446

1650

if error[0] == errno.EPERM:

1447

1651

logger.error("No permission to"

1448

1652

" bind to interface %s",

1490

1694

self.enabled = False

1491

1695

self.clients = clients

1492

1696

if self.clients is None:

1493

self.clients = set()

1697

self.clients = {}

1494

1698

self.use_dbus = use_dbus

1495

1699

self.gnutls_priority = gnutls_priority

1496

1700

IPv6_TCPServer.__init__(self, server_address,

1500

1704

def server_activate(self):

1501

1705

if self.enabled:

1502

1706

return socketserver.TCPServer.server_activate(self)

1707

1503

1708

def enable(self):

1504

1709

self.enabled = True

1505

def add_pipe(self, parent_pipe):

1710

1711

def add_pipe(self, parent_pipe, proc):

1506

1712

# Call "handle_ipc" for both data and EOF events

1507

1713

gobject.io_add_watch(parent_pipe.fileno(),

1508

1714

gobject.IO_IN | gobject.IO_HUP,

1509

1715

functools.partial(self.handle_ipc,

1510

parent_pipe = parent_pipe))

1511

1716

parent_pipe =

1717

parent_pipe,

1718

proc = proc))

1719

1512

1720

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

1513

client_object=None):

1721

proc = None, client_object=None):

1514

1722

condition_names = {

1515

1723

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

1516

1724

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

1525

1733

for cond, name in

1526

1734

condition_names.iteritems()

1527

1735

if cond & condition)

1528

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

1736

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

1529

1737

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

1738

# Wait for other process to exit

1739

proc.join()

1530

1740

return False

1531

1741

1532

1742

# Read a request from the child

1537

1747

fpr = request[1]

1538

1748

address = request[2]

1539

1749

1540

for c in self.clients:

1750

for c in self.clients.itervalues():

1541

1751

if c.fingerprint == fpr:

1542

1752

client = c

1543

1753

break

1544

1754

else:

1545

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

1546

"dress: %s", fpr, address)

1755

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

1756

"dress: %s", fpr, address)

1547

1757

if self.use_dbus:

1548

1758

# Emit D-Bus signal

1549

mandos_dbus_service.ClientNotFound(fpr, address[0])

1759

mandos_dbus_service.ClientNotFound(fpr,

1760

address[0])

1550

1761

parent_pipe.send(False)

1551

1762

return False

1552

1763

1553

1764

gobject.io_add_watch(parent_pipe.fileno(),

1554

1765

gobject.IO_IN | gobject.IO_HUP,

1555

1766

functools.partial(self.handle_ipc,

1556

parent_pipe = parent_pipe,

1557

client_object = client))

1767

parent_pipe =

1768

parent_pipe,

1769

proc = proc,

1770

client_object =

1771

client))

1558

1772

parent_pipe.send(True)

1559

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

1773

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

1774

# same fileno

1560

1775

return False

1561

1776

if command == 'funcall':

1562

1777

funcname = request[1]

1563

1778

args = request[2]

1564

1779

kwargs = request[3]

1565

1780

1566

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

1567

1781

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

1782

funcname)(*args,

1783

**kwargs)))

1784

1568

1785

if command == 'getattr':

1569

1786

attrname = request[1]

1570

1787

if callable(client_object.__getattribute__(attrname)):

1571

1788

parent_pipe.send(('function',))

1572

1789

else:

1573

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

1790

parent_pipe.send(('data', client_object

1791

.__getattribute__(attrname)))

1574

1792

1575

1793

if command == 'setattr':

1576

1794

attrname = request[1]

1577

1795

value = request[2]

1578

1796

setattr(client_object, attrname, value)

1579

1797

1580

1798

return True

1581

1799

1582

1800

1613

1831

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

1614

1832

else:

1615

1833

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

1616

except (ValueError, IndexError), e:

1834

except (ValueError, IndexError) as e:

1617

1835

raise ValueError(*(e.args))

1618

1836

timevalue += delta

1619

1837

return timevalue

1673

1891

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

1674

1892

# Parsing of options, both command line and config file

1675

1893

1676

parser = optparse.OptionParser(version = "%%prog %s" % version)

1677

parser.add_option("-i", "--interface", type="string",

1678

metavar="IF", help="Bind to interface IF")

1679

parser.add_option("-a", "--address", type="string",

1680

help="Address to listen for requests on")

1681

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

1682

help="Port number to receive requests on")

1683

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

1684

help="Run self-test")

1685

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

1686

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

1687

" terminal")

1688

parser.add_option("--debuglevel", type="string", metavar="LEVEL",

1689

help="Debug level for stdout output")

1690

parser.add_option("--priority", type="string", help="GnuTLS"

1691

" priority string (see GnuTLS documentation)")

1692

parser.add_option("--servicename", type="string",

1693

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

1694

parser.add_option("--configdir", type="string",

1695

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

1696

help="Directory to search for configuration"

1697

" files")

1698

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

1699

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

1700

" system bus interface")

1701

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

1702

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

1703

options = parser.parse_args()[0]

1894

parser = argparse.ArgumentParser()

1895

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

1896

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

1897

help="show version number and exit")

1898

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

1899

help="Bind to interface IF")

1900

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

1901

help="Address to listen for requests on")

1902

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

1903

help="Port number to receive requests on")

1904

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

1905

help="Run self-test")

1906

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

1907

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

1908

" to terminal")

1909

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

1910

help="Debug level for stdout output")

1911

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

1912

" priority string (see GnuTLS documentation)")

1913

parser.add_argument("--servicename",

1914

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

1915

parser.add_argument("--configdir",

1916

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

1917

help="Directory to search for configuration"

1918

" files")

1919

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

1920

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

1921

" system bus interface")

1922

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

1923

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

1924

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

1925

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

1926

default=True)

1927

1928

options = parser.parse_args()

1704

1929

1705

1930

if options.check:

1706

1931

import doctest

1740

1965

# options, if set.

1741

1966

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

1742

1967

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

1743

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

1968

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

1744

1969

value = getattr(options, option)

1745

1970

if value is not None:

1746

1971

server_settings[option] = value

1758

1983

debuglevel = server_settings["debuglevel"]

1759

1984

use_dbus = server_settings["use_dbus"]

1760

1985

use_ipv6 = server_settings["use_ipv6"]

1761

1986

1762

1987

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

1763

1988

syslogger.setFormatter(logging.Formatter

1764

1989

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

1766

1991

% server_settings["servicename"]))

1767

1992

1768

1993

# Parse config file with clients

1769

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

1770

"interval": "5m",

1994

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

1995

"extended_timeout": "15m",

1996

"interval": "2m",

1771

1997

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

1772

1998

"host": "",

1773

1999

"approval_delay": "0s",

1813

2039

try:

1814

2040

os.setgid(gid)

1815

2041

os.setuid(uid)

1816

except OSError, error:

2042

except OSError as error:

1817

2043

if error[0] != errno.EPERM:

1818

2044

raise error

1819

2045

1820

2046

if not debug and not debuglevel:

1821

syslogger.setLevel(logging.WARNING)

1822

console.setLevel(logging.WARNING)

2047

logger.setLevel(logging.WARNING)

1823

2048

if debuglevel:

1824

2049

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

1825

syslogger.setLevel(level)

1826

console.setLevel(level)

1827

2050

logger.setLevel(level)

2051

1828

2052

if debug:

2053

logger.setLevel(logging.DEBUG)

1829

2054

# Enable all possible GnuTLS debugging

1830

2055

1831

2056

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

1861

2086

# End of Avahi example code

1862

2087

if use_dbus:

1863

2088

try:

1864

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

2089

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

1865

2090

bus, do_not_queue=True)

1866

except dbus.exceptions.NameExistsException, e:

2091

old_bus_name = (dbus.service.BusName

2092

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

2093

do_not_queue=True))

2094

except dbus.exceptions.NameExistsException as e:

1867

2095

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

1868

2096

use_dbus = False

1869

2097

server_settings["use_dbus"] = False

1870

2098

tcp_server.use_dbus = False

1871

2099

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1872

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

1873

servicetype = "_mandos._tcp",

1874

protocol = protocol, bus = bus)

2100

service = AvahiServiceToSyslog(name =

2101

server_settings["servicename"],

2102

servicetype = "_mandos._tcp",

2103

protocol = protocol, bus = bus)

1875

2104

if server_settings["interface"]:

1876

2105

service.interface = (if_nametoindex

1877

2106

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

1881

2110

1882

2111

client_class = Client

1883

2112

if use_dbus:

1884

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

1885

def client_config_items(config, section):

1886

special_settings = {

1887

"approved_by_default":

1888

lambda: config.getboolean(section,

1889

"approved_by_default"),

1890

}

1891

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

2113

client_class = functools.partial(ClientDBusTransitional,

2114

bus = bus)

2115

2116

special_settings = {

2117

# Some settings need to be accessd by special methods;

2118

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

2119

"approved_by_default":

2120

lambda section:

2121

client_config.getboolean(section, "approved_by_default"),

2122

}

2123

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

2124

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

2125

# with exceptions for any special settings as defined above

2126

client_settings = dict((clientname,

2127

dict((setting,

2128

(value if setting not in special_settings

2129

else special_settings[setting](clientname)))

2130

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

2131

for clientname in client_config.sections())

2132

2133

old_client_settings = {}

2134

clients_data = []

2135

2136

# Get client data and settings from last running state.

2137

if server_settings["restore"]:

2138

try:

2139

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

2140

clients_data, old_client_settings = pickle.load(stored_state)

2141

os.remove(stored_state_path)

2142

except IOError as e:

2143

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

2144

if e.errno != errno.ENOENT:

2145

raise

2146

2147

for client in clients_data:

2148

client_name = client["name"]

2149

2150

# Decide which value to use after restoring saved state.

2151

# We have three different values: Old config file,

2152

# new config file, and saved state.

2153

# New config value takes precedence if it differs from old

2154

# config value, otherwise use saved state.

2155

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

1892

2156

try:

1893

yield (name, special_settings[name]())

2157

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

2158

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

2159

# attribute)

2160

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

2161

setattr(client, name, value)

1894

2162

except KeyError:

1895

yield (name, value)

2163

pass

2164

2165

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

2166

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

2167

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

2168

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

2169

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

2170

> client["interval"]):

2171

if client["last_checker_status"] != 0:

2172

client["enabled"] = False

2173

else:

2174

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

2175

2176

client["changedstate"] = (multiprocessing_manager

2177

.Condition(multiprocessing_manager

2178

.Lock()))

2179

if use_dbus:

2180

new_client = ClientDBusTransitional.__new__(ClientDBusTransitional)

2181

tcp_server.clients[client_name] = new_client

2182

new_client.bus = bus

2183

for name, value in client.iteritems():

2184

setattr(new_client, name, value)

2185

client_object_name = unicode(client_name).translate(

2186

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

2187

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

2188

new_client.dbus_object_path = (dbus.ObjectPath

2189

("/clients/" + client_object_name))

2190

DBusObjectWithProperties.__init__(new_client,

2191

new_client.bus,

2192

new_client.dbus_object_path)

2193

else:

2194

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

2195

for name, value in client.iteritems():

2196

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

2197

2198

tcp_server.clients[client_name].decrypt_secret(

2199

client_settings[client_name]["secret"])

2200

2201

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

2202

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

2203

del tcp_server.clients[clientname]

2204

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

2205

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

2206

config =

2207

client_settings

2208

[clientname]))

1896

2209

1897

tcp_server.clients.update(set(

1898

client_class(name = section,

1899

config= dict(client_config_items(

1900

client_config, section)))

1901

for section in client_config.sections()))

2210

1902

2211

if not tcp_server.clients:

1903

2212

logger.warning("No clients defined")

1904

2213

1917

2226

del pidfilename

1918

2227

1919

2228

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

1920

2229

1921

2230

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

1922

2231

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

1923

2232

1926

2235

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

1927

2236

def __init__(self):

1928

2237

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

1929

_interface = "se.bsnet.fukt.Mandos"

2238

_interface = "se.recompile.Mandos"

1930

2239

1931

2240

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

1932

2241

def ClientAdded(self, objpath):

1947

2256

def GetAllClients(self):

1948

2257

"D-Bus method"

1949

2258

return dbus.Array(c.dbus_object_path

1950

for c in tcp_server.clients)

2259

for c in

2260

tcp_server.clients.itervalues())

1951

2261

1952

2262

@dbus.service.method(_interface,

1953

2263

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

1955

2265

"D-Bus method"

1956

2266

return dbus.Dictionary(

1957

2267

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

1958

for c in tcp_server.clients),

2268

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

1959

2269

signature="oa{sv}")

1960

2270

1961

2271

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

1962

2272

def RemoveClient(self, object_path):

1963

2273

"D-Bus method"

1964

for c in tcp_server.clients:

2274

for c in tcp_server.clients.itervalues():

1965

2275

if c.dbus_object_path == object_path:

1966

tcp_server.clients.remove(c)

2276

del tcp_server.clients[c.name]

1967

2277

c.remove_from_connection()

1968

2278

# Don't signal anything except ClientRemoved

1969

2279

c.disable(quiet=True)

1974

2284

1975

2285

del _interface

1976

2286

1977

mandos_dbus_service = MandosDBusService()

2287

class MandosDBusServiceTransitional(MandosDBusService):

2288

__metaclass__ = AlternateDBusNamesMetaclass

2289

mandos_dbus_service = MandosDBusServiceTransitional()

1978

2290

1979

2291

def cleanup():

1980

2292

"Cleanup function; run on exit"

1981

2293

service.cleanup()

1982

2294

2295

multiprocessing.active_children()

2296

if not (tcp_server.clients or client_settings):

2297

return

2298

2299

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

2300

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

2301

# secret will thus be unrecovable.

2302

clients = []

2303

for client in tcp_server.clients.itervalues():

2304

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

2305

2306

client_dict = {}

2307

2308

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

2309

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

2310

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

2311

exclude.add(name)

2312

2313

client_dict["encrypted_secret"] = client.encrypted_secret

2314

for attr in client.client_structure:

2315

if attr not in exclude:

2316

client_dict[attr] = getattr(client, attr)

2317

2318

clients.append(client_dict)

2319

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

2320

2321

try:

2322

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

2323

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

2324

except IOError as e:

2325

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

2326

if e.errno != errno.ENOENT:

2327

raise

2328

2329

# Delete all clients, and settings from config

1983

2330

while tcp_server.clients:

1984

client = tcp_server.clients.pop()

2331

name, client = tcp_server.clients.popitem()

1985

2332

if use_dbus:

1986

2333

client.remove_from_connection()

1987

client.disable_hook = None

1988

2334

# Don't signal anything except ClientRemoved

1989

2335

client.disable(quiet=True)

1990

2336

if use_dbus:

1991

2337

# Emit D-Bus signal

1992

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2338

mandos_dbus_service.ClientRemoved(client

2339

.dbus_object_path,

1993

2340

client.name)

2341

client_settings.clear()

1994

2342

1995

2343

atexit.register(cleanup)

1996

2344

1997

for client in tcp_server.clients:

2345

for client in tcp_server.clients.itervalues():

1998

2346

if use_dbus:

1999

2347

# Emit D-Bus signal

2000

2348

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2001

client.enable()

2349

# Need to initiate checking of clients

2350

if client.enabled:

2351

client.init_checker()

2352

2002

2353

2003

2354

tcp_server.enable()

2004

2355

tcp_server.server_activate()

2019

2370

# From the Avahi example code

2020

2371

try:

2021

2372

service.activate()

2022

except dbus.exceptions.DBusException, error:

2373

except dbus.exceptions.DBusException as error:

2023

2374

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

2024

2375

cleanup()

2025

2376

sys.exit(1)

2032

2383

2033

2384

logger.debug("Starting main loop")

2034

2385

main_loop.run()

2035

except AvahiError, error:

2386

except AvahiError as error:

2036

2387

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

2037

2388

cleanup()

2038

2389

sys.exit(1)

2044

2395

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

2045

2396

cleanup()

2046

2397

2398

2047

2399

if __name__ == '__main__':

2048

2400

main()