/mandos/release : revision 237.7.11

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

from contextlib import closing

58

import contextlib

59

import struct

60

import fcntl

61

import functools

62

import cPickle as pickle

63

import multiprocessing

62

64

63

65

import dbus

64

66

import dbus.service

67

69

from dbus.mainloop.glib import DBusGMainLoop

68

70

import ctypes

69

71

import ctypes.util

72

import xml.dom.minidom

73

import inspect

70

74

71

75

try:

72

76

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

77

81

SO_BINDTODEVICE = None

78

82

79

83

80

version = "1.0.8"

84

version = "1.2.3"

81

85

86

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

82

87

logger = logging.Logger(u'mandos')

83

88

syslogger = (logging.handlers.SysLogHandler

84

89

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

152

157

u" after %i retries, exiting.",

153

158

self.rename_count)

154

159

raise AvahiServiceError(u"Too many renames")

155

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

160

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

156

161

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

157

unicode(self.name))

162

self.name)

158

163

syslogger.setFormatter(logging.Formatter

159

164

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

160

165

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

161

166

% self.name))

162

167

self.remove()

163

self.add()

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)

164

174

self.rename_count += 1

165

175

def remove(self):

166

176

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

174

184

self.server.EntryGroupNew()),

175

185

avahi.DBUS_INTERFACE_ENTRY_GROUP)

176

186

self.group.connect_to_signal('StateChanged',

177

self.entry_group_state_changed)

187

self

188

.entry_group_state_changed)

178

189

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

179

190

self.name, self.type)

180

191

self.group.AddService(

188

199

self.group.Commit()

189

200

def entry_group_state_changed(self, state, error):

190

201

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

191

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

202

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

192

203

193

204

if state == avahi.ENTRY_GROUP_ESTABLISHED:

194

205

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

195

206

elif state == avahi.ENTRY_GROUP_COLLISION:

196

logger.warning(u"Zeroconf service name collision.")

207

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

197

208

self.rename()

198

209

elif state == avahi.ENTRY_GROUP_FAILURE:

199

210

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

207

218

self.group = None

208

219

def server_state_changed(self, state):

209

220

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

221

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

210

222

if state == avahi.SERVER_COLLISION:

211

223

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

212

224

self.remove()

228

240

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

229

241

230

242

Attributes:

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)

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

245

246

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

246

247

to see if the client lives.

247

248

'None' if no process is running.

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

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

253

252

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

254

253

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

255

256

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.

256

273

"""

257

274

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

258

280

@staticmethod

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

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

264

286

265

287

def timeout_milliseconds(self):

266

288

"Return the 'timeout' attribute in milliseconds"

267

return self._datetime_to_milliseconds(self.timeout)

289

return self._timedelta_to_milliseconds(self.timeout)

268

290

269

291

def interval_milliseconds(self):

270

292

"Return the 'interval' attribute in milliseconds"

271

return self._datetime_to_milliseconds(self.interval)

293

return self._timedelta_to_milliseconds(self.interval)

294

295

def approval_delay_milliseconds(self):

296

return self._timedelta_to_milliseconds(self.approval_delay)

272

297

273

298

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

274

299

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

287

312

if u"secret" in config:

288

313

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

289

314

elif u"secfile" in config:

290

with closing(open(os.path.expanduser

291

(os.path.expandvars

292

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

315

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

316

(config[u"secfile"])),

317

"rb") as secfile:

293

318

self.secret = secfile.read()

294

319

else:

295

320

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

297

322

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

298

323

self.created = datetime.datetime.utcnow()

299

324

self.enabled = False

325

self.last_approval_request = None

300

326

self.last_enabled = None

301

327

self.last_checked_ok = None

302

328

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

309

335

self.checker_command = config[u"checker"]

310

336

self.current_checker_command = None

311

337

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

312

347

348

def send_changedstate(self):

349

self.changedstate.acquire()

350

self.changedstate.notify_all()

351

self.changedstate.release()

352

313

353

def enable(self):

314

354

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

355

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

356

# Already enabled

357

return

358

self.send_changedstate()

315

359

self.last_enabled = datetime.datetime.utcnow()

316

360

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

317

361

# and every interval from then on.

318

362

self.checker_initiator_tag = (gobject.timeout_add

319

363

(self.interval_milliseconds(),

320

364

self.start_checker))

321

# Also start a new checker *right now*.

322

self.start_checker()

323

365

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

324

366

self.disable_initiator_tag = (gobject.timeout_add

325

367

(self.timeout_milliseconds(),

326

368

self.disable))

327

369

self.enabled = True

370

# Also start a new checker *right now*.

371

self.start_checker()

328

372

329

def disable(self):

373

def disable(self, quiet=True):

330

374

"""Disable this client."""

331

375

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

332

376

return False

333

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

377

if not quiet:

378

self.send_changedstate()

379

if not quiet:

380

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

334

381

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

335

382

gobject.source_remove(self.disable_initiator_tag)

336

383

self.disable_initiator_tag = None

377

424

(self.timeout_milliseconds(),

378

425

self.disable))

379

426

427

def need_approval(self):

428

self.last_approval_request = datetime.datetime.utcnow()

429

380

430

def start_checker(self):

381

431

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

382

432

388

438

# client would inevitably timeout, since no checker would get

389

439

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

390

440

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

391

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

392

# is as it should be.

441

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

442

# should be.

393

443

394

444

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

395

if self.checker is not None:

445

try:

396

446

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:

397

452

if pid:

398

453

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

399

454

gobject.source_remove(self.checker_callback_tag)

406

461

command = self.checker_command % self.host

407

462

except TypeError:

408

463

# Escape attributes for the shell

409

escaped_attrs = dict((key,

410

re.escape(unicode(str(val),

411

errors=

412

u'replace')))

413

for key, val in

414

vars(self).iteritems())

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

415

472

try:

416

473

command = self.checker_command % escaped_attrs

417

474

except TypeError, error:

455

512

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

456

513

try:

457

514

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

458

#os.sleep(0.5)

515

#time.sleep(0.5)

459

516

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

460

517

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

461

518

except OSError, error:

462

519

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

463

520

raise

464

521

self.checker = None

465

466

def still_valid(self):

467

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

468

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

469

return False

470

now = datetime.datetime.utcnow()

471

if self.last_checked_ok is None:

472

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

473

else:

474

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

475

476

477

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

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

478

713

"""A Client class using D-Bus

479

714

480

715

Attributes:

481

716

dbus_object_path: dbus.ObjectPath

482

717

bus: dbus.SystemBus()

483

718

"""

719

720

runtime_expansions = (Client.runtime_expansions

721

+ (u"dbus_object_path",))

722

484

723

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

485

724

486

725

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

726

self._approvals_pending = 0

487

727

self.bus = bus

488

728

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

489

729

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

490

730

# the D-Bus

731

client_object_name = unicode(self.name).translate(

732

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

733

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

491

734

self.dbus_object_path = (dbus.ObjectPath

492

(u"/clients/"

493

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

494

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

495

self.dbus_object_path)

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

496

754

497

755

@staticmethod

498

756

def _datetime_to_dbus(dt, variant_level=0):

505

763

r = Client.enable(self)

506

764

if oldstate != self.enabled:

507

765

# Emit D-Bus signals

508

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

766

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

509

767

dbus.Boolean(True, variant_level=1))

510

768

self.PropertyChanged(

511

dbus.String(u"last_enabled"),

769

dbus.String(u"LastEnabled"),

512

770

self._datetime_to_dbus(self.last_enabled,

513

771

variant_level=1))

514

772

return r

515

773

516

def disable(self, signal = True):

774

def disable(self, quiet = False):

517

775

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

518

r = Client.disable(self)

519

if signal and oldstate != self.enabled:

776

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

777

if not quiet and oldstate != self.enabled:

520

778

# Emit D-Bus signal

521

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

779

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

522

780

dbus.Boolean(False, variant_level=1))

523

781

return r

524

782

527

785

self.remove_from_connection()

528

786

except LookupError:

529

787

pass

530

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

531

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

788

if hasattr(DBusObjectWithProperties, u"__del__"):

789

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

532

790

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

533

791

534

792

def checker_callback(self, pid, condition, command,

536

794

self.checker_callback_tag = None

537

795

self.checker = None

538

796

# Emit D-Bus signal

539

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

797

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

540

798

dbus.Boolean(False, variant_level=1))

541

799

if os.WIFEXITED(condition):

542

800

exitstatus = os.WEXITSTATUS(condition)

557

815

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

558

816

# Emit D-Bus signal

559

817

self.PropertyChanged(

560

dbus.String(u"last_checked_ok"),

818

dbus.String(u"LastCheckedOK"),

561

819

(self._datetime_to_dbus(self.last_checked_ok,

562

820

variant_level=1)))

563

821

return r

564

822

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

565

832

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

566

833

old_checker = self.checker

567

834

if self.checker is not None:

575

842

# Emit D-Bus signal

576

843

self.CheckerStarted(self.current_checker_command)

577

844

self.PropertyChanged(

578

dbus.String(u"checker_running"),

845

dbus.String(u"CheckerRunning"),

579

846

dbus.Boolean(True, variant_level=1))

580

847

return r

581

848

584

851

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

585

852

if (old_checker is not None

586

853

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

587

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

854

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

588

855

dbus.Boolean(False, variant_level=1))

589

856

return r

590

591

## D-Bus methods & signals

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

592

871

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

593

872

594

# CheckedOK - method

595

@dbus.service.method(_interface)

596

def CheckedOK(self):

597

return self.checked_ok()

873

## Signals

598

874

599

875

# CheckerCompleted - signal

600

876

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

608

884

"D-Bus signal"

609

885

pass

610

886

611

# GetAllProperties - method

612

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

613

def GetAllProperties(self):

614

"D-Bus method"

615

return dbus.Dictionary({

616

dbus.String(u"name"):

617

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

618

dbus.String(u"fingerprint"):

619

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

620

dbus.String(u"host"):

621

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

622

dbus.String(u"created"):

623

self._datetime_to_dbus(self.created,

624

variant_level=1),

625

dbus.String(u"last_enabled"):

626

(self._datetime_to_dbus(self.last_enabled,

627

variant_level=1)

628

if self.last_enabled is not None

629

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

630

dbus.String(u"enabled"):

631

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

632

dbus.String(u"last_checked_ok"):

633

(self._datetime_to_dbus(self.last_checked_ok,

634

variant_level=1)

635

if self.last_checked_ok is not None

636

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

637

dbus.String(u"timeout"):

638

dbus.UInt64(self.timeout_milliseconds(),

639

variant_level=1),

640

dbus.String(u"interval"):

641

dbus.UInt64(self.interval_milliseconds(),

642

variant_level=1),

643

dbus.String(u"checker"):

644

dbus.String(self.checker_command,

645

variant_level=1),

646

dbus.String(u"checker_running"):

647

dbus.Boolean(self.checker is not None,

648

variant_level=1),

649

dbus.String(u"object_path"):

650

dbus.ObjectPath(self.dbus_object_path,

651

variant_level=1)

652

}, signature=u"sv")

653

654

# IsStillValid - method

655

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

656

def IsStillValid(self):

657

return self.still_valid()

658

659

887

# PropertyChanged - signal

660

888

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

661

889

def PropertyChanged(self, property, value):

662

890

"D-Bus signal"

663

891

pass

664

892

665

# ReceivedSecret - signal

893

# GotSecret - signal

666

894

@dbus.service.signal(_interface)

667

def ReceivedSecret(self):

668

"D-Bus signal"

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

"""

669

900

pass

670

901

671

902

# Rejected - signal

672

@dbus.service.signal(_interface)

673

def Rejected(self):

903

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

904

def Rejected(self, reason):

674

905

"D-Bus signal"

675

906

pass

676

907

677

# SetChecker - method

678

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

679

def SetChecker(self, checker):

680

"D-Bus setter method"

681

self.checker_command = checker

682

# Emit D-Bus signal

683

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

684

dbus.String(self.checker_command,

685

variant_level=1))

686

687

# SetHost - method

688

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

689

def SetHost(self, host):

690

"D-Bus setter method"

691

self.host = host

692

# Emit D-Bus signal

693

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

694

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

695

696

# SetInterval - method

697

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

698

def SetInterval(self, milliseconds):

699

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

700

# Emit D-Bus signal

701

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

702

(dbus.UInt64(self.interval_milliseconds(),

703

variant_level=1)))

704

705

# SetSecret - method

706

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

707

byte_arrays=True)

708

def SetSecret(self, secret):

709

"D-Bus setter method"

710

self.secret = str(secret)

711

712

# SetTimeout - method

713

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

714

def SetTimeout(self, milliseconds):

715

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

716

# Emit D-Bus signal

717

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

718

(dbus.UInt64(self.timeout_milliseconds(),

719

variant_level=1)))

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

720

925

721

926

# Enable - method

722

927

@dbus.service.method(_interface)

741

946

def StopChecker(self):

742

947

self.stop_checker()

743

948

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

744

1135

del _interface

745

1136

746

1137

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

747

1164

class ClientHandler(socketserver.BaseRequestHandler, object):

748

1165

"""A class to handle client connections.

749

1166

751

1168

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

752

1169

753

1170

def handle(self):

754

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

755

unicode(self.client_address))

756

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

757

# Open IPC pipe to parent process

758

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

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

759

1177

session = (gnutls.connection

760

1178

.ClientSession(self.request,

761

1179

gnutls.connection

762

1180

.X509Credentials()))

763

764

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

765

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

766

try:

767

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

768

raise RuntimeError

769

except (ValueError, IndexError, RuntimeError), error:

770

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

771

return

772

1181

773

1182

# Note: gnutls.connection.X509Credentials is really a

774

1183

# generic GnuTLS certificate credentials object so long as

775

1184

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

776

1185

# here despite using OpenPGP certificates.

777

1186

778

1187

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

779

1188

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

780

1189

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

786

1195

(gnutls.library.functions

787

1196

.gnutls_priority_set_direct(session._c_object,

788

1197

priority, None))

789

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

790

1211

try:

791

1212

session.handshake()

792

1213

except gnutls.errors.GNUTLSError, error:

795

1216

# established. Just abandon the request.

796

1217

return

797

1218

logger.debug(u"Handshake succeeded")

1219

1220

approval_required = False

798

1221

try:

799

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

800

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

801

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

802

session.bye()

803

return

804

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

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

805

1308

806

for c in self.server.clients:

807

if c.fingerprint == fpr:

808

client = c

809

break

810

else:

811

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

812

session.bye()

813

return

814

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

815

# possible that the client timed out while establishing

816

# the GnuTLS session.

817

if not client.still_valid():

818

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

819

session.bye()

820

return

821

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

822

sent_size = 0

823

while sent_size < len(client.secret):

824

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

825

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

826

sent, len(client.secret)

827

- (sent_size + sent))

828

sent_size += sent

829

session.bye()

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

830

1316

831

1317

@staticmethod

832

1318

def peer_certificate(session):

892

1378

return hex_fpr

893

1379

894

1380

895

class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):

896

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

897

898

Assumes a gobject.MainLoop event loop.

899

"""

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

900

1397

def process_request(self, request, client_address):

901

1398

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

902

1399

903

This function creates a new pipe in self.pipe

1400

This function creates a new pipe in self.pipe

904

1401

"""

905

self.pipe = os.pipe()

906

super(ForkingMixInWithPipe,

1402

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1403

1404

super(MultiprocessingMixInWithPipe,

907

1405

self).process_request(request, client_address)

908

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

909

# Call "handle_ipc" for both data and EOF events

910

gobject.io_add_watch(self.pipe[0],

911

gobject.IO_IN | gobject.IO_HUP,

912

self.handle_ipc)

913

def handle_ipc(self, source, condition):

1406

self.child_pipe.close()

1407

self.add_pipe(parent_pipe)

1408

1409

def add_pipe(self, parent_pipe):

914

1410

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

915

os.close(source)

916

return False

917

918

919

class IPv6_TCPServer(ForkingMixInWithPipe,

1411

pass

1412

1413

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

920

1414

socketserver.TCPServer, object):

921

1415

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

922

1416

924

1418

enabled: Boolean; whether this server is activated yet

925

1419

interface: None or a network interface name (string)

926

1420

use_ipv6: Boolean; to use IPv6 or not

927

----

928

clients: set of Client objects

929

gnutls_priority GnuTLS priority string

930

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

931

1421

"""

932

1422

def __init__(self, server_address, RequestHandlerClass,

933

1423

interface=None, use_ipv6=True):

990

1480

clients: set of Client objects

991

1481

gnutls_priority GnuTLS priority string

992

1482

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

1483

1484

Assumes a gobject.MainLoop event loop.

993

1485

"""

994

1486

def __init__(self, server_address, RequestHandlerClass,

995

1487

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

996

1488

gnutls_priority=None, use_dbus=True):

997

1489

self.enabled = False

998

1490

self.clients = clients

1491

if self.clients is None:

1492

self.clients = set()

999

1493

self.use_dbus = use_dbus

1000

1494

self.gnutls_priority = gnutls_priority

1001

1495

IPv6_TCPServer.__init__(self, server_address,

1007

1501

return socketserver.TCPServer.server_activate(self)

1008

1502

def enable(self):

1009

1503

self.enabled = True

1010

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

1504

def add_pipe(self, parent_pipe):

1505

# 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

1513

condition_names = {

1012

1514

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

1013

1515

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

1022

1524

for cond, name in

1023

1525

condition_names.iteritems()

1024

1526

if cond & condition)

1025

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

1026

conditions_string)

1027

1028

# Turn the pipe file descriptor into a Python file object

1029

if source not in file_objects:

1030

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

1031

1032

# Read a line from the file object

1033

cmdline = file_objects[source].readline()

1034

if not cmdline: # Empty line means end of file

1035

# close the IPC pipe

1036

file_objects[source].close()

1037

del file_objects[source]

1038

1039

# Stop calling this function

1040

return False

1041

1042

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

1043

1044

# Parse and act on command

1045

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

1046

1047

if cmd == u"NOTFOUND":

1048

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

1049

args)

1050

if self.use_dbus:

1051

# Emit D-Bus signal

1052

mandos_dbus_service.ClientNotFound(args)

1053

elif cmd == u"INVALID":

1054

for client in self.clients:

1055

if client.name == args:

1056

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

1057

if self.use_dbus:

1058

# Emit D-Bus signal

1059

client.Rejected()

1060

break

1061

else:

1062

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

1063

elif cmd == u"SENDING":

1064

for client in self.clients:

1065

if client.name == args:

1066

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

1067

client.checked_ok()

1068

if self.use_dbus:

1069

# Emit D-Bus signal

1070

client.ReceivedSecret()

1071

break

1072

else:

1073

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

1074

args)

1075

else:

1076

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

1077

1078

# Keep calling this function

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

1079

1579

return True

1080

1580

1081

1581

1111

1611

elif suffix == u"w":

1112

1612

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

1113

1613

else:

1114

raise ValueError

1115

except (ValueError, IndexError):

1116

raise ValueError

1614

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

1615

except (ValueError, IndexError), e:

1616

raise ValueError(e.message)

1117

1617

timevalue += delta

1118

1618

return timevalue

1119

1619

1132

1632

def if_nametoindex(interface):

1133

1633

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

1134

1634

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

1135

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

1635

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

1136

1636

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1137

1637

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

1138

1638

interface))

1158

1658

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

1159

1659

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

1160

1660

raise OSError(errno.ENODEV,

1161

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

1661

u"%s not a character device"

1662

% os.path.devnull)

1162

1663

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

1163

1664

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

1164

1665

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

1168

1669

1169

1670

def main():

1170

1671

1171

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

1672

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

1172

1673

# Parsing of options, both command line and config file

1173

1674

1174

1675

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

1183

1684

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

1184

1685

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

1185

1686

u" terminal")

1687

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

1688

help=u"Debug level for stdout output")

1186

1689

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

1187

1690

u" priority string (see GnuTLS documentation)")

1188

1691

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

1213

1716

u"servicename": u"Mandos",

1214

1717

u"use_dbus": u"True",

1215

1718

u"use_ipv6": u"True",

1719

u"debuglevel": u"",

1216

1720

}

1217

1721

1218

1722

# Parse config file for server-global settings

1235

1739

# options, if set.

1236

1740

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

1237

1741

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

1238

u"use_dbus", u"use_ipv6"):

1742

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

1239

1743

value = getattr(options, option)

1240

1744

if value is not None:

1241

1745

server_settings[option] = value

1250

1754

1251

1755

# For convenience

1252

1756

debug = server_settings[u"debug"]

1757

debuglevel = server_settings[u"debuglevel"]

1253

1758

use_dbus = server_settings[u"use_dbus"]

1254

1759

use_ipv6 = server_settings[u"use_ipv6"]

1255

1256

if not debug:

1257

syslogger.setLevel(logging.WARNING)

1258

console.setLevel(logging.WARNING)

1259

1760

1260

1761

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

1261

1762

syslogger.setFormatter(logging.Formatter

1262

1763

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

1268

1769

u"interval": u"5m",

1269

1770

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

1270

1771

u"host": u"",

1772

u"approval_delay": u"0s",

1773

u"approval_duration": u"1s",

1271

1774

}

1272

1775

client_config = configparser.SafeConfigParser(client_defaults)

1273

1776

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

1276

1779

global mandos_dbus_service

1277

1780

mandos_dbus_service = None

1278

1781

1279

clients = set()

1280

1782

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

1281

1783

server_settings[u"port"]),

1282

1784

ClientHandler,

1283

interface=server_settings[u"interface"],

1785

interface=(server_settings[u"interface"]

1786

or None),

1284

1787

use_ipv6=use_ipv6,

1285

clients=clients,

1286

1788

gnutls_priority=

1287

1789

server_settings[u"priority"],

1288

1790

use_dbus=use_dbus)

1289

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

1290

try:

1291

pidfile = open(pidfilename, u"w")

1292

except IOError:

1293

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

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)

1294

1797

1295

1798

try:

1296

1799

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

1313

1816

if error[0] != errno.EPERM:

1314

1817

raise error

1315

1818

1316

# Enable all possible GnuTLS debugging

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

1827

if debug:

1828

# Enable all possible GnuTLS debugging

1829

1318

1830

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

1319

1831

# - GnuTLS manual

1320

1832

gnutls.library.functions.gnutls_global_set_log_level(11)

1325

1837

1326

1838

(gnutls.library.functions

1327

1839

.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

# Need to fork before connecting to D-Bus

1851

if not debug:

1852

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

1853

daemon()

1328

1854

1329

1855

global main_loop

1330

1856

# From the Avahi example code

1333

1859

bus = dbus.SystemBus()

1334

1860

# End of Avahi example code

1335

1861

if use_dbus:

1336

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

1862

try:

1863

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

1864

bus, do_not_queue=True)

1865

except dbus.exceptions.NameExistsException, e:

1866

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

1867

use_dbus = False

1868

server_settings[u"use_dbus"] = False

1869

tcp_server.use_dbus = False

1337

1870

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1338

1871

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

1339

1872

servicetype = u"_mandos._tcp",

1342

1875

service.interface = (if_nametoindex

1343

1876

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

1344

1877

1878

global multiprocessing_manager

1879

multiprocessing_manager = multiprocessing.Manager()

1880

1345

1881

client_class = Client

1346

1882

if use_dbus:

1347

1883

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

1348

clients.update(set(

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

tcp_server.clients.update(set(

1349

1897

client_class(name = section,

1350

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

1898

config= dict(client_config_items(

1899

client_config, section)))

1351

1900

for section in client_config.sections()))

1352

if not clients:

1901

if not tcp_server.clients:

1353

1902

logger.warning(u"No clients defined")

1354

1355

if debug:

1356

# Redirect stdin so all checkers get /dev/null

1357

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

1358

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

1359

if null > 2:

1360

os.close(null)

1361

else:

1362

# No console logging

1363

logger.removeHandler(console)

1364

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

1365

daemon()

1366

1367

try:

1368

with closing(pidfile):

1369

pid = os.getpid()

1370

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

1371

del pidfile

1372

except IOError:

1373

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

1374

pidfilename, pid)

1375

except NameError:

1376

# "pidfile" was never created

1377

pass

1378

del pidfilename

1379

1380

def cleanup():

1381

"Cleanup function; run on exit"

1382

service.cleanup()

1383

1903

1384

while clients:

1385

client = clients.pop()

1386

client.disable_hook = None

1387

client.disable()

1388

1389

atexit.register(cleanup)

1390

1391

1904

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

1392

1918

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

1919

1393

1920

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

1394

1921

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

1395

1922

1400

1927

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

1401

1928

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

1402

1929

1403

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

1404

def ClientAdded(self, objpath, properties):

1930

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

1931

def ClientAdded(self, objpath):

1405

1932

"D-Bus signal"

1406

1933

pass

1407

1934

1408

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

1409

def ClientNotFound(self, fingerprint):

1935

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

1936

def ClientNotFound(self, fingerprint, address):

1410

1937

"D-Bus signal"

1411

1938

pass

1412

1939

1418

1945

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

1419

1946

def GetAllClients(self):

1420

1947

"D-Bus method"

1421

return dbus.Array(c.dbus_object_path for c in clients)

1948

return dbus.Array(c.dbus_object_path

1949

for c in tcp_server.clients)

1422

1950

1423

1951

@dbus.service.method(_interface,

1424

1952

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

1425

1953

def GetAllClientsWithProperties(self):

1426

1954

"D-Bus method"

1427

1955

return dbus.Dictionary(

1428

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

1429

for c in clients),

1956

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

1957

for c in tcp_server.clients),

1430

1958

signature=u"oa{sv}")

1431

1959

1432

1960

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

1433

1961

def RemoveClient(self, object_path):

1434

1962

"D-Bus method"

1435

for c in clients:

1963

for c in tcp_server.clients:

1436

1964

if c.dbus_object_path == object_path:

1437

clients.remove(c)

1965

tcp_server.clients.remove(c)

1438

1966

c.remove_from_connection()

1439

1967

# Don't signal anything except ClientRemoved

1440

c.disable(signal=False)

1968

c.disable(quiet=True)

1441

1969

# Emit D-Bus signal

1442

1970

self.ClientRemoved(object_path, c.name)

1443

1971

return

1444

raise KeyError

1972

raise KeyError(object_path)

1445

1973

1446

1974

del _interface

1447

1975

1448

1976

mandos_dbus_service = MandosDBusService()

1449

1977

1450

for client in clients:

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

for client in tcp_server.clients:

1451

1997

if use_dbus:

1452

1998

# Emit D-Bus signal

1453

mandos_dbus_service.ClientAdded(client.dbus_object_path,

1454

client.GetAllProperties())

1999

mandos_dbus_service.ClientAdded(client.dbus_object_path)

1455

2000

client.enable()

1456

2001

1457

2002

tcp_server.enable()

1475

2020

service.activate()

1476

2021

except dbus.exceptions.DBusException, error:

1477

2022

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

2023

cleanup()

1478

2024

sys.exit(1)

1479

2025

# End of Avahi example code

1480

2026

1487

2033

main_loop.run()

1488

2034

except AvahiError, error:

1489

2035

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

2036

cleanup()

1490

2037

sys.exit(1)

1491

2038

except KeyboardInterrupt:

1492

2039

if debug:

1493

2040

print >> sys.stderr

1494

2041

logger.debug(u"Server received KeyboardInterrupt")

1495

2042

logger.debug(u"Server exiting")

2043

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

2044

cleanup()

1496

2045

1497

2046

if __name__ == '__main__':

1498

2047

main()