/mandos/trunk : revision 518.1.3

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,

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

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

912

1122

"D-Bus signal"

913

1123

return self.need_approval()

914

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

915

1133

## Methods

916

1134

917

1135

# Approve - method

922

1140

# CheckedOK - method

923

1141

@dbus.service.method(_interface)

924

1142

def CheckedOK(self):

925

return self.checked_ok()

1143

self.checked_ok()

926

1144

927

1145

# Enable - method

928

1146

@dbus.service.method(_interface)

961

1179

if value is None: # get

962

1180

return dbus.Boolean(self.approved_by_default)

963

1181

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

1182

968

1183

# ApprovalDelay - property

969

1184

@dbus_service_property(_interface, signature="t",

972

1187

if value is None: # get

973

1188

return dbus.UInt64(self.approval_delay_milliseconds())

974

1189

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

1190

979

1191

# ApprovalDuration - property

980

1192

@dbus_service_property(_interface, signature="t",

981

1193

access="readwrite")

982

1194

def ApprovalDuration_dbus_property(self, value=None):

983

1195

if value is None: # get

984

return dbus.UInt64(self._timedelta_to_milliseconds(

1196

return dbus.UInt64(_timedelta_to_milliseconds(

985

1197

self.approval_duration))

986

1198

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

1199

991

1200

# Name - property

992

1201

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

1005

1214

if value is None: # get

1006

1215

return dbus.String(self.host)

1007

1216

self.host = value

1008

# Emit D-Bus signal

1009

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

1010

dbus.String(value, variant_level=1))

1011

1217

1012

1218

# Created - property

1013

1219

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

1014

1220

def Created_dbus_property(self):

1015

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

1221

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

1016

1222

1017

1223

# LastEnabled - property

1018

1224

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

1019

1225

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

1226

return datetime_to_dbus(self.last_enabled)

1023

1227

1024

1228

# Enabled - property

1025

1229

@dbus_service_property(_interface, signature="b",

1039

1243

if value is not None:

1040

1244

self.checked_ok()

1041

1245

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

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)

1046

1252

1047

1253

# LastApprovalRequest - property

1048

1254

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

1049

1255

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

1256

return datetime_to_dbus(self.last_approval_request)

1055

1257

1056

1258

# Timeout - property

1057

1259

@dbus_service_property(_interface, signature="t",

1060

1262

if value is None: # get

1061

1263

return dbus.UInt64(self.timeout_milliseconds())

1062

1264

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

1265

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

1067

1266

return

1068

1267

# Reschedule timeout

1069

1268

gobject.source_remove(self.disable_initiator_tag)

1070

1269

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

1270

self.expires = None

1271

time_to_die = _timedelta_to_milliseconds((self

1272

.last_checked_ok

1273

+ self.timeout)

1274

- datetime.datetime

1275

.utcnow())

1077

1276

if time_to_die <= 0:

1078

1277

# The timeout has passed

1079

1278

self.disable()

1080

1279

else:

1280

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

1281

+ datetime.timedelta(milliseconds =

1282

time_to_die))

1081

1283

self.disable_initiator_tag = (gobject.timeout_add

1082

1284

(time_to_die, self.disable))

1083

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

1084

1294

# Interval - property

1085

1295

@dbus_service_property(_interface, signature="t",

1086

1296

access="readwrite")

1088

1298

if value is None: # get

1089

1299

return dbus.UInt64(self.interval_milliseconds())

1090

1300

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

1301

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

1095

1302

return

1096

1303

# Reschedule checker run

1098

1305

self.checker_initiator_tag = (gobject.timeout_add

1099

1306

(value, self.start_checker))

1100

1307

self.start_checker() # Start one now, too

1101

1308

1102

1309

# Checker - property

1103

1310

@dbus_service_property(_interface, signature="s",

1104

1311

access="readwrite")

1106

1313

if value is None: # get

1107

1314

return dbus.String(self.checker_command)

1108

1315

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

1316

1114

1317

# CheckerRunning - property

1115

1318

@dbus_service_property(_interface, signature="b",

1142

1345

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

1143

1346

if not self._pipe.recv():

1144

1347

raise KeyError()

1145

1348

1146

1349

def __getattribute__(self, name):

1147

1350

if(name == '_pipe'):

1148

1351

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

1155

1358

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

1156

1359

return self._pipe.recv()[1]

1157

1360

return func

1158

1361

1159

1362

def __setattr__(self, name, value):

1160

1363

if(name == '_pipe'):

1161

1364

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

1162

1365

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

1163

1366

1367

class ClientDBusTransitional(ClientDBus):

1368

__metaclass__ = AlternateDBusNamesMetaclass

1164

1369

1165

1370

class ClientHandler(socketserver.BaseRequestHandler, object):

1166

1371

"""A class to handle client connections.

1174

1379

unicode(self.client_address))

1175

1380

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

1176

1381

self.server.child_pipe.fileno())

1177

1382

1178

1383

session = (gnutls.connection

1179

1384

.ClientSession(self.request,

1180

1385

gnutls.connection

1181

1386

.X509Credentials()))

1182

1387

1183

1388

# Note: gnutls.connection.X509Credentials is really a

1184

1389

# generic GnuTLS certificate credentials object so long as

1185

1390

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

1186

1391

# here despite using OpenPGP certificates.

1187

1392

1188

1393

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

1189

1394

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

1190

1395

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

1196

1401

(gnutls.library.functions

1197

1402

.gnutls_priority_set_direct(session._c_object,

1198

1403

priority, None))

1199

1404

1200

1405

# Start communication using the Mandos protocol

1201

1406

# Get protocol number

1202

1407

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

1204

1409

try:

1205

1410

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

1206

1411

raise RuntimeError

1207

except (ValueError, IndexError, RuntimeError), error:

1412

except (ValueError, IndexError, RuntimeError) as error:

1208

1413

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

1209

1414

return

1210

1415

1211

1416

# Start GnuTLS connection

1212

1417

try:

1213

1418

session.handshake()

1214

except gnutls.errors.GNUTLSError, error:

1419

except gnutls.errors.GNUTLSError as error:

1215

1420

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

1216

1421

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

1217

1422

# established. Just abandon the request.

1218

1423

return

1219

1424

logger.debug("Handshake succeeded")

1220

1425

1221

1426

approval_required = False

1222

1427

try:

1223

1428

try:

1224

1429

fpr = self.fingerprint(self.peer_certificate

1225

1430

(session))

1226

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

1431

except (TypeError,

1432

gnutls.errors.GNUTLSError) as error:

1227

1433

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

1228

1434

return

1229

1435

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

1230

1436

if self.server.use_dbus:

1437

# Emit D-Bus signal

1438

client.NewRequest(str(self.client_address))

1439

1231

1440

try:

1232

1441

client = ProxyClient(child_pipe, fpr,

1233

1442

self.client_address)

1241

1450

1242

1451

while True:

1243

1452

if not client.enabled:

1244

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

1453

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

1245

1454

client.name)

1246

1455

if self.server.use_dbus:

1247

1456

# Emit D-Bus signal

1248

client.Rejected("Disabled")

1457

client.Rejected("Disabled")

1249

1458

return

1250

1459

1251

1460

if client._approved or not client.approval_delay:

1268

1477

return

1269

1478

1270

1479

#wait until timeout or approved

1271

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

1272

1480

time = datetime.datetime.now()

1273

1481

client.changedstate.acquire()

1274

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

1482

(client.changedstate.wait

1483

(float(client._timedelta_to_milliseconds(delay)

1484

/ 1000)))

1275

1485

client.changedstate.release()

1276

1486

time2 = datetime.datetime.now()

1277

1487

if (time2 - time) >= delay:

1292

1502

while sent_size < len(client.secret):

1293

1503

try:

1294

1504

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

1295

except (gnutls.errors.GNUTLSError), error:

1505

except gnutls.errors.GNUTLSError as error:

1296

1506

logger.warning("gnutls send failed")

1297

1507

return

1298

1508

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

1299

1509

sent, len(client.secret)

1300

1510

- (sent_size + sent))

1301

1511

sent_size += sent

1302

1512

1303

1513

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

1304

# bump the timeout as if seen

1305

client.checked_ok()

1514

# bump the timeout using extended_timeout

1515

client.checked_ok(client.extended_timeout)

1306

1516

if self.server.use_dbus:

1307

1517

# Emit D-Bus signal

1308

1518

client.GotSecret()

1312

1522

client.approvals_pending -= 1

1313

1523

try:

1314

1524

session.bye()

1315

except (gnutls.errors.GNUTLSError), error:

1525

except gnutls.errors.GNUTLSError as error:

1316

1526

logger.warning("GnuTLS bye failed")

1317

1527

1318

1528

@staticmethod

1387

1597

except:

1388

1598

self.handle_error(request, address)

1389

1599

self.close_request(request)

1390

1600

1391

1601

def process_request(self, request, address):

1392

1602

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

1393

multiprocessing.Process(target = self.sub_process_main,

1394

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

1603

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

1604

args = (request,

1605

address))

1606

proc.start()

1607

return proc

1608

1395

1609

1396

1610

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1397

1611

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

1401

1615

This function creates a new pipe in self.pipe

1402

1616

"""

1403

1617

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1404

1405

super(MultiprocessingMixInWithPipe,

1406

self).process_request(request, client_address)

1618

1619

proc = MultiprocessingMixIn.process_request(self, request,

1620

client_address)

1407

1621

self.child_pipe.close()

1408

self.add_pipe(parent_pipe)

1409

1410

def add_pipe(self, parent_pipe):

1622

self.add_pipe(parent_pipe, proc)

1623

1624

def add_pipe(self, parent_pipe, proc):

1411

1625

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

1412

1626

raise NotImplementedError

1413

1627

1628

1414

1629

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1415

1630

socketserver.TCPServer, object):

1416

1631

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

1442

1657

SO_BINDTODEVICE,

1443

1658

str(self.interface

1444

1659

+ '\0'))

1445

except socket.error, error:

1660

except socket.error as error:

1446

1661

if error[0] == errno.EPERM:

1447

1662

logger.error("No permission to"

1448

1663

" bind to interface %s",

1490

1705

self.enabled = False

1491

1706

self.clients = clients

1492

1707

if self.clients is None:

1493

self.clients = set()

1708

self.clients = {}

1494

1709

self.use_dbus = use_dbus

1495

1710

self.gnutls_priority = gnutls_priority

1496

1711

IPv6_TCPServer.__init__(self, server_address,

1500

1715

def server_activate(self):

1501

1716

if self.enabled:

1502

1717

return socketserver.TCPServer.server_activate(self)

1718

1503

1719

def enable(self):

1504

1720

self.enabled = True

1505

def add_pipe(self, parent_pipe):

1721

1722

def add_pipe(self, parent_pipe, proc):

1506

1723

# Call "handle_ipc" for both data and EOF events

1507

1724

gobject.io_add_watch(parent_pipe.fileno(),

1508

1725

gobject.IO_IN | gobject.IO_HUP,

1509

1726

functools.partial(self.handle_ipc,

1510

parent_pipe = parent_pipe))

1511

1727

parent_pipe =

1728

parent_pipe,

1729

proc = proc))

1730

1512

1731

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

1513

client_object=None):

1732

proc = None, client_object=None):

1514

1733

condition_names = {

1515

1734

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

1516

1735

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

1525

1744

for cond, name in

1526

1745

condition_names.iteritems()

1527

1746

if cond & condition)

1528

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

1747

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

1529

1748

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

1749

# Wait for other process to exit

1750

proc.join()

1530

1751

return False

1531

1752

1532

1753

# Read a request from the child

1537

1758

fpr = request[1]

1538

1759

address = request[2]

1539

1760

1540

for c in self.clients:

1761

for c in self.clients.itervalues():

1541

1762

if c.fingerprint == fpr:

1542

1763

client = c

1543

1764

break

1544

1765

else:

1545

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

1546

"dress: %s", fpr, address)

1766

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

1767

"dress: %s", fpr, address)

1547

1768

if self.use_dbus:

1548

1769

# Emit D-Bus signal

1549

mandos_dbus_service.ClientNotFound(fpr, address[0])

1770

mandos_dbus_service.ClientNotFound(fpr,

1771

address[0])

1550

1772

parent_pipe.send(False)

1551

1773

return False

1552

1774

1553

1775

gobject.io_add_watch(parent_pipe.fileno(),

1554

1776

gobject.IO_IN | gobject.IO_HUP,

1555

1777

functools.partial(self.handle_ipc,

1556

parent_pipe = parent_pipe,

1557

client_object = client))

1778

parent_pipe =

1779

parent_pipe,

1780

proc = proc,

1781

client_object =

1782

client))

1558

1783

parent_pipe.send(True)

1559

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

1784

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

1785

# same fileno

1560

1786

return False

1561

1787

if command == 'funcall':

1562

1788

funcname = request[1]

1563

1789

args = request[2]

1564

1790

kwargs = request[3]

1565

1791

1566

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

1567

1792

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

1793

funcname)(*args,

1794

**kwargs)))

1795

1568

1796

if command == 'getattr':

1569

1797

attrname = request[1]

1570

1798

if callable(client_object.__getattribute__(attrname)):

1571

1799

parent_pipe.send(('function',))

1572

1800

else:

1573

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

1801

parent_pipe.send(('data', client_object

1802

.__getattribute__(attrname)))

1574

1803

1575

1804

if command == 'setattr':

1576

1805

attrname = request[1]

1577

1806

value = request[2]

1578

1807

setattr(client_object, attrname, value)

1579

1808

1580

1809

return True

1581

1810

1582

1811

1613

1842

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

1614

1843

else:

1615

1844

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

1616

except (ValueError, IndexError), e:

1845

except (ValueError, IndexError) as e:

1617

1846

raise ValueError(*(e.args))

1618

1847

timevalue += delta

1619

1848

return timevalue

1703

1932

" system bus interface")

1704

1933

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

1705

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

1706

1939

options = parser.parse_args()

1707

1940

1708

1941

if options.check:

1743

1976

# options, if set.

1744

1977

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

1745

1978

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

1746

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

1979

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

1747

1980

value = getattr(options, option)

1748

1981

if value is not None:

1749

1982

server_settings[option] = value

1761

1994

debuglevel = server_settings["debuglevel"]

1762

1995

use_dbus = server_settings["use_dbus"]

1763

1996

use_ipv6 = server_settings["use_ipv6"]

1764

1997

1765

1998

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

1766

1999

syslogger.setFormatter(logging.Formatter

1767

2000

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

1769

2002

% server_settings["servicename"]))

1770

2003

1771

2004

# Parse config file with clients

1772

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

1773

"interval": "5m",

2005

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

2006

"extended_timeout": "15m",

2007

"interval": "2m",

1774

2008

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

1775

2009

"host": "",

1776

2010

"approval_delay": "0s",

1816

2050

try:

1817

2051

os.setgid(gid)

1818

2052

os.setuid(uid)

1819

except OSError, error:

2053

except OSError as error:

1820

2054

if error[0] != errno.EPERM:

1821

2055

raise error

1822

2056

1823

2057

if not debug and not debuglevel:

1824

syslogger.setLevel(logging.WARNING)

1825

console.setLevel(logging.WARNING)

2058

logger.setLevel(logging.WARNING)

1826

2059

if debuglevel:

1827

2060

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

1828

syslogger.setLevel(level)

1829

console.setLevel(level)

1830

2061

logger.setLevel(level)

2062

1831

2063

if debug:

2064

logger.setLevel(logging.DEBUG)

1832

2065

# Enable all possible GnuTLS debugging

1833

2066

1834

2067

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

1864

2097

# End of Avahi example code

1865

2098

if use_dbus:

1866

2099

try:

1867

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

2100

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

1868

2101

bus, do_not_queue=True)

1869

except dbus.exceptions.NameExistsException, e:

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:

1870

2106

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

1871

2107

use_dbus = False

1872

2108

server_settings["use_dbus"] = False

1873

2109

tcp_server.use_dbus = False

1874

2110

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1875

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

1876

servicetype = "_mandos._tcp",

1877

protocol = protocol, bus = bus)

2111

service = AvahiServiceToSyslog(name =

2112

server_settings["servicename"],

2113

servicetype = "_mandos._tcp",

2114

protocol = protocol, bus = bus)

1878

2115

if server_settings["interface"]:

1879

2116

service.interface = (if_nametoindex

1880

2117

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

1884

2121

1885

2122

client_class = Client

1886

2123

if use_dbus:

1887

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

1888

def client_config_items(config, section):

1889

special_settings = {

1890

"approved_by_default":

1891

lambda: config.getboolean(section,

1892

"approved_by_default"),

1893

}

1894

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

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

1895

2167

try:

1896

yield (name, special_settings[name]())

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)

1897

2173

except KeyError:

1898

yield (name, value)

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

1899

2220

1900

tcp_server.clients.update(set(

1901

client_class(name = section,

1902

config= dict(client_config_items(

1903

client_config, section)))

1904

for section in client_config.sections()))

2221

1905

2222

if not tcp_server.clients:

1906

2223

logger.warning("No clients defined")

1907

2224

1920

2237

del pidfilename

1921

2238

1922

2239

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

1923

2240

1924

2241

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

1925

2242

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

1926

2243

1929

2246

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

1930

2247

def __init__(self):

1931

2248

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

1932

_interface = "se.bsnet.fukt.Mandos"

2249

_interface = "se.recompile.Mandos"

1933

2250

1934

2251

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

1935

2252

def ClientAdded(self, objpath):

1950

2267

def GetAllClients(self):

1951

2268

"D-Bus method"

1952

2269

return dbus.Array(c.dbus_object_path

1953

for c in tcp_server.clients)

2270

for c in

2271

tcp_server.clients.itervalues())

1954

2272

1955

2273

@dbus.service.method(_interface,

1956

2274

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

1958

2276

"D-Bus method"

1959

2277

return dbus.Dictionary(

1960

2278

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

1961

for c in tcp_server.clients),

2279

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

1962

2280

signature="oa{sv}")

1963

2281

1964

2282

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

1965

2283

def RemoveClient(self, object_path):

1966

2284

"D-Bus method"

1967

for c in tcp_server.clients:

2285

for c in tcp_server.clients.itervalues():

1968

2286

if c.dbus_object_path == object_path:

1969

tcp_server.clients.remove(c)

2287

del tcp_server.clients[c.name]

1970

2288

c.remove_from_connection()

1971

2289

# Don't signal anything except ClientRemoved

1972

2290

c.disable(quiet=True)

1977

2295

1978

2296

del _interface

1979

2297

1980

mandos_dbus_service = MandosDBusService()

2298

class MandosDBusServiceTransitional(MandosDBusService):

2299

__metaclass__ = AlternateDBusNamesMetaclass

2300

mandos_dbus_service = MandosDBusServiceTransitional()

1981

2301

1982

2302

def cleanup():

1983

2303

"Cleanup function; run on exit"

1984

2304

service.cleanup()

1985

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

1986

2341

while tcp_server.clients:

1987

client = tcp_server.clients.pop()

2342

name, client = tcp_server.clients.popitem()

1988

2343

if use_dbus:

1989

2344

client.remove_from_connection()

1990

client.disable_hook = None

1991

2345

# Don't signal anything except ClientRemoved

1992

2346

client.disable(quiet=True)

1993

2347

if use_dbus:

1994

2348

# Emit D-Bus signal

1995

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2349

mandos_dbus_service.ClientRemoved(client

2350

.dbus_object_path,

1996

2351

client.name)

2352

client_settings.clear()

1997

2353

1998

2354

atexit.register(cleanup)

1999

2355

2000

for client in tcp_server.clients:

2356

for client in tcp_server.clients.itervalues():

2001

2357

if use_dbus:

2002

2358

# Emit D-Bus signal

2003

2359

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2004

client.enable()

2360

# Need to initiate checking of clients

2361

if client.enabled:

2362

client.init_checker()

2363

2005

2364

2006

2365

tcp_server.enable()

2007

2366

tcp_server.server_activate()

2022

2381

# From the Avahi example code

2023

2382

try:

2024

2383

service.activate()

2025

except dbus.exceptions.DBusException, error:

2384

except dbus.exceptions.DBusException as error:

2026

2385

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

2027

2386

cleanup()

2028

2387

sys.exit(1)

2035

2394

2036

2395

logger.debug("Starting main loop")

2037

2396

main_loop.run()

2038

except AvahiError, error:

2397

except AvahiError as error:

2039

2398

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

2040

2399

cleanup()

2041

2400

sys.exit(1)

2047

2406

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

2048

2407

cleanup()

2049

2408

2409

2050

2410

if __name__ == '__main__':

2051

2411

main()