/mandos/trunk : revision 341

11

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

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

55

import logging

56

import logging.handlers

57

import pwd

58

import contextlib

58

from contextlib import closing

59

import struct

60

import fcntl

61

import functools

62

import cPickle as pickle

63

import multiprocessing

64

62

65

63

import dbus

66

64

import dbus.service

69

67

from dbus.mainloop.glib import DBusGMainLoop

70

68

import ctypes

71

69

import ctypes.util

72

import xml.dom.minidom

73

import inspect

74

70

75

71

try:

76

72

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

81

77

SO_BINDTODEVICE = None

82

78

83

79

84

version = "1.0.14"

80

version = "1.0.8"

85

81

86

#logger = logging.getLogger(u'mandos')

87

82

logger = logging.Logger(u'mandos')

88

83

syslogger = (logging.handlers.SysLogHandler

89

84

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

157

152

u" after %i retries, exiting.",

158

153

self.rename_count)

159

154

raise AvahiServiceError(u"Too many renames")

160

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

155

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

161

156

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

162

self.name)

157

unicode(self.name))

163

158

syslogger.setFormatter(logging.Formatter

164

159

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

165

160

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

166

161

% self.name))

167

162

self.remove()

168

try:

169

self.add()

170

except dbus.exceptions.DBusException, error:

171

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

172

self.cleanup()

173

os._exit(1)

163

self.add()

174

164

self.rename_count += 1

175

165

def remove(self):

176

166

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

184

174

self.server.EntryGroupNew()),

185

175

avahi.DBUS_INTERFACE_ENTRY_GROUP)

186

176

self.group.connect_to_signal('StateChanged',

187

self

188

.entry_group_state_changed)

177

self.entry_group_state_changed)

189

178

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

190

179

self.name, self.type)

191

180

self.group.AddService(

199

188

self.group.Commit()

200

189

def entry_group_state_changed(self, state, error):

201

190

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

202

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

191

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

203

192

204

193

if state == avahi.ENTRY_GROUP_ESTABLISHED:

205

194

logger.debug(u"Zeroconf service established.")

218

207

self.group = None

219

208

def server_state_changed(self, state):

220

209

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

221

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

222

210

if state == avahi.SERVER_COLLISION:

223

211

logger.error(u"Zeroconf server name collision")

224

212

self.remove()

240

228

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

241

229

242

230

Attributes:

243

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

244

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

245

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

231

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

232

D-Bus identifiers

233

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

234

uniquely identify the client

235

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

236

host: string; available for use by the checker command

237

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

238

last_enabled: datetime.datetime(); (UTC)

239

enabled: bool()

240

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

241

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

242

until this client is invalid

243

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

244

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

246

245

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

247

246

to see if the client lives.

248

247

'None' if no process is running.

249

checker_callback_tag: a gobject event source tag, or None

250

checker_command: string; External command which is run to check

251

if client lives. %() expansions are done at

248

checker_initiator_tag: a gobject event source tag, or None

249

disable_initiator_tag: - '' -

250

checker_callback_tag: - '' -

251

checker_command: string; External command which is run to check if

252

client lives. %() expansions are done at

252

253

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

253

254

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

254

checker_initiator_tag: a gobject event source tag, or None

255

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

256

255

current_checker_command: string; current running checker_command

257

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

258

disable_initiator_tag: a gobject event source tag, or None

259

enabled: bool()

260

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

261

uniquely identify the client

262

host: string; available for use by the checker command

263

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

264

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

265

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

266

last_enabled: datetime.datetime(); (UTC)

267

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

268

D-Bus identifiers

269

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

270

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

271

until this client is disabled

272

runtime_expansions: Allowed attributes for runtime expansion.

273

256

"""

274

257

275

runtime_expansions = (u"approval_delay", u"approval_duration",

276

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

277

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

278

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

279

280

258

@staticmethod

281

def _timedelta_to_milliseconds(td):

282

"Convert a datetime.timedelta() to milliseconds"

283

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

284

+ (td.seconds * 1000)

285

+ (td.microseconds // 1000))

259

def _datetime_to_milliseconds(dt):

260

"Convert a datetime.datetime() to milliseconds"

261

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

262

+ (dt.seconds * 1000)

263

+ (dt.microseconds // 1000))

286

264

287

265

def timeout_milliseconds(self):

288

266

"Return the 'timeout' attribute in milliseconds"

289

return self._timedelta_to_milliseconds(self.timeout)

267

return self._datetime_to_milliseconds(self.timeout)

290

268

291

269

def interval_milliseconds(self):

292

270

"Return the 'interval' attribute in milliseconds"

293

return self._timedelta_to_milliseconds(self.interval)

294

295

def approval_delay_milliseconds(self):

296

return self._timedelta_to_milliseconds(self.approval_delay)

271

return self._datetime_to_milliseconds(self.interval)

297

272

298

273

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

299

274

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

312

287

if u"secret" in config:

313

288

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

314

289

elif u"secfile" in config:

315

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

316

(config[u"secfile"])),

317

"rb") as secfile:

290

with closing(open(os.path.expanduser

291

(os.path.expandvars

292

(config[u"secfile"])))) as secfile:

318

293

self.secret = secfile.read()

319

294

else:

320

295

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

322

297

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

323

298

self.created = datetime.datetime.utcnow()

324

299

self.enabled = False

325

self.last_approval_request = None

326

300

self.last_enabled = None

327

301

self.last_checked_ok = None

328

302

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

335

309

self.checker_command = config[u"checker"]

336

310

self.current_checker_command = None

337

311

self.last_connect = None

338

self._approved = None

339

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

340

True)

341

self.approvals_pending = 0

342

self.approval_delay = string_to_delta(

343

config[u"approval_delay"])

344

self.approval_duration = string_to_delta(

345

config[u"approval_duration"])

346

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

347

312

348

def send_changedstate(self):

349

self.changedstate.acquire()

350

self.changedstate.notify_all()

351

self.changedstate.release()

352

353

313

def enable(self):

354

314

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

355

315

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

356

316

# Already enabled

357

317

return

358

self.send_changedstate()

359

318

self.last_enabled = datetime.datetime.utcnow()

360

319

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

361

320

# and every interval from then on.

362

321

self.checker_initiator_tag = (gobject.timeout_add

363

322

(self.interval_milliseconds(),

364

323

self.start_checker))

324

# Also start a new checker *right now*.

325

self.start_checker()

365

326

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

366

327

self.disable_initiator_tag = (gobject.timeout_add

367

328

(self.timeout_milliseconds(),

368

329

self.disable))

369

330

self.enabled = True

370

# Also start a new checker *right now*.

371

self.start_checker()

372

331

373

def disable(self, quiet=True):

332

def disable(self):

374

333

"""Disable this client."""

375

334

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

376

335

return False

377

if not quiet:

378

self.send_changedstate()

379

if not quiet:

380

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

336

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

381

337

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

382

338

gobject.source_remove(self.disable_initiator_tag)

383

339

self.disable_initiator_tag = None

424

380

(self.timeout_milliseconds(),

425

381

self.disable))

426

382

427

def need_approval(self):

428

self.last_approval_request = datetime.datetime.utcnow()

429

430

383

def start_checker(self):

431

384

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

432

385

438

391

# client would inevitably timeout, since no checker would get

439

392

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

440

393

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

441

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

442

# should be.

394

# than 'timeout' for the client to be declared invalid, which

395

# is as it should be.

443

396

444

397

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

445

try:

398

if self.checker is not None:

446

399

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

447

except (AttributeError, OSError), error:

448

if (isinstance(error, OSError)

449

and error.errno != errno.ECHILD):

450

raise error

451

else:

452

400

if pid:

453

401

logger.warning(u"Checker was a zombie")

454

402

gobject.source_remove(self.checker_callback_tag)

461

409

command = self.checker_command % self.host

462

410

except TypeError:

463

411

# Escape attributes for the shell

464

escaped_attrs = dict(

465

(attr,

466

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

467

errors=

468

u'replace')))

469

for attr in

470

self.runtime_expansions)

471

412

escaped_attrs = dict((key,

413

re.escape(unicode(str(val),

414

errors=

415

u'replace')))

416

for key, val in

417

vars(self).iteritems())

472

418

try:

473

419

command = self.checker_command % escaped_attrs

474

420

except TypeError, error:

512

458

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

513

459

try:

514

460

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

515

#time.sleep(0.5)

461

#os.sleep(0.5)

516

462

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

517

463

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

518

464

except OSError, error:

519

465

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

520

466

raise

521

467

self.checker = None

522

523

def dbus_service_property(dbus_interface, signature=u"v",

524

access=u"readwrite", byte_arrays=False):

525

"""Decorators for marking methods of a DBusObjectWithProperties to

526

become properties on the D-Bus.

527

528

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

529

and with one argument by "Set".

530

531

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

532

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

533

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

534

"""

535

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

536

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

537

if byte_arrays and signature != u"ay":

538

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

539

u" signature %r" % signature)

540

def decorator(func):

541

func._dbus_is_property = True

542

func._dbus_interface = dbus_interface

543

func._dbus_signature = signature

544

func._dbus_access = access

545

func._dbus_name = func.__name__

546

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

547

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

548

func._dbus_get_args_options = {u'byte_arrays': byte_arrays }

549

return func

550

return decorator

551

552

553

class DBusPropertyException(dbus.exceptions.DBusException):

554

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

555

"""

556

def __unicode__(self):

557

return unicode(str(self))

558

559

560

class DBusPropertyAccessException(DBusPropertyException):

561

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

562

"""

563

pass

564

565

566

class DBusPropertyNotFound(DBusPropertyException):

567

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

568

"""

569

pass

570

571

572

class DBusObjectWithProperties(dbus.service.Object):

573

"""A D-Bus object with properties.

574

575

Classes inheriting from this can use the dbus_service_property

576

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

577

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

578

"""

579

580

@staticmethod

581

def _is_dbus_property(obj):

582

return getattr(obj, u"_dbus_is_property", False)

583

584

def _get_all_dbus_properties(self):

585

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

586

"""

587

return ((prop._dbus_name, prop)

588

for name, prop in

589

inspect.getmembers(self, self._is_dbus_property))

590

591

def _get_dbus_property(self, interface_name, property_name):

592

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

593

property with the specified name and interface.

594

"""

595

for name in (property_name,

596

property_name + u"_dbus_property"):

597

prop = getattr(self, name, None)

598

if (prop is None

599

or not self._is_dbus_property(prop)

600

or prop._dbus_name != property_name

601

or (interface_name and prop._dbus_interface

602

and interface_name != prop._dbus_interface)):

603

continue

604

return prop

605

# No such property

606

raise DBusPropertyNotFound(self.dbus_object_path + u":"

607

+ interface_name + u"."

608

+ property_name)

609

610

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

611

out_signature=u"v")

612

def Get(self, interface_name, property_name):

613

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

614

"""

615

prop = self._get_dbus_property(interface_name, property_name)

616

if prop._dbus_access == u"write":

617

raise DBusPropertyAccessException(property_name)

618

value = prop()

619

if not hasattr(value, u"variant_level"):

620

return value

621

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

622

623

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

624

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

625

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

626

"""

627

prop = self._get_dbus_property(interface_name, property_name)

628

if prop._dbus_access == u"read":

629

raise DBusPropertyAccessException(property_name)

630

if prop._dbus_get_args_options[u"byte_arrays"]:

631

# The byte_arrays option is not supported yet on

632

# signatures other than "ay".

633

if prop._dbus_signature != u"ay":

634

raise ValueError

635

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

636

for byte in value))

637

prop(value)

638

639

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

640

out_signature=u"a{sv}")

641

def GetAll(self, interface_name):

642

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

643

standard.

644

645

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

646

"""

647

all = {}

648

for name, prop in self._get_all_dbus_properties():

649

if (interface_name

650

and interface_name != prop._dbus_interface):

651

# Interface non-empty but did not match

652

continue

653

# Ignore write-only properties

654

if prop._dbus_access == u"write":

655

continue

656

value = prop()

657

if not hasattr(value, u"variant_level"):

658

all[name] = value

659

continue

660

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

661

value.variant_level+1)

662

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

663

664

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

665

out_signature=u"s",

666

path_keyword='object_path',

667

connection_keyword='connection')

668

def Introspect(self, object_path, connection):

669

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

670

"""

671

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

672

connection)

673

try:

674

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

675

def make_tag(document, name, prop):

676

e = document.createElement(u"property")

677

e.setAttribute(u"name", name)

678

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

679

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

680

return e

681

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

682

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

683

for name, prop

684

in self._get_all_dbus_properties()

685

if prop._dbus_interface

686

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

687

if_tag.appendChild(tag)

688

# Add the names to the return values for the

689

# "org.freedesktop.DBus.Properties" methods

690

if (if_tag.getAttribute(u"name")

691

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

692

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

693

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

694

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

695

if (arg.getAttribute(u"direction")

696

== u"out"):

697

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

698

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

699

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

700

if (arg.getAttribute(u"direction")

701

== u"out"):

702

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

703

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

704

document.unlink()

705

except (AttributeError, xml.dom.DOMException,

706

xml.parsers.expat.ExpatError), error:

707

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

708

error)

709

return xmlstring

710

711

712

class ClientDBus(Client, DBusObjectWithProperties):

468

469

def still_valid(self):

470

"""Has the timeout not yet passed for this client?"""

471

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

472

return False

473

now = datetime.datetime.utcnow()

474

if self.last_checked_ok is None:

475

return now < (self.created + self.timeout)

476

else:

477

return now < (self.last_checked_ok + self.timeout)

478

479

480

class ClientDBus(Client, dbus.service.Object):

713

481

"""A Client class using D-Bus

714

482

715

483

Attributes:

716

484

dbus_object_path: dbus.ObjectPath

717

485

bus: dbus.SystemBus()

718

486

"""

719

720

runtime_expansions = (Client.runtime_expansions

721

+ (u"dbus_object_path",))

722

723

487

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

724

488

725

489

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

726

self._approvals_pending = 0

727

490

self.bus = bus

728

491

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

729

492

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

730

493

# the D-Bus

731

client_object_name = unicode(self.name).translate(

732

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

733

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

734

494

self.dbus_object_path = (dbus.ObjectPath

735

(u"/clients/" + client_object_name))

736

DBusObjectWithProperties.__init__(self, self.bus,

737

self.dbus_object_path)

738

739

def _get_approvals_pending(self):

740

return self._approvals_pending

741

def _set_approvals_pending(self, value):

742

old_value = self._approvals_pending

743

self._approvals_pending = value

744

bval = bool(value)

745

if (hasattr(self, "dbus_object_path")

746

and bval is not bool(old_value)):

747

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

748

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

749

dbus_bool)

750

751

approvals_pending = property(_get_approvals_pending,

752

_set_approvals_pending)

753

del _get_approvals_pending, _set_approvals_pending

495

(u"/clients/"

496

+ self.name.replace(u".", u"_")))

497

dbus.service.Object.__init__(self, self.bus,

498

self.dbus_object_path)

754

499

755

500

@staticmethod

756

501

def _datetime_to_dbus(dt, variant_level=0):

763

508

r = Client.enable(self)

764

509

if oldstate != self.enabled:

765

510

# Emit D-Bus signals

766

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

511

self.PropertyChanged(dbus.String(u"enabled"),

767

512

dbus.Boolean(True, variant_level=1))

768

513

self.PropertyChanged(

769

dbus.String(u"LastEnabled"),

514

dbus.String(u"last_enabled"),

770

515

self._datetime_to_dbus(self.last_enabled,

771

516

variant_level=1))

772

517

return r

773

518

774

def disable(self, quiet = False):

519

def disable(self, signal = True):

775

520

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

776

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

777

if not quiet and oldstate != self.enabled:

521

r = Client.disable(self)

522

if signal and oldstate != self.enabled:

778

523

# Emit D-Bus signal

779

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

524

self.PropertyChanged(dbus.String(u"enabled"),

780

525

dbus.Boolean(False, variant_level=1))

781

526

return r

782

527

785

530

self.remove_from_connection()

786

531

except LookupError:

787

532

pass

788

if hasattr(DBusObjectWithProperties, u"__del__"):

789

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

533

if hasattr(dbus.service.Object, u"__del__"):

534

dbus.service.Object.__del__(self, *args, **kwargs)

790

535

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

791

536

792

537

def checker_callback(self, pid, condition, command,

794

539

self.checker_callback_tag = None

795

540

self.checker = None

796

541

# Emit D-Bus signal

797

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

542

self.PropertyChanged(dbus.String(u"checker_running"),

798

543

dbus.Boolean(False, variant_level=1))

799

544

if os.WIFEXITED(condition):

800

545

exitstatus = os.WEXITSTATUS(condition)

815

560

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

816

561

# Emit D-Bus signal

817

562

self.PropertyChanged(

818

dbus.String(u"LastCheckedOK"),

563

dbus.String(u"last_checked_ok"),

819

564

(self._datetime_to_dbus(self.last_checked_ok,

820

565

variant_level=1)))

821

566

return r

822

567

823

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

824

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

825

# Emit D-Bus signal

826

self.PropertyChanged(

827

dbus.String(u"LastApprovalRequest"),

828

(self._datetime_to_dbus(self.last_approval_request,

829

variant_level=1)))

830

return r

831

832

568

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

833

569

old_checker = self.checker

834

570

if self.checker is not None:

842

578

# Emit D-Bus signal

843

579

self.CheckerStarted(self.current_checker_command)

844

580

self.PropertyChanged(

845

dbus.String(u"CheckerRunning"),

581

dbus.String(u"checker_running"),

846

582

dbus.Boolean(True, variant_level=1))

847

583

return r

848

584

851

587

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

852

588

if (old_checker is not None

853

589

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

854

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

590

self.PropertyChanged(dbus.String(u"checker_running"),

855

591

dbus.Boolean(False, variant_level=1))

856

592

return r

857

858

def _reset_approved(self):

859

self._approved = None

860

return False

861

862

def approve(self, value=True):

863

self.send_changedstate()

864

self._approved = value

865

gobject.timeout_add(self._timedelta_to_milliseconds

866

(self.approval_duration),

867

self._reset_approved)

868

869

870

## D-Bus methods, signals & properties

593

594

## D-Bus methods & signals

871

595

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

872

596

873

## Signals

597

# CheckedOK - method

598

@dbus.service.method(_interface)

599

def CheckedOK(self):

600

return self.checked_ok()

874

601

875

602

# CheckerCompleted - signal

876

603

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

884

611

"D-Bus signal"

885

612

pass

886

613

614

# GetAllProperties - method

615

@dbus.service.method(_interface, out_signature=u"a{sv}")

616

def GetAllProperties(self):

617

"D-Bus method"

618

return dbus.Dictionary({

619

dbus.String(u"name"):

620

dbus.String(self.name, variant_level=1),

621

dbus.String(u"fingerprint"):

622

dbus.String(self.fingerprint, variant_level=1),

623

dbus.String(u"host"):

624

dbus.String(self.host, variant_level=1),

625

dbus.String(u"created"):

626

self._datetime_to_dbus(self.created,

627

variant_level=1),

628

dbus.String(u"last_enabled"):

629

(self._datetime_to_dbus(self.last_enabled,

630

variant_level=1)

631

if self.last_enabled is not None

632

else dbus.Boolean(False, variant_level=1)),

633

dbus.String(u"enabled"):

634

dbus.Boolean(self.enabled, variant_level=1),

635

dbus.String(u"last_checked_ok"):

636

(self._datetime_to_dbus(self.last_checked_ok,

637

variant_level=1)

638

if self.last_checked_ok is not None

639

else dbus.Boolean (False, variant_level=1)),

640

dbus.String(u"timeout"):

641

dbus.UInt64(self.timeout_milliseconds(),

642

variant_level=1),

643

dbus.String(u"interval"):

644

dbus.UInt64(self.interval_milliseconds(),

645

variant_level=1),

646

dbus.String(u"checker"):

647

dbus.String(self.checker_command,

648

variant_level=1),

649

dbus.String(u"checker_running"):

650

dbus.Boolean(self.checker is not None,

651

variant_level=1),

652

dbus.String(u"object_path"):

653

dbus.ObjectPath(self.dbus_object_path,

654

variant_level=1)

655

}, signature=u"sv")

656

657

# IsStillValid - method

658

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

659

def IsStillValid(self):

660

return self.still_valid()

661

887

662

# PropertyChanged - signal

888

663

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

889

664

def PropertyChanged(self, property, value):

890

665

"D-Bus signal"

891

666

pass

892

667

893

# GotSecret - signal

668

# ReceivedSecret - signal

894

669

@dbus.service.signal(_interface)

895

def GotSecret(self):

896

"""D-Bus signal

897

Is sent after a successful transfer of secret from the Mandos

898

server to mandos-client

899

"""

670

def ReceivedSecret(self):

671

"D-Bus signal"

900

672

pass

901

673

902

674

# Rejected - signal

903

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

904

def Rejected(self, reason):

675

@dbus.service.signal(_interface)

676

def Rejected(self):

905

677

"D-Bus signal"

906

678

pass

907

679

908

# NeedApproval - signal

909

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

910

def NeedApproval(self, timeout, default):

911

"D-Bus signal"

912

return self.need_approval()

913

914

## Methods

915

916

# Approve - method

917

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

918

def Approve(self, value):

919

self.approve(value)

920

921

# CheckedOK - method

922

@dbus.service.method(_interface)

923

def CheckedOK(self):

924

return self.checked_ok()

680

# SetChecker - method

681

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

682

def SetChecker(self, checker):

683

"D-Bus setter method"

684

self.checker_command = checker

685

# Emit D-Bus signal

686

self.PropertyChanged(dbus.String(u"checker"),

687

dbus.String(self.checker_command,

688

variant_level=1))

689

690

# SetHost - method

691

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

692

def SetHost(self, host):

693

"D-Bus setter method"

694

self.host = host

695

# Emit D-Bus signal

696

self.PropertyChanged(dbus.String(u"host"),

697

dbus.String(self.host, variant_level=1))

698

699

# SetInterval - method

700

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

701

def SetInterval(self, milliseconds):

702

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

703

# Emit D-Bus signal

704

self.PropertyChanged(dbus.String(u"interval"),

705

(dbus.UInt64(self.interval_milliseconds(),

706

variant_level=1)))

707

708

# SetSecret - method

709

@dbus.service.method(_interface, in_signature=u"ay",

710

byte_arrays=True)

711

def SetSecret(self, secret):

712

"D-Bus setter method"

713

self.secret = str(secret)

714

715

# SetTimeout - method

716

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

717

def SetTimeout(self, milliseconds):

718

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

719

# Emit D-Bus signal

720

self.PropertyChanged(dbus.String(u"timeout"),

721

(dbus.UInt64(self.timeout_milliseconds(),

722

variant_level=1)))

925

723

926

724

# Enable - method

927

725

@dbus.service.method(_interface)

946

744

def StopChecker(self):

947

745

self.stop_checker()

948

746

949

## Properties

950

951

# ApprovalPending - property

952

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

953

def ApprovalPending_dbus_property(self):

954

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

955

956

# ApprovedByDefault - property

957

@dbus_service_property(_interface, signature=u"b",

958

access=u"readwrite")

959

def ApprovedByDefault_dbus_property(self, value=None):

960

if value is None: # get

961

return dbus.Boolean(self.approved_by_default)

962

self.approved_by_default = bool(value)

963

# Emit D-Bus signal

964

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

965

dbus.Boolean(value, variant_level=1))

966

967

# ApprovalDelay - property

968

@dbus_service_property(_interface, signature=u"t",

969

access=u"readwrite")

970

def ApprovalDelay_dbus_property(self, value=None):

971

if value is None: # get

972

return dbus.UInt64(self.approval_delay_milliseconds())

973

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

974

# Emit D-Bus signal

975

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

976

dbus.UInt64(value, variant_level=1))

977

978

# ApprovalDuration - property

979

@dbus_service_property(_interface, signature=u"t",

980

access=u"readwrite")

981

def ApprovalDuration_dbus_property(self, value=None):

982

if value is None: # get

983

return dbus.UInt64(self._timedelta_to_milliseconds(

984

self.approval_duration))

985

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

986

# Emit D-Bus signal

987

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

988

dbus.UInt64(value, variant_level=1))

989

990

# Name - property

991

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

992

def Name_dbus_property(self):

993

return dbus.String(self.name)

994

995

# Fingerprint - property

996

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

997

def Fingerprint_dbus_property(self):

998

return dbus.String(self.fingerprint)

999

1000

# Host - property

1001

@dbus_service_property(_interface, signature=u"s",

1002

access=u"readwrite")

1003

def Host_dbus_property(self, value=None):

1004

if value is None: # get

1005

return dbus.String(self.host)

1006

self.host = value

1007

# Emit D-Bus signal

1008

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

1009

dbus.String(value, variant_level=1))

1010

1011

# Created - property

1012

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

1013

def Created_dbus_property(self):

1014

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

1015

1016

# LastEnabled - property

1017

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

1018

def LastEnabled_dbus_property(self):

1019

if self.last_enabled is None:

1020

return dbus.String(u"")

1021

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

1022

1023

# Enabled - property

1024

@dbus_service_property(_interface, signature=u"b",

1025

access=u"readwrite")

1026

def Enabled_dbus_property(self, value=None):

1027

if value is None: # get

1028

return dbus.Boolean(self.enabled)

1029

if value:

1030

self.enable()

1031

else:

1032

self.disable()

1033

1034

# LastCheckedOK - property

1035

@dbus_service_property(_interface, signature=u"s",

1036

access=u"readwrite")

1037

def LastCheckedOK_dbus_property(self, value=None):

1038

if value is not None:

1039

self.checked_ok()

1040

return

1041

if self.last_checked_ok is None:

1042

return dbus.String(u"")

1043

return dbus.String(self._datetime_to_dbus(self

1044

.last_checked_ok))

1045

1046

# LastApprovalRequest - property

1047

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

1048

def LastApprovalRequest_dbus_property(self):

1049

if self.last_approval_request is None:

1050

return dbus.String(u"")

1051

return dbus.String(self.

1052

_datetime_to_dbus(self

1053

.last_approval_request))

1054

1055

# Timeout - property

1056

@dbus_service_property(_interface, signature=u"t",

1057

access=u"readwrite")

1058

def Timeout_dbus_property(self, value=None):

1059

if value is None: # get

1060

return dbus.UInt64(self.timeout_milliseconds())

1061

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

1062

# Emit D-Bus signal

1063

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

1064

dbus.UInt64(value, variant_level=1))

1065

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

1066

return

1067

# Reschedule timeout

1068

gobject.source_remove(self.disable_initiator_tag)

1069

self.disable_initiator_tag = None

1070

time_to_die = (self.

1071

_timedelta_to_milliseconds((self

1072

.last_checked_ok

1073

+ self.timeout)

1074

- datetime.datetime

1075

.utcnow()))

1076

if time_to_die <= 0:

1077

# The timeout has passed

1078

self.disable()

1079

else:

1080

self.disable_initiator_tag = (gobject.timeout_add

1081

(time_to_die, self.disable))

1082

1083

# Interval - property

1084

@dbus_service_property(_interface, signature=u"t",

1085

access=u"readwrite")

1086

def Interval_dbus_property(self, value=None):

1087

if value is None: # get

1088

return dbus.UInt64(self.interval_milliseconds())

1089

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

1090

# Emit D-Bus signal

1091

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

1092

dbus.UInt64(value, variant_level=1))

1093

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

1094

return

1095

# Reschedule checker run

1096

gobject.source_remove(self.checker_initiator_tag)

1097

self.checker_initiator_tag = (gobject.timeout_add

1098

(value, self.start_checker))

1099

self.start_checker() # Start one now, too

1100

1101

# Checker - property

1102

@dbus_service_property(_interface, signature=u"s",

1103

access=u"readwrite")

1104

def Checker_dbus_property(self, value=None):

1105

if value is None: # get

1106

return dbus.String(self.checker_command)

1107

self.checker_command = value

1108

# Emit D-Bus signal

1109

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

1110

dbus.String(self.checker_command,

1111

variant_level=1))

1112

1113

# CheckerRunning - property

1114

@dbus_service_property(_interface, signature=u"b",

1115

access=u"readwrite")

1116

def CheckerRunning_dbus_property(self, value=None):

1117

if value is None: # get

1118

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

1119

if value:

1120

self.start_checker()

1121

else:

1122

self.stop_checker()

1123

1124

# ObjectPath - property

1125

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

1126

def ObjectPath_dbus_property(self):

1127

return self.dbus_object_path # is already a dbus.ObjectPath

1128

1129

# Secret = property

1130

@dbus_service_property(_interface, signature=u"ay",

1131

access=u"write", byte_arrays=True)

1132

def Secret_dbus_property(self, value):

1133

self.secret = str(value)

1134

1135

747

del _interface

1136

748

1137

749

1138

class ProxyClient(object):

1139

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

1140

self._pipe = child_pipe

1141

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

1142

if not self._pipe.recv():

1143

raise KeyError()

1144

1145

def __getattribute__(self, name):

1146

if(name == '_pipe'):

1147

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

1148

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

1149

data = self._pipe.recv()

1150

if data[0] == 'data':

1151

return data[1]

1152

if data[0] == 'function':

1153

def func(*args, **kwargs):

1154

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

1155

return self._pipe.recv()[1]

1156

return func

1157

1158

def __setattr__(self, name, value):

1159

if(name == '_pipe'):

1160

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

1161

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

1162

1163

1164

750

class ClientHandler(socketserver.BaseRequestHandler, object):

1165

751

"""A class to handle client connections.

1166

752

1168

754

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

1169

755

1170

756

def handle(self):

1171

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

1172

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

1173

unicode(self.client_address))

1174

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

1175

self.server.child_pipe.fileno())

1176

757

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

758

unicode(self.client_address))

759

logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])

760

# Open IPC pipe to parent process

761

with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:

1177

762

session = (gnutls.connection

1178

763

.ClientSession(self.request,

1179

764

gnutls.connection

1180

765

.X509Credentials()))

1181

766

767

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

768

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

769

try:

770

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

771

raise RuntimeError

772

except (ValueError, IndexError, RuntimeError), error:

773

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

774

return

775

1182

776

# Note: gnutls.connection.X509Credentials is really a

1183

777

# generic GnuTLS certificate credentials object so long as

1184

778

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

1185

779

# here despite using OpenPGP certificates.

1186

780

1187

781

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

1188

782

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

1189

783

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

1195

789

(gnutls.library.functions

1196

790

.gnutls_priority_set_direct(session._c_object,

1197

791

priority, None))

1198

1199

# Start communication using the Mandos protocol

1200

# Get protocol number

1201

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

1202

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

1203

try:

1204

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

1205

raise RuntimeError

1206

except (ValueError, IndexError, RuntimeError), error:

1207

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

1208

return

1209

1210

# Start GnuTLS connection

792

1211

793

try:

1212

794

session.handshake()

1213

795

except gnutls.errors.GNUTLSError, error:

1216

798

# established. Just abandon the request.

1217

799

return

1218

800

logger.debug(u"Handshake succeeded")

1219

1220

approval_required = False

1221

801

try:

1222

try:

1223

fpr = self.fingerprint(self.peer_certificate

1224

(session))

1225

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

1226

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

1227

return

1228

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

1229

1230

try:

1231

client = ProxyClient(child_pipe, fpr,

1232

self.client_address)

1233

except KeyError:

1234

return

1235

1236

if client.approval_delay:

1237

delay = client.approval_delay

1238

client.approvals_pending += 1

1239

approval_required = True

1240

1241

while True:

1242

if not client.enabled:

1243

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

1244

client.name)

1245

if self.server.use_dbus:

1246

# Emit D-Bus signal

1247

client.Rejected("Disabled")

1248

return

1249

1250

if client._approved or not client.approval_delay:

1251

#We are approved or approval is disabled

1252

break

1253

elif client._approved is None:

1254

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

1255

client.name)

1256

if self.server.use_dbus:

1257

# Emit D-Bus signal

1258

client.NeedApproval(

1259

client.approval_delay_milliseconds(),

1260

client.approved_by_default)

1261

else:

1262

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

1263

client.name)

1264

if self.server.use_dbus:

1265

# Emit D-Bus signal

1266

client.Rejected("Denied")

1267

return

1268

1269

#wait until timeout or approved

1270

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

1271

time = datetime.datetime.now()

1272

client.changedstate.acquire()

1273

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

1274

client.changedstate.release()

1275

time2 = datetime.datetime.now()

1276

if (time2 - time) >= delay:

1277

if not client.approved_by_default:

1278

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

1279

" waiting for approval",

1280

client.name)

1281

if self.server.use_dbus:

1282

# Emit D-Bus signal

1283

client.Rejected("Approval timed out")

1284

return

1285

else:

1286

break

1287

else:

1288

delay -= time2 - time

1289

1290

sent_size = 0

1291

while sent_size < len(client.secret):

1292

try:

1293

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

1294

except (gnutls.errors.GNUTLSError), error:

1295

logger.warning("gnutls send failed")

1296

return

1297

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

1298

sent, len(client.secret)

1299

- (sent_size + sent))

1300

sent_size += sent

1301

1302

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

1303

# bump the timeout as if seen

1304

client.checked_ok()

1305

if self.server.use_dbus:

1306

# Emit D-Bus signal

1307

client.GotSecret()

802

fpr = self.fingerprint(self.peer_certificate(session))

803

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

804

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

805

session.bye()

806

return

807

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

1308

808

1309

finally:

1310

if approval_required:

1311

client.approvals_pending -= 1

1312

try:

1313

session.bye()

1314

except (gnutls.errors.GNUTLSError), error:

1315

logger.warning("GnuTLS bye failed")

809

for c in self.server.clients:

810

if c.fingerprint == fpr:

811

client = c

812

break

813

else:

814

ipc.write(u"NOTFOUND %s\n" % fpr)

815

session.bye()

816

return

817

# Have to check if client.still_valid(), since it is

818

# possible that the client timed out while establishing

819

# the GnuTLS session.

820

if not client.still_valid():

821

ipc.write(u"INVALID %s\n" % client.name)

822

session.bye()

823

return

824

ipc.write(u"SENDING %s\n" % client.name)

825

sent_size = 0

826

while sent_size < len(client.secret):

827

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

828

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

829

sent, len(client.secret)

830

- (sent_size + sent))

831

sent_size += sent

832

session.bye()

1316

833

1317

834

@staticmethod

1318

835

def peer_certificate(session):

1378

895

return hex_fpr

1379

896

1380

897

1381

class MultiprocessingMixIn(object):

1382

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

1383

def sub_process_main(self, request, address):

1384

try:

1385

self.finish_request(request, address)

1386

except:

1387

self.handle_error(request, address)

1388

self.close_request(request)

1389

1390

def process_request(self, request, address):

1391

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

1392

multiprocessing.Process(target = self.sub_process_main,

1393

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

1394

1395

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1396

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

898

class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):

899

"""Like socketserver.ForkingMixIn, but also pass a pipe."""

1397

900

def process_request(self, request, client_address):

1398

901

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

1399

902

1400

This function creates a new pipe in self.pipe

903

This function creates a new pipe in self.pipe

1401

904

"""

1402

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1403

1404

super(MultiprocessingMixInWithPipe,

905

self.pipe = os.pipe()

906

super(ForkingMixInWithPipe,

1405

907

self).process_request(request, client_address)

1406

self.child_pipe.close()

1407

self.add_pipe(parent_pipe)

1408

1409

def add_pipe(self, parent_pipe):

908

os.close(self.pipe[1]) # close write end

909

self.add_pipe(self.pipe[0])

910

def add_pipe(self, pipe):

1410

911

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

1411

pass

1412

1413

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

912

os.close(pipe)

913

914

915

class IPv6_TCPServer(ForkingMixInWithPipe,

1414

916

socketserver.TCPServer, object):

1415

917

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

1416

918

1480

982

clients: set of Client objects

1481

983

gnutls_priority GnuTLS priority string

1482

984

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

985

clients: set of Client objects

986

gnutls_priority GnuTLS priority string

987

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

1483

988

1484

989

Assumes a gobject.MainLoop event loop.

1485

990

"""

1501

1006

return socketserver.TCPServer.server_activate(self)

1502

1007

def enable(self):

1503

1008

self.enabled = True

1504

def add_pipe(self, parent_pipe):

1009

def add_pipe(self, pipe):

1505

1010

# Call "handle_ipc" for both data and EOF events

1506

gobject.io_add_watch(parent_pipe.fileno(),

1507

gobject.IO_IN | gobject.IO_HUP,

1508

functools.partial(self.handle_ipc,

1509

parent_pipe = parent_pipe))

1510

1511

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

1512

client_object=None):

1011

gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,

1012

self.handle_ipc)

1013

def handle_ipc(self, source, condition, file_objects={}):

1513

1014

condition_names = {

1514

1015

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

1515

1016

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

1524

1025

for cond, name in

1525

1026

condition_names.iteritems()

1526

1027

if cond & condition)

1527

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

1528

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

1529

return False

1530

1531

# Read a request from the child

1532

request = parent_pipe.recv()

1533

command = request[0]

1534

1535

if command == 'init':

1536

fpr = request[1]

1537

address = request[2]

1538

1539

for c in self.clients:

1540

if c.fingerprint == fpr:

1541

client = c

1542

break

1543

else:

1544

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

1545

u"dress: %s", fpr, address)

1546

if self.use_dbus:

1547

# Emit D-Bus signal

1548

mandos_dbus_service.ClientNotFound(fpr, address[0])

1549

parent_pipe.send(False)

1550

return False

1551

1552

gobject.io_add_watch(parent_pipe.fileno(),

1553

gobject.IO_IN | gobject.IO_HUP,

1554

functools.partial(self.handle_ipc,

1555

parent_pipe = parent_pipe,

1556

client_object = client))

1557

parent_pipe.send(True)

1558

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

1559

return False

1560

if command == 'funcall':

1561

funcname = request[1]

1562

args = request[2]

1563

kwargs = request[3]

1564

1565

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

1566

1567

if command == 'getattr':

1568

attrname = request[1]

1569

if callable(client_object.__getattribute__(attrname)):

1570

parent_pipe.send(('function',))

1571

else:

1572

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

1573

1574

if command == 'setattr':

1575

attrname = request[1]

1576

value = request[2]

1577

setattr(client_object, attrname, value)

1578

1028

logger.debug(u"Handling IPC: FD = %d, condition = %s", source,

1029

conditions_string)

1030

1031

# Turn the pipe file descriptor into a Python file object

1032

if source not in file_objects:

1033

file_objects[source] = os.fdopen(source, u"r", 1)

1034

1035

# Read a line from the file object

1036

cmdline = file_objects[source].readline()

1037

if not cmdline: # Empty line means end of file

1038

# close the IPC pipe

1039

file_objects[source].close()

1040

del file_objects[source]

1041

1042

# Stop calling this function

1043

return False

1044

1045

logger.debug(u"IPC command: %r", cmdline)

1046

1047

# Parse and act on command

1048

cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)

1049

1050

if cmd == u"NOTFOUND":

1051

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

1052

args)

1053

if self.use_dbus:

1054

# Emit D-Bus signal

1055

mandos_dbus_service.ClientNotFound(args)

1056

elif cmd == u"INVALID":

1057

for client in self.clients:

1058

if client.name == args:

1059

logger.warning(u"Client %s is invalid", args)

1060

if self.use_dbus:

1061

# Emit D-Bus signal

1062

client.Rejected()

1063

break

1064

else:

1065

logger.error(u"Unknown client %s is invalid", args)

1066

elif cmd == u"SENDING":

1067

for client in self.clients:

1068

if client.name == args:

1069

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

1070

client.checked_ok()

1071

if self.use_dbus:

1072

# Emit D-Bus signal

1073

client.ReceivedSecret()

1074

break

1075

else:

1076

logger.error(u"Sending secret to unknown client %s",

1077

args)

1078

else:

1079

logger.error(u"Unknown IPC command: %r", cmdline)

1080

1081

# Keep calling this function

1579

1082

return True

1580

1083

1581

1084

1611

1114

elif suffix == u"w":

1612

1115

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

1613

1116

else:

1614

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

1615

except (ValueError, IndexError), e:

1616

raise ValueError(e.message)

1117

raise ValueError

1118

except (ValueError, IndexError):

1119

raise ValueError

1617

1120

timevalue += delta

1618

1121

return timevalue

1619

1122

1632

1135

def if_nametoindex(interface):

1633

1136

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

1634

1137

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

1635

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

1138

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

1636

1139

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1637

1140

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

1638

1141

interface))

1658

1161

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

1659

1162

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

1660

1163

raise OSError(errno.ENODEV,

1661

u"%s not a character device"

1662

% os.path.devnull)

1164

u"/dev/null not a character device")

1663

1165

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

1664

1166

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

1665

1167

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

1669

1171

1670

1172

def main():

1671

1173

1672

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

1174

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

1673

1175

# Parsing of options, both command line and config file

1674

1176

1675

1177

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

1684

1186

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

1685

1187

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

1686

1188

u" terminal")

1687

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

1688

help=u"Debug level for stdout output")

1689

1189

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

1690

1190

u" priority string (see GnuTLS documentation)")

1691

1191

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

1716

1216

u"servicename": u"Mandos",

1717

1217

u"use_dbus": u"True",

1718

1218

u"use_ipv6": u"True",

1719

u"debuglevel": u"",

1720

1219

}

1721

1220

1722

1221

# Parse config file for server-global settings

1739

1238

# options, if set.

1740

1239

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

1741

1240

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

1742

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

1241

u"use_dbus", u"use_ipv6"):

1743

1242

value = getattr(options, option)

1744

1243

if value is not None:

1745

1244

server_settings[option] = value

1754

1253

1755

1254

# For convenience

1756

1255

debug = server_settings[u"debug"]

1757

debuglevel = server_settings[u"debuglevel"]

1758

1256

use_dbus = server_settings[u"use_dbus"]

1759

1257

use_ipv6 = server_settings[u"use_ipv6"]

1760

1258

1259

if not debug:

1260

syslogger.setLevel(logging.WARNING)

1261

console.setLevel(logging.WARNING)

1262

1761

1263

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

1762

1264

syslogger.setFormatter(logging.Formatter

1763

1265

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

1769

1271

u"interval": u"5m",

1770

1272

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

1771

1273

u"host": u"",

1772

u"approval_delay": u"0s",

1773

u"approval_duration": u"1s",

1774

1274

}

1775

1275

client_config = configparser.SafeConfigParser(client_defaults)

1776

1276

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

1782

1282

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

1783

1283

server_settings[u"port"]),

1784

1284

ClientHandler,

1785

interface=(server_settings[u"interface"]

1786

or None),

1285

interface=server_settings[u"interface"],

1787

1286

use_ipv6=use_ipv6,

1788

1287

gnutls_priority=

1789

1288

server_settings[u"priority"],

1790

1289

use_dbus=use_dbus)

1791

if not debug:

1792

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

1793

try:

1794

pidfile = open(pidfilename, u"w")

1795

except IOError:

1796

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

1290

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

1291

try:

1292

pidfile = open(pidfilename, u"w")

1293

except IOError:

1294

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

1797

1295

1798

1296

try:

1799

1297

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

1816

1314

if error[0] != errno.EPERM:

1817

1315

raise error

1818

1316

1819

if not debug and not debuglevel:

1820

syslogger.setLevel(logging.WARNING)

1821

console.setLevel(logging.WARNING)

1822

if debuglevel:

1823

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

1824

syslogger.setLevel(level)

1825

console.setLevel(level)

1826

1317

# Enable all possible GnuTLS debugging

1827

1318

if debug:

1828

# Enable all possible GnuTLS debugging

1829

1830

1319

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

1831

1320

# - GnuTLS manual

1832

1321

gnutls.library.functions.gnutls_global_set_log_level(11)

1837

1326

1838

1327

(gnutls.library.functions

1839

1328

.gnutls_global_set_log_function(debug_gnutls))

1840

1841

# Redirect stdin so all checkers get /dev/null

1842

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

1843

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

1844

if null > 2:

1845

os.close(null)

1846

else:

1847

# No console logging

1848

logger.removeHandler(console)

1849

1850

1329

1851

1330

global main_loop

1852

1331

# From the Avahi example code

1855

1334

bus = dbus.SystemBus()

1856

1335

# End of Avahi example code

1857

1336

if use_dbus:

1858

try:

1859

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

1860

bus, do_not_queue=True)

1861

except dbus.exceptions.NameExistsException, e:

1862

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

1863

use_dbus = False

1864

server_settings[u"use_dbus"] = False

1865

tcp_server.use_dbus = False

1337

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

1866

1338

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1867

1339

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

1868

1340

servicetype = u"_mandos._tcp",

1870

1342

if server_settings["interface"]:

1871

1343

service.interface = (if_nametoindex

1872

1344

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

1873

1874

if not debug:

1875

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

1876

daemon()

1877

1878

global multiprocessing_manager

1879

multiprocessing_manager = multiprocessing.Manager()

1880

1345

1881

1346

client_class = Client

1882

1347

if use_dbus:

1883

1348

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

1884

def client_config_items(config, section):

1885

special_settings = {

1886

"approved_by_default":

1887

lambda: config.getboolean(section,

1888

"approved_by_default"),

1889

}

1890

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

1891

try:

1892

yield (name, special_settings[name]())

1893

except KeyError:

1894

yield (name, value)

1895

1896

1349

tcp_server.clients.update(set(

1897

1350

client_class(name = section,

1898

config= dict(client_config_items(

1899

client_config, section)))

1351

config= dict(client_config.items(section)))

1900

1352

for section in client_config.sections()))

1901

1353

if not tcp_server.clients:

1902

1354

logger.warning(u"No clients defined")

1355

1356

if debug:

1357

# Redirect stdin so all checkers get /dev/null

1358

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

1359

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

1360

if null > 2:

1361

os.close(null)

1362

else:

1363

# No console logging

1364

logger.removeHandler(console)

1365

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

1366

daemon()

1367

1368

try:

1369

with closing(pidfile):

1370

pid = os.getpid()

1371

pidfile.write(str(pid) + "\n")

1372

del pidfile

1373

except IOError:

1374

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

1375

pidfilename, pid)

1376

except NameError:

1377

# "pidfile" was never created

1378

pass

1379

del pidfilename

1380

1381

def cleanup():

1382

"Cleanup function; run on exit"

1383

service.cleanup()

1903

1384

1385

while tcp_server.clients:

1386

client = tcp_server.clients.pop()

1387

client.disable_hook = None

1388

client.disable()

1389

1390

atexit.register(cleanup)

1391

1904

1392

if not debug:

1905

try:

1906

with pidfile:

1907

pid = os.getpid()

1908

pidfile.write(str(pid) + "\n")

1909

del pidfile

1910

except IOError:

1911

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

1912

pidfilename, pid)

1913

except NameError:

1914

# "pidfile" was never created

1915

pass

1916

del pidfilename

1917

1918

1393

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

1919

1920

1394

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

1921

1395

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

1922

1396

1927

1401

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

1928

1402

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

1929

1403

1930

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

1931

def ClientAdded(self, objpath):

1404

@dbus.service.signal(_interface, signature=u"oa{sv}")

1405

def ClientAdded(self, objpath, properties):

1932

1406

"D-Bus signal"

1933

1407

pass

1934

1408

1935

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

1936

def ClientNotFound(self, fingerprint, address):

1409

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

1410

def ClientNotFound(self, fingerprint):

1937

1411

"D-Bus signal"

1938

1412

pass

1939

1413

1953

1427

def GetAllClientsWithProperties(self):

1954

1428

"D-Bus method"

1955

1429

return dbus.Dictionary(

1956

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

1430

((c.dbus_object_path, c.GetAllProperties())

1957

1431

for c in tcp_server.clients),

1958

1432

signature=u"oa{sv}")

1959

1433

1965

1439

tcp_server.clients.remove(c)

1966

1440

c.remove_from_connection()

1967

1441

# Don't signal anything except ClientRemoved

1968

c.disable(quiet=True)

1442

c.disable(signal=False)

1969

1443

# Emit D-Bus signal

1970

1444

self.ClientRemoved(object_path, c.name)

1971

1445

return

1972

raise KeyError(object_path)

1446

raise KeyError

1973

1447

1974

1448

del _interface

1975

1449

1976

1450

mandos_dbus_service = MandosDBusService()

1977

1451

1978

def cleanup():

1979

"Cleanup function; run on exit"

1980

service.cleanup()

1981

1982

while tcp_server.clients:

1983

client = tcp_server.clients.pop()

1984

if use_dbus:

1985

client.remove_from_connection()

1986

client.disable_hook = None

1987

# Don't signal anything except ClientRemoved

1988

client.disable(quiet=True)

1989

if use_dbus:

1990

# Emit D-Bus signal

1991

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

1992

client.name)

1993

1994

atexit.register(cleanup)

1995

1996

1452

for client in tcp_server.clients:

1997

1453

if use_dbus:

1998

1454

# Emit D-Bus signal

1999

mandos_dbus_service.ClientAdded(client.dbus_object_path)

1455

mandos_dbus_service.ClientAdded(client.dbus_object_path,

1456

client.GetAllProperties())

2000

1457

client.enable()

2001

1458

2002

1459

tcp_server.enable()

2020

1477

service.activate()

2021

1478

except dbus.exceptions.DBusException, error:

2022

1479

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

2023

cleanup()

2024

1480

sys.exit(1)

2025

1481

# End of Avahi example code

2026

1482

2033

1489

main_loop.run()

2034

1490

except AvahiError, error:

2035

1491

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

2036

cleanup()

2037

1492

sys.exit(1)

2038

1493

except KeyboardInterrupt:

2039

1494

if debug:

2040

1495

print >> sys.stderr

2041

1496

logger.debug(u"Server received KeyboardInterrupt")

2042

1497

logger.debug(u"Server exiting")

2043

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

2044

cleanup()

2045

1498

2046

1499

if __name__ == '__main__':

2047

1500

main()