/mandos/trunk : revision 423

6

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

7

# service publisher, downloaded from

8

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

9

# methods "add" and "remove" in the "AvahiService" class, the

10

# "server_state_changed" and "entry_group_state_changed" functions,

11

# and some lines in "main".

9

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

10

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

11

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

12

#

13

# Everything else is

14

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

61

64

62

65

import dbus

63

66

import dbus.service

66

69

from dbus.mainloop.glib import DBusGMainLoop

67

70

import ctypes

68

71

import ctypes.util

72

import xml.dom.minidom

73

import inspect

69

74

70

75

try:

71

76

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

73

78

try:

74

79

from IN import SO_BINDTODEVICE

75

80

except ImportError:

76

# From /usr/include/asm/socket.h

77

SO_BINDTODEVICE = 25

78

79

80

version = "1.0.8"

81

SO_BINDTODEVICE = None

82

83

84

version = "1.0.14"

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,

124

129

max_renames: integer; maximum number of renames

125

130

rename_count: integer; counter so we only rename after collisions

126

131

a sensible number of times

132

group: D-Bus Entry Group

133

server: D-Bus Server

134

bus: dbus.SystemBus()

127

135

"""

128

136

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

129

137

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

130

138

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

131

protocol = avahi.PROTO_UNSPEC):

139

protocol = avahi.PROTO_UNSPEC, bus = None):

132

140

self.interface = interface

133

141

self.name = name

134

142

self.type = servicetype

139

147

self.rename_count = 0

140

148

self.max_renames = max_renames

141

149

self.protocol = protocol

150

self.group = None # our entry group

151

self.server = None

152

self.bus = bus

142

153

def rename(self):

143

154

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

144

155

if self.rename_count >= self.max_renames:

146

157

u" after %i retries, exiting.",

147

158

self.rename_count)

148

159

raise AvahiServiceError(u"Too many renames")

149

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

160

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

150

161

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

151

162

self.name)

152

163

syslogger.setFormatter(logging.Formatter

154

165

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

155

166

% self.name))

156

167

self.remove()

157

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)

158

174

self.rename_count += 1

159

175

def remove(self):

160

176

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

161

if group is not None:

162

group.Reset()

177

if self.group is not None:

178

self.group.Reset()

163

179

def add(self):

164

180

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

165

global group

166

if group is None:

167

group = dbus.Interface(bus.get_object

168

(avahi.DBUS_NAME,

169

server.EntryGroupNew()),

170

avahi.DBUS_INTERFACE_ENTRY_GROUP)

171

group.connect_to_signal('StateChanged',

172

entry_group_state_changed)

181

if self.group is None:

182

self.group = dbus.Interface(

183

self.bus.get_object(avahi.DBUS_NAME,

184

self.server.EntryGroupNew()),

185

avahi.DBUS_INTERFACE_ENTRY_GROUP)

186

self.group.connect_to_signal('StateChanged',

187

self

188

.entry_group_state_changed)

173

189

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

174

service.name, service.type)

175

group.AddService(

176

self.interface, # interface

177

self.protocol, # protocol

178

dbus.UInt32(0), # flags

179

self.name, self.type,

180

self.domain, self.host,

181

dbus.UInt16(self.port),

182

avahi.string_array_to_txt_array(self.TXT))

183

group.Commit()

184

185

# From the Avahi example code:

186

group = None # our entry group

187

# End of Avahi example code

188

189

190

def _datetime_to_dbus(dt, variant_level=0):

191

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

192

return dbus.String(dt.isoformat(), variant_level=variant_level)

190

self.name, self.type)

191

self.group.AddService(

192

self.interface,

193

self.protocol,

194

dbus.UInt32(0), # flags

195

self.name, self.type,

196

self.domain, self.host,

197

dbus.UInt16(self.port),

198

avahi.string_array_to_txt_array(self.TXT))

199

self.group.Commit()

200

def entry_group_state_changed(self, state, error):

201

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

202

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

203

204

if state == avahi.ENTRY_GROUP_ESTABLISHED:

205

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

206

elif state == avahi.ENTRY_GROUP_COLLISION:

207

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

208

self.rename()

209

elif state == avahi.ENTRY_GROUP_FAILURE:

210

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

211

unicode(error))

212

raise AvahiGroupError(u"State changed: %s"

213

% unicode(error))

214

def cleanup(self):

215

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

216

if self.group is not None:

217

self.group.Free()

218

self.group = None

219

def server_state_changed(self, state):

220

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

221

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

222

if state == avahi.SERVER_COLLISION:

223

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

224

self.remove()

225

elif state == avahi.SERVER_RUNNING:

226

self.add()

227

def activate(self):

228

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

229

if self.server is None:

230

self.server = dbus.Interface(

231

self.bus.get_object(avahi.DBUS_NAME,

232

avahi.DBUS_PATH_SERVER),

233

avahi.DBUS_INTERFACE_SERVER)

234

self.server.connect_to_signal(u"StateChanged",

235

self.server_state_changed)

236

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

193

237

194

238

195

239

class Client(object):

207

251

enabled: bool()

208

252

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

209

253

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

210

until this client is invalid

254

until this client is disabled

211

255

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

212

256

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

213

257

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

214

258

to see if the client lives.

215

259

'None' if no process is running.

216

260

checker_initiator_tag: a gobject event source tag, or None

217

disable_initiator_tag: - '' -

261

disable_initiator_tag: - '' -

218

262

checker_callback_tag: - '' -

219

263

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

220

264

client lives. %() expansions are done at

221

265

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

222

266

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

223

267

current_checker_command: string; current running checker_command

268

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

269

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

270

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

224

271

"""

225

272

226

273

@staticmethod

227

def _datetime_to_milliseconds(dt):

228

"Convert a datetime.datetime() to milliseconds"

229

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

230

+ (dt.seconds * 1000)

231

+ (dt.microseconds // 1000))

274

def _timedelta_to_milliseconds(td):

275

"Convert a datetime.timedelta() to milliseconds"

276

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

277

+ (td.seconds * 1000)

278

+ (td.microseconds // 1000))

232

279

233

280

def timeout_milliseconds(self):

234

281

"Return the 'timeout' attribute in milliseconds"

235

return self._datetime_to_milliseconds(self.timeout)

282

return self._timedelta_to_milliseconds(self.timeout)

236

283

237

284

def interval_milliseconds(self):

238

285

"Return the 'interval' attribute in milliseconds"

239

return self._datetime_to_milliseconds(self.interval)

286

return self._timedelta_to_milliseconds(self.interval)

287

288

def approval_delay_milliseconds(self):

289

return self._timedelta_to_milliseconds(self.approval_delay)

240

290

241

291

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

242

292

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

255

305

if u"secret" in config:

256

306

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

257

307

elif u"secfile" in config:

258

with closing(open(os.path.expanduser

259

(os.path.expandvars

260

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

308

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

309

(config[u"secfile"])),

310

"rb") as secfile:

261

311

self.secret = secfile.read()

262

312

else:

263

313

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

277

327

self.checker_command = config[u"checker"]

278

328

self.current_checker_command = None

279

329

self.last_connect = None

330

self._approved = None

331

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

332

True)

333

self.approvals_pending = 0

334

self.approval_delay = string_to_delta(

335

config[u"approval_delay"])

336

self.approval_duration = string_to_delta(

337

config[u"approval_duration"])

338

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

280

339

340

def send_changedstate(self):

341

self.changedstate.acquire()

342

self.changedstate.notify_all()

343

self.changedstate.release()

344

281

345

def enable(self):

282

346

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

347

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

348

# Already enabled

349

return

350

self.send_changedstate()

283

351

self.last_enabled = datetime.datetime.utcnow()

284

352

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

285

353

# and every interval from then on.

286

354

self.checker_initiator_tag = (gobject.timeout_add

287

355

(self.interval_milliseconds(),

288

356

self.start_checker))

289

# Also start a new checker *right now*.

290

self.start_checker()

291

357

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

292

358

self.disable_initiator_tag = (gobject.timeout_add

293

359

(self.timeout_milliseconds(),

294

360

self.disable))

295

361

self.enabled = True

362

# Also start a new checker *right now*.

363

self.start_checker()

296

364

297

def disable(self):

365

def disable(self, quiet=True):

298

366

"""Disable this client."""

299

367

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

300

368

return False

301

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

369

if not quiet:

370

self.send_changedstate()

371

if not quiet:

372

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

302

373

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

303

374

gobject.source_remove(self.disable_initiator_tag)

304

375

self.disable_initiator_tag = None

356

427

# client would inevitably timeout, since no checker would get

357

428

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

358

429

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

359

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

360

# is as it should be.

430

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

431

# should be.

361

432

362

433

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

363

if self.checker is not None:

434

try:

364

435

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

436

except (AttributeError, OSError), error:

437

if (isinstance(error, OSError)

438

and error.errno != errno.ECHILD):

439

raise error

440

else:

365

441

if pid:

366

442

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

367

443

gobject.source_remove(self.checker_callback_tag)

423

499

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

424

500

try:

425

501

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

426

#os.sleep(0.5)

502

#time.sleep(0.5)

427

503

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

428

504

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

429

505

except OSError, error:

430

506

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

431

507

raise

432

508

self.checker = None

433

434

def still_valid(self):

435

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

436

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

437

return False

438

now = datetime.datetime.utcnow()

439

if self.last_checked_ok is None:

440

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

441

else:

442

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

443

444

445

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

509

510

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

511

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

512

"""Decorators for marking methods of a DBusObjectWithProperties to

513

become properties on the D-Bus.

514

515

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

516

and with one argument by "Set".

517

518

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

519

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

520

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

521

"""

522

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

523

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

524

if byte_arrays and signature != u"ay":

525

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

526

u" signature %r" % signature)

527

def decorator(func):

528

func._dbus_is_property = True

529

func._dbus_interface = dbus_interface

530

func._dbus_signature = signature

531

func._dbus_access = access

532

func._dbus_name = func.__name__

533

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

534

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

535

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

536

return func

537

return decorator

538

539

540

class DBusPropertyException(dbus.exceptions.DBusException):

541

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

542

"""

543

def __unicode__(self):

544

return unicode(str(self))

545

546

547

class DBusPropertyAccessException(DBusPropertyException):

548

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

549

"""

550

pass

551

552

553

class DBusPropertyNotFound(DBusPropertyException):

554

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

555

"""

556

pass

557

558

559

class DBusObjectWithProperties(dbus.service.Object):

560

"""A D-Bus object with properties.

561

562

Classes inheriting from this can use the dbus_service_property

563

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

564

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

565

"""

566

567

@staticmethod

568

def _is_dbus_property(obj):

569

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

570

571

def _get_all_dbus_properties(self):

572

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

573

"""

574

return ((prop._dbus_name, prop)

575

for name, prop in

576

inspect.getmembers(self, self._is_dbus_property))

577

578

def _get_dbus_property(self, interface_name, property_name):

579

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

580

property with the specified name and interface.

581

"""

582

for name in (property_name,

583

property_name + u"_dbus_property"):

584

prop = getattr(self, name, None)

585

if (prop is None

586

or not self._is_dbus_property(prop)

587

or prop._dbus_name != property_name

588

or (interface_name and prop._dbus_interface

589

and interface_name != prop._dbus_interface)):

590

continue

591

return prop

592

# No such property

593

raise DBusPropertyNotFound(self.dbus_object_path + u":"

594

+ interface_name + u"."

595

+ property_name)

596

597

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

598

out_signature=u"v")

599

def Get(self, interface_name, property_name):

600

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

601

"""

602

prop = self._get_dbus_property(interface_name, property_name)

603

if prop._dbus_access == u"write":

604

raise DBusPropertyAccessException(property_name)

605

value = prop()

606

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

607

return value

608

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

609

610

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

611

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

612

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

613

"""

614

prop = self._get_dbus_property(interface_name, property_name)

615

if prop._dbus_access == u"read":

616

raise DBusPropertyAccessException(property_name)

617

if prop._dbus_get_args_options[u"byte_arrays"]:

618

# The byte_arrays option is not supported yet on

619

# signatures other than "ay".

620

if prop._dbus_signature != u"ay":

621

raise ValueError

622

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

623

for byte in value))

624

prop(value)

625

626

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

627

out_signature=u"a{sv}")

628

def GetAll(self, interface_name):

629

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

630

standard.

631

632

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

633

"""

634

all = {}

635

for name, prop in self._get_all_dbus_properties():

636

if (interface_name

637

and interface_name != prop._dbus_interface):

638

# Interface non-empty but did not match

639

continue

640

# Ignore write-only properties

641

if prop._dbus_access == u"write":

642

continue

643

value = prop()

644

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

645

all[name] = value

646

continue

647

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

648

value.variant_level+1)

649

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

650

651

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

652

out_signature=u"s",

653

path_keyword='object_path',

654

connection_keyword='connection')

655

def Introspect(self, object_path, connection):

656

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

657

"""

658

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

659

connection)

660

try:

661

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

662

def make_tag(document, name, prop):

663

e = document.createElement(u"property")

664

e.setAttribute(u"name", name)

665

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

666

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

667

return e

668

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

669

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

670

for name, prop

671

in self._get_all_dbus_properties()

672

if prop._dbus_interface

673

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

674

if_tag.appendChild(tag)

675

# Add the names to the return values for the

676

# "org.freedesktop.DBus.Properties" methods

677

if (if_tag.getAttribute(u"name")

678

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

679

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

680

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

681

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

682

if (arg.getAttribute(u"direction")

683

== u"out"):

684

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

685

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

686

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

687

if (arg.getAttribute(u"direction")

688

== u"out"):

689

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

690

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

691

document.unlink()

692

except (AttributeError, xml.dom.DOMException,

693

xml.parsers.expat.ExpatError), error:

694

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

695

error)

696

return xmlstring

697

698

699

class ClientDBus(Client, DBusObjectWithProperties):

446

700

"""A Client class using D-Bus

447

701

448

702

Attributes:

449

dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus

703

dbus_object_path: dbus.ObjectPath

704

bus: dbus.SystemBus()

450

705

"""

451

706

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

452

707

453

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

708

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

709

self._approvals_pending = 0

710

self.bus = bus

454

711

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

455

712

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

456

713

# the D-Bus

457

714

self.dbus_object_path = (dbus.ObjectPath

458

715

(u"/clients/"

459

716

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

460

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

461

self.dbus_object_path)

717

DBusObjectWithProperties.__init__(self, self.bus,

718

self.dbus_object_path)

719

720

def _get_approvals_pending(self):

721

return self._approvals_pending

722

def _set_approvals_pending(self, value):

723

old_value = self._approvals_pending

724

self._approvals_pending = value

725

bval = bool(value)

726

if (hasattr(self, "dbus_object_path")

727

and bval is not bool(old_value)):

728

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

729

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

730

dbus_bool)

731

732

approvals_pending = property(_get_approvals_pending,

733

_set_approvals_pending)

734

del _get_approvals_pending, _set_approvals_pending

735

736

@staticmethod

737

def _datetime_to_dbus(dt, variant_level=0):

738

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

739

return dbus.String(dt.isoformat(),

740

variant_level=variant_level)

741

462

742

def enable(self):

463

743

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

464

744

r = Client.enable(self)

465

745

if oldstate != self.enabled:

466

746

# Emit D-Bus signals

467

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

747

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

468

748

dbus.Boolean(True, variant_level=1))

469

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

470

(_datetime_to_dbus(self.last_enabled,

471

variant_level=1)))

749

self.PropertyChanged(

750

dbus.String(u"LastEnabled"),

751

self._datetime_to_dbus(self.last_enabled,

752

variant_level=1))

472

753

return r

473

754

474

def disable(self, signal = True):

755

def disable(self, quiet = False):

475

756

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

476

r = Client.disable(self)

477

if signal and oldstate != self.enabled:

757

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

758

if not quiet and oldstate != self.enabled:

478

759

# Emit D-Bus signal

479

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

760

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

480

761

dbus.Boolean(False, variant_level=1))

481

762

return r

482

763

485

766

self.remove_from_connection()

486

767

except LookupError:

487

768

pass

488

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

489

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

769

if hasattr(DBusObjectWithProperties, u"__del__"):

770

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

490

771

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

491

772

492

773

def checker_callback(self, pid, condition, command,

494

775

self.checker_callback_tag = None

495

776

self.checker = None

496

777

# Emit D-Bus signal

497

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

778

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

498

779

dbus.Boolean(False, variant_level=1))

499

780

if os.WIFEXITED(condition):

500

781

exitstatus = os.WEXITSTATUS(condition)

515

796

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

516

797

# Emit D-Bus signal

517

798

self.PropertyChanged(

518

dbus.String(u"last_checked_ok"),

519

(_datetime_to_dbus(self.last_checked_ok,

520

variant_level=1)))

799

dbus.String(u"LastCheckedOK"),

800

(self._datetime_to_dbus(self.last_checked_ok,

801

variant_level=1)))

521

802

return r

522

803

523

804

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

533

814

# Emit D-Bus signal

534

815

self.CheckerStarted(self.current_checker_command)

535

816

self.PropertyChanged(

536

dbus.String(u"checker_running"),

817

dbus.String(u"CheckerRunning"),

537

818

dbus.Boolean(True, variant_level=1))

538

819

return r

539

820

542

823

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

543

824

if (old_checker is not None

544

825

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

545

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

826

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

546

827

dbus.Boolean(False, variant_level=1))

547

828

return r

548

549

## D-Bus methods & signals

829

830

def _reset_approved(self):

831

self._approved = None

832

return False

833

834

def approve(self, value=True):

835

self.send_changedstate()

836

self._approved = value

837

gobject.timeout_add(self._timedelta_to_milliseconds

838

(self.approval_duration),

839

self._reset_approved)

840

841

842

## D-Bus methods, signals & properties

550

843

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

551

844

552

# CheckedOK - method

553

@dbus.service.method(_interface)

554

def CheckedOK(self):

555

return self.checked_ok()

845

## Signals

556

846

557

847

# CheckerCompleted - signal

558

848

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

566

856

"D-Bus signal"

567

857

pass

568

858

569

# GetAllProperties - method

570

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

571

def GetAllProperties(self):

572

"D-Bus method"

573

return dbus.Dictionary({

574

dbus.String(u"name"):

575

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

576

dbus.String(u"fingerprint"):

577

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

578

dbus.String(u"host"):

579

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

580

dbus.String(u"created"):

581

_datetime_to_dbus(self.created, variant_level=1),

582

dbus.String(u"last_enabled"):

583

(_datetime_to_dbus(self.last_enabled,

584

variant_level=1)

585

if self.last_enabled is not None

586

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

587

dbus.String(u"enabled"):

588

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

589

dbus.String(u"last_checked_ok"):

590

(_datetime_to_dbus(self.last_checked_ok,

591

variant_level=1)

592

if self.last_checked_ok is not None

593

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

594

dbus.String(u"timeout"):

595

dbus.UInt64(self.timeout_milliseconds(),

596

variant_level=1),

597

dbus.String(u"interval"):

598

dbus.UInt64(self.interval_milliseconds(),

599

variant_level=1),

600

dbus.String(u"checker"):

601

dbus.String(self.checker_command,

602

variant_level=1),

603

dbus.String(u"checker_running"):

604

dbus.Boolean(self.checker is not None,

605

variant_level=1),

606

dbus.String(u"object_path"):

607

dbus.ObjectPath(self.dbus_object_path,

608

variant_level=1)

609

}, signature=u"sv")

610

611

# IsStillValid - method

612

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

613

def IsStillValid(self):

614

return self.still_valid()

615

616

859

# PropertyChanged - signal

617

860

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

618

861

def PropertyChanged(self, property, value):

619

862

"D-Bus signal"

620

863

pass

621

864

622

# ReceivedSecret - signal

865

# GotSecret - signal

623

866

@dbus.service.signal(_interface)

624

def ReceivedSecret(self):

625

"D-Bus signal"

867

def GotSecret(self):

868

"""D-Bus signal

869

Is sent after a successful transfer of secret from the Mandos

870

server to mandos-client

871

"""

626

872

pass

627

873

628

874

# Rejected - signal

629

@dbus.service.signal(_interface)

630

def Rejected(self):

631

"D-Bus signal"

632

pass

633

634

# SetChecker - method

635

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

636

def SetChecker(self, checker):

637

"D-Bus setter method"

638

self.checker_command = checker

639

# Emit D-Bus signal

640

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

641

dbus.String(self.checker_command,

642

variant_level=1))

643

644

# SetHost - method

645

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

646

def SetHost(self, host):

647

"D-Bus setter method"

648

self.host = host

649

# Emit D-Bus signal

650

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

651

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

652

653

# SetInterval - method

654

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

655

def SetInterval(self, milliseconds):

656

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

657

# Emit D-Bus signal

658

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

659

(dbus.UInt64(self.interval_milliseconds(),

660

variant_level=1)))

661

662

# SetSecret - method

663

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

664

byte_arrays=True)

665

def SetSecret(self, secret):

666

"D-Bus setter method"

667

self.secret = str(secret)

668

669

# SetTimeout - method

670

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

671

def SetTimeout(self, milliseconds):

672

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

673

# Emit D-Bus signal

674

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

675

(dbus.UInt64(self.timeout_milliseconds(),

676

variant_level=1)))

875

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

876

def Rejected(self, reason):

877

"D-Bus signal"

878

pass

879

880

# NeedApproval - signal

881

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

882

def NeedApproval(self, timeout, default):

883

"D-Bus signal"

884

pass

885

886

## Methods

887

888

# Approve - method

889

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

890

def Approve(self, value):

891

self.approve(value)

892

893

# CheckedOK - method

894

@dbus.service.method(_interface)

895

def CheckedOK(self):

896

return self.checked_ok()

677

897

678

898

# Enable - method

679

899

@dbus.service.method(_interface)

698

918

def StopChecker(self):

699

919

self.stop_checker()

700

920

921

## Properties

922

923

# ApprovalPending - property

924

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

925

def ApprovalPending_dbus_property(self):

926

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

927

928

# ApprovedByDefault - property

929

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

930

access=u"readwrite")

931

def ApprovedByDefault_dbus_property(self, value=None):

932

if value is None: # get

933

return dbus.Boolean(self.approved_by_default)

934

self.approved_by_default = bool(value)

935

# Emit D-Bus signal

936

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

937

dbus.Boolean(value, variant_level=1))

938

939

# ApprovalDelay - property

940

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

941

access=u"readwrite")

942

def ApprovalDelay_dbus_property(self, value=None):

943

if value is None: # get

944

return dbus.UInt64(self.approval_delay_milliseconds())

945

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

946

# Emit D-Bus signal

947

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

948

dbus.UInt64(value, variant_level=1))

949

950

# ApprovalDuration - property

951

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

952

access=u"readwrite")

953

def ApprovalDuration_dbus_property(self, value=None):

954

if value is None: # get

955

return dbus.UInt64(self._timedelta_to_milliseconds(

956

self.approval_duration))

957

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

958

# Emit D-Bus signal

959

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

960

dbus.UInt64(value, variant_level=1))

961

962

# Name - property

963

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

964

def Name_dbus_property(self):

965

return dbus.String(self.name)

966

967

# Fingerprint - property

968

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

969

def Fingerprint_dbus_property(self):

970

return dbus.String(self.fingerprint)

971

972

# Host - property

973

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

974

access=u"readwrite")

975

def Host_dbus_property(self, value=None):

976

if value is None: # get

977

return dbus.String(self.host)

978

self.host = value

979

# Emit D-Bus signal

980

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

981

dbus.String(value, variant_level=1))

982

983

# Created - property

984

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

985

def Created_dbus_property(self):

986

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

987

988

# LastEnabled - property

989

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

990

def LastEnabled_dbus_property(self):

991

if self.last_enabled is None:

992

return dbus.String(u"")

993

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

994

995

# Enabled - property

996

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

997

access=u"readwrite")

998

def Enabled_dbus_property(self, value=None):

999

if value is None: # get

1000

return dbus.Boolean(self.enabled)

1001

if value:

1002

self.enable()

1003

else:

1004

self.disable()

1005

1006

# LastCheckedOK - property

1007

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

1008

access=u"readwrite")

1009

def LastCheckedOK_dbus_property(self, value=None):

1010

if value is not None:

1011

self.checked_ok()

1012

return

1013

if self.last_checked_ok is None:

1014

return dbus.String(u"")

1015

return dbus.String(self._datetime_to_dbus(self

1016

.last_checked_ok))

1017

1018

# Timeout - property

1019

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

1020

access=u"readwrite")

1021

def Timeout_dbus_property(self, value=None):

1022

if value is None: # get

1023

return dbus.UInt64(self.timeout_milliseconds())

1024

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

1025

# Emit D-Bus signal

1026

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

1027

dbus.UInt64(value, variant_level=1))

1028

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

1029

return

1030

# Reschedule timeout

1031

gobject.source_remove(self.disable_initiator_tag)

1032

self.disable_initiator_tag = None

1033

time_to_die = (self.

1034

_timedelta_to_milliseconds((self

1035

.last_checked_ok

1036

+ self.timeout)

1037

- datetime.datetime

1038

.utcnow()))

1039

if time_to_die <= 0:

1040

# The timeout has passed

1041

self.disable()

1042

else:

1043

self.disable_initiator_tag = (gobject.timeout_add

1044

(time_to_die, self.disable))

1045

1046

# Interval - property

1047

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

1048

access=u"readwrite")

1049

def Interval_dbus_property(self, value=None):

1050

if value is None: # get

1051

return dbus.UInt64(self.interval_milliseconds())

1052

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

1053

# Emit D-Bus signal

1054

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

1055

dbus.UInt64(value, variant_level=1))

1056

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

1057

return

1058

# Reschedule checker run

1059

gobject.source_remove(self.checker_initiator_tag)

1060

self.checker_initiator_tag = (gobject.timeout_add

1061

(value, self.start_checker))

1062

self.start_checker() # Start one now, too

1063

1064

# Checker - property

1065

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

1066

access=u"readwrite")

1067

def Checker_dbus_property(self, value=None):

1068

if value is None: # get

1069

return dbus.String(self.checker_command)

1070

self.checker_command = value

1071

# Emit D-Bus signal

1072

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

1073

dbus.String(self.checker_command,

1074

variant_level=1))

1075

1076

# CheckerRunning - property

1077

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

1078

access=u"readwrite")

1079

def CheckerRunning_dbus_property(self, value=None):

1080

if value is None: # get

1081

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

1082

if value:

1083

self.start_checker()

1084

else:

1085

self.stop_checker()

1086

1087

# ObjectPath - property

1088

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

1089

def ObjectPath_dbus_property(self):

1090

return self.dbus_object_path # is already a dbus.ObjectPath

1091

1092

# Secret = property

1093

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

1094

access=u"write", byte_arrays=True)

1095

def Secret_dbus_property(self, value):

1096

self.secret = str(value)

1097

701

1098

del _interface

702

1099

703

1100

1101

class ProxyClient(object):

1102

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

1103

self._pipe = child_pipe

1104

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

1105

if not self._pipe.recv():

1106

raise KeyError()

1107

1108

def __getattribute__(self, name):

1109

if(name == '_pipe'):

1110

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

1111

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

1112

data = self._pipe.recv()

1113

if data[0] == 'data':

1114

return data[1]

1115

if data[0] == 'function':

1116

def func(*args, **kwargs):

1117

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

1118

return self._pipe.recv()[1]

1119

return func

1120

1121

def __setattr__(self, name, value):

1122

if(name == '_pipe'):

1123

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

1124

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

1125

1126

704

1127

class ClientHandler(socketserver.BaseRequestHandler, object):

705

1128

"""A class to handle client connections.

706

1129

708

1131

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

709

1132

710

1133

def handle(self):

711

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

712

unicode(self.client_address))

713

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

714

# Open IPC pipe to parent process

715

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

1134

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

1135

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

1136

unicode(self.client_address))

1137

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

1138

self.server.child_pipe.fileno())

1139

716

1140

session = (gnutls.connection

717

1141

.ClientSession(self.request,

718

1142

gnutls.connection

719

1143

.X509Credentials()))

720

721

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

722

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

723

try:

724

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

725

raise RuntimeError

726

except (ValueError, IndexError, RuntimeError), error:

727

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

728

return

729

1144

730

1145

# Note: gnutls.connection.X509Credentials is really a

731

1146

# generic GnuTLS certificate credentials object so long as

732

1147

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

733

1148

# here despite using OpenPGP certificates.

734

1149

735

1150

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

736

1151

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

737

1152

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

743

1158

(gnutls.library.functions

744

1159

.gnutls_priority_set_direct(session._c_object,

745

1160

priority, None))

746

1161

1162

# Start communication using the Mandos protocol

1163

# Get protocol number

1164

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

1165

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

1166

try:

1167

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

1168

raise RuntimeError

1169

except (ValueError, IndexError, RuntimeError), error:

1170

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

1171

return

1172

1173

# Start GnuTLS connection

747

1174

try:

748

1175

session.handshake()

749

1176

except gnutls.errors.GNUTLSError, error:

752

1179

# established. Just abandon the request.

753

1180

return

754

1181

logger.debug(u"Handshake succeeded")

1182

1183

approval_required = False

755

1184

try:

756

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

757

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

758

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

759

session.bye()

760

return

761

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

1185

try:

1186

fpr = self.fingerprint(self.peer_certificate

1187

(session))

1188

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

1189

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

1190

return

1191

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

1192

1193

try:

1194

client = ProxyClient(child_pipe, fpr,

1195

self.client_address)

1196

except KeyError:

1197

return

1198

1199

if client.approval_delay:

1200

delay = client.approval_delay

1201

client.approvals_pending += 1

1202

approval_required = True

1203

1204

while True:

1205

if not client.enabled:

1206

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

1207

client.name)

1208

if self.server.use_dbus:

1209

# Emit D-Bus signal

1210

client.Rejected("Disabled")

1211

return

1212

1213

if client._approved or not client.approval_delay:

1214

#We are approved or approval is disabled

1215

break

1216

elif client._approved is None:

1217

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

1218

client.name)

1219

if self.server.use_dbus:

1220

# Emit D-Bus signal

1221

client.NeedApproval(

1222

client.approval_delay_milliseconds(),

1223

client.approved_by_default)

1224

else:

1225

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

1226

client.name)

1227

if self.server.use_dbus:

1228

# Emit D-Bus signal

1229

client.Rejected("Denied")

1230

return

1231

1232

#wait until timeout or approved

1233

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

1234

time = datetime.datetime.now()

1235

client.changedstate.acquire()

1236

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

1237

client.changedstate.release()

1238

time2 = datetime.datetime.now()

1239

if (time2 - time) >= delay:

1240

if not client.approved_by_default:

1241

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

1242

" waiting for approval",

1243

client.name)

1244

if self.server.use_dbus:

1245

# Emit D-Bus signal

1246

client.Rejected("Timed out")

1247

return

1248

else:

1249

break

1250

else:

1251

delay -= time2 - time

1252

1253

sent_size = 0

1254

while sent_size < len(client.secret):

1255

try:

1256

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

1257

except (gnutls.errors.GNUTLSError), error:

1258

logger.warning("gnutls send failed")

1259

return

1260

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

1261

sent, len(client.secret)

1262

- (sent_size + sent))

1263

sent_size += sent

1264

1265

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

1266

# bump the timeout as if seen

1267

client.checked_ok()

1268

if self.server.use_dbus:

1269

# Emit D-Bus signal

1270

client.GotSecret()

762

1271

763

for c in self.server.clients:

764

if c.fingerprint == fpr:

765

client = c

766

break

767

else:

768

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

769

session.bye()

770

return

771

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

772

# possible that the client timed out while establishing

773

# the GnuTLS session.

774

if not client.still_valid():

775

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

776

session.bye()

777

return

778

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

779

sent_size = 0

780

while sent_size < len(client.secret):

781

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

782

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

783

sent, len(client.secret)

784

- (sent_size + sent))

785

sent_size += sent

786

session.bye()

1272

finally:

1273

if approval_required:

1274

client.approvals_pending -= 1

1275

try:

1276

session.bye()

1277

except (gnutls.errors.GNUTLSError), error:

1278

logger.warning("GnuTLS bye failed")

787

1279

788

1280

@staticmethod

789

1281

def peer_certificate(session):

849

1341

return hex_fpr

850

1342

851

1343

852

class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):

853

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

854

855

Assumes a gobject.MainLoop event loop.

856

"""

1344

class MultiprocessingMixIn(object):

1345

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

1346

def sub_process_main(self, request, address):

1347

try:

1348

self.finish_request(request, address)

1349

except:

1350

self.handle_error(request, address)

1351

self.close_request(request)

1352

1353

def process_request(self, request, address):

1354

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

1355

multiprocessing.Process(target = self.sub_process_main,

1356

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

1357

1358

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1359

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

857

1360

def process_request(self, request, client_address):

858

1361

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

859

1362

860

This function creates a new pipe in self.pipe

1363

This function creates a new pipe in self.pipe

861

1364

"""

862

self.pipe = os.pipe()

863

super(ForkingMixInWithPipe,

1365

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1366

1367

super(MultiprocessingMixInWithPipe,

864

1368

self).process_request(request, client_address)

865

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

866

# Call "handle_ipc" for both data and EOF events

867

gobject.io_add_watch(self.pipe[0],

868

gobject.IO_IN | gobject.IO_HUP,

869

self.handle_ipc)

870

def handle_ipc(source, condition):

1369

self.child_pipe.close()

1370

self.add_pipe(parent_pipe)

1371

1372

def add_pipe(self, parent_pipe):

871

1373

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

872

os.close(source)

873

return False

874

875

876

class IPv6_TCPServer(ForkingMixInWithPipe,

1374

pass

1375

1376

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

877

1377

socketserver.TCPServer, object):

878

1378

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

879

1379

881

1381

enabled: Boolean; whether this server is activated yet

882

1382

interface: None or a network interface name (string)

883

1383

use_ipv6: Boolean; to use IPv6 or not

884

----

885

clients: set of Client objects

886

gnutls_priority GnuTLS priority string

887

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

888

1384

"""

889

1385

def __init__(self, server_address, RequestHandlerClass,

890

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

891

gnutls_priority=None, use_dbus=True):

892

self.enabled = False

1386

interface=None, use_ipv6=True):

893

1387

self.interface = interface

894

1388

if use_ipv6:

895

1389

self.address_family = socket.AF_INET6

896

self.clients = clients

897

self.use_dbus = use_dbus

898

self.gnutls_priority = gnutls_priority

899

1390

socketserver.TCPServer.__init__(self, server_address,

900

1391

RequestHandlerClass)

901

1392

def server_bind(self):

903

1394

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

904

1395

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

905

1396

if self.interface is not None:

906

try:

907

self.socket.setsockopt(socket.SOL_SOCKET,

908

SO_BINDTODEVICE,

909

str(self.interface + u'\0'))

910

except socket.error, error:

911

if error[0] == errno.EPERM:

912

logger.error(u"No permission to"

913

u" bind to interface %s",

914

self.interface)

915

else:

916

raise

1397

if SO_BINDTODEVICE is None:

1398

logger.error(u"SO_BINDTODEVICE does not exist;"

1399

u" cannot bind to interface %s",

1400

self.interface)

1401

else:

1402

try:

1403

self.socket.setsockopt(socket.SOL_SOCKET,

1404

SO_BINDTODEVICE,

1405

str(self.interface

1406

+ u'\0'))

1407

except socket.error, error:

1408

if error[0] == errno.EPERM:

1409

logger.error(u"No permission to"

1410

u" bind to interface %s",

1411

self.interface)

1412

elif error[0] == errno.ENOPROTOOPT:

1413

logger.error(u"SO_BINDTODEVICE not available;"

1414

u" cannot bind to interface %s",

1415

self.interface)

1416

else:

1417

raise

917

1418

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

918

1419

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

919

1420

if not self.server_address[0]:

933

1434

# if_nametoindex

934

1435

# (self.interface))

935

1436

return socketserver.TCPServer.server_bind(self)

1437

1438

1439

class MandosServer(IPv6_TCPServer):

1440

"""Mandos server.

1441

1442

Attributes:

1443

clients: set of Client objects

1444

gnutls_priority GnuTLS priority string

1445

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

1446

1447

Assumes a gobject.MainLoop event loop.

1448

"""

1449

def __init__(self, server_address, RequestHandlerClass,

1450

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

1451

gnutls_priority=None, use_dbus=True):

1452

self.enabled = False

1453

self.clients = clients

1454

if self.clients is None:

1455

self.clients = set()

1456

self.use_dbus = use_dbus

1457

self.gnutls_priority = gnutls_priority

1458

IPv6_TCPServer.__init__(self, server_address,

1459

RequestHandlerClass,

1460

interface = interface,

1461

use_ipv6 = use_ipv6)

936

1462

def server_activate(self):

937

1463

if self.enabled:

938

1464

return socketserver.TCPServer.server_activate(self)

939

1465

def enable(self):

940

1466

self.enabled = True

941

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

1467

def add_pipe(self, parent_pipe):

1468

# Call "handle_ipc" for both data and EOF events

1469

gobject.io_add_watch(parent_pipe.fileno(),

1470

gobject.IO_IN | gobject.IO_HUP,

1471

functools.partial(self.handle_ipc,

1472

parent_pipe = parent_pipe))

1473

1474

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

1475

client_object=None):

942

1476

condition_names = {

943

1477

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

944

1478

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

955

1489

if cond & condition)

956

1490

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

957

1491

conditions_string)

958

959

# Turn the pipe file descriptor into a Python file object

960

if source not in file_objects:

961

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

962

963

# Read a line from the file object

964

cmdline = file_objects[source].readline()

965

if not cmdline: # Empty line means end of file

966

# close the IPC pipe

967

file_objects[source].close()

968

del file_objects[source]

969

970

# Stop calling this function

971

return False

972

973

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

974

975

# Parse and act on command

976

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

977

978

if cmd == u"NOTFOUND":

979

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

980

args)

981

if self.use_dbus:

982

# Emit D-Bus signal

983

mandos_dbus_service.ClientNotFound(args)

984

elif cmd == u"INVALID":

985

for client in self.clients:

986

if client.name == args:

987

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

988

if self.use_dbus:

989

# Emit D-Bus signal

990

client.Rejected()

991

break

992

else:

993

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

994

elif cmd == u"SENDING":

995

for client in self.clients:

996

if client.name == args:

997

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

998

client.checked_ok()

999

if self.use_dbus:

1000

# Emit D-Bus signal

1001

client.ReceivedSecret()

1002

break

1003

else:

1004

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

1005

args)

1006

else:

1007

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

1008

1009

# Keep calling this function

1492

1493

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

1494

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

1495

return False

1496

1497

# Read a request from the child

1498

request = parent_pipe.recv()

1499

logger.debug(u"IPC request: %s", repr(request))

1500

command = request[0]

1501

1502

if command == 'init':

1503

fpr = request[1]

1504

address = request[2]

1505

1506

for c in self.clients:

1507

if c.fingerprint == fpr:

1508

client = c

1509

break

1510

else:

1511

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

1512

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

1513

if self.use_dbus:

1514

# Emit D-Bus signal

1515

mandos_dbus_service.ClientNotFound(fpr, address)

1516

parent_pipe.send(False)

1517

return False

1518

1519

gobject.io_add_watch(parent_pipe.fileno(),

1520

gobject.IO_IN | gobject.IO_HUP,

1521

functools.partial(self.handle_ipc,

1522

parent_pipe = parent_pipe,

1523

client_object = client))

1524

parent_pipe.send(True)

1525

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

1526

return False

1527

if command == 'funcall':

1528

funcname = request[1]

1529

args = request[2]

1530

kwargs = request[3]

1531

1532

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

1533

1534

if command == 'getattr':

1535

attrname = request[1]

1536

if callable(client_object.__getattribute__(attrname)):

1537

parent_pipe.send(('function',))

1538

else:

1539

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

1540

1541

if command == 'setattr':

1542

attrname = request[1]

1543

value = request[2]

1544

setattr(client_object, attrname, value)

1545

1010

1546

return True

1011

1547

1012

1548

1042

1578

elif suffix == u"w":

1043

1579

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

1044

1580

else:

1045

raise ValueError

1046

except (ValueError, IndexError):

1047

raise ValueError

1581

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

1582

except (ValueError, IndexError), e:

1583

raise ValueError(e.message)

1048

1584

timevalue += delta

1049

1585

return timevalue

1050

1586

1051

1587

1052

def server_state_changed(state):

1053

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

1054

if state == avahi.SERVER_COLLISION:

1055

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

1056

service.remove()

1057

elif state == avahi.SERVER_RUNNING:

1058

service.add()

1059

1060

1061

def entry_group_state_changed(state, error):

1062

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

1063

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

1064

1065

if state == avahi.ENTRY_GROUP_ESTABLISHED:

1066

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

1067

elif state == avahi.ENTRY_GROUP_COLLISION:

1068

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

1069

service.rename()

1070

elif state == avahi.ENTRY_GROUP_FAILURE:

1071

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

1072

unicode(error))

1073

raise AvahiGroupError(u"State changed: %s" % unicode(error))

1074

1075

1588

def if_nametoindex(interface):

1076

1589

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

1077

1590

1086

1599

def if_nametoindex(interface):

1087

1600

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

1088

1601

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

1089

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

1602

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

1090

1603

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1091

1604

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

1092

1605

interface))

1112

1625

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

1113

1626

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

1114

1627

raise OSError(errno.ENODEV,

1115

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

1628

u"%s not a character device"

1629

% os.path.devnull)

1116

1630

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

1117

1631

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

1118

1632

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

1122

1636

1123

1637

def main():

1124

1638

1125

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

1639

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

1126

1640

# Parsing of options, both command line and config file

1127

1641

1128

1642

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

1137

1651

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

1138

1652

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

1139

1653

u" terminal")

1654

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

1655

help=u"Debug level for stdout output")

1140

1656

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

1141

1657

u" priority string (see GnuTLS documentation)")

1142

1658

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

1167

1683

u"servicename": u"Mandos",

1168

1684

u"use_dbus": u"True",

1169

1685

u"use_ipv6": u"True",

1686

u"debuglevel": u"",

1170

1687

}

1171

1688

1172

1689

# Parse config file for server-global settings

1189

1706

# options, if set.

1190

1707

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

1191

1708

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

1192

u"use_dbus", u"use_ipv6"):

1709

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

1193

1710

value = getattr(options, option)

1194

1711

if value is not None:

1195

1712

server_settings[option] = value

1204

1721

1205

1722

# For convenience

1206

1723

debug = server_settings[u"debug"]

1724

debuglevel = server_settings[u"debuglevel"]

1207

1725

use_dbus = server_settings[u"use_dbus"]

1208

1726

use_ipv6 = server_settings[u"use_ipv6"]

1209

1210

if not debug:

1211

syslogger.setLevel(logging.WARNING)

1212

console.setLevel(logging.WARNING)

1213

1727

1214

1728

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

1215

1729

syslogger.setFormatter(logging.Formatter

1216

1730

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

1222

1736

u"interval": u"5m",

1223

1737

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

1224

1738

u"host": u"",

1739

u"approval_delay": u"0s",

1740

u"approval_duration": u"1s",

1225

1741

}

1226

1742

client_config = configparser.SafeConfigParser(client_defaults)

1227

1743

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

1230

1746

global mandos_dbus_service

1231

1747

mandos_dbus_service = None

1232

1748

1233

clients = set()

1234

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

1235

server_settings[u"port"]),

1236

ClientHandler,

1237

interface=

1238

server_settings[u"interface"],

1239

use_ipv6=use_ipv6,

1240

clients=clients,

1241

gnutls_priority=

1242

server_settings[u"priority"],

1243

use_dbus=use_dbus)

1749

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

1750

server_settings[u"port"]),

1751

ClientHandler,

1752

interface=(server_settings[u"interface"]

1753

or None),

1754

use_ipv6=use_ipv6,

1755

gnutls_priority=

1756

server_settings[u"priority"],

1757

use_dbus=use_dbus)

1244

1758

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

1245

1759

try:

1246

1760

pidfile = open(pidfilename, u"w")

1268

1782

if error[0] != errno.EPERM:

1269

1783

raise error

1270

1784

1271

# Enable all possible GnuTLS debugging

1785

if not debug and not debuglevel:

1786

syslogger.setLevel(logging.WARNING)

1787

console.setLevel(logging.WARNING)

1788

if debuglevel:

1789

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

1790

syslogger.setLevel(level)

1791

console.setLevel(level)

1792

1272

1793

if debug:

1794

# Enable all possible GnuTLS debugging

1795

1273

1796

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

1274

1797

# - GnuTLS manual

1275

1798

gnutls.library.functions.gnutls_global_set_log_level(11)

1280

1803

1281

1804

(gnutls.library.functions

1282

1805

.gnutls_global_set_log_function(debug_gnutls))

1283

1284

global service

1806

1807

# Redirect stdin so all checkers get /dev/null

1808

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

1809

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

1810

if null > 2:

1811

os.close(null)

1812

else:

1813

# No console logging

1814

logger.removeHandler(console)

1815

1816

1817

global main_loop

1818

# From the Avahi example code

1819

DBusGMainLoop(set_as_default=True )

1820

main_loop = gobject.MainLoop()

1821

bus = dbus.SystemBus()

1822

# End of Avahi example code

1823

if use_dbus:

1824

try:

1825

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

1826

bus, do_not_queue=True)

1827

except dbus.exceptions.NameExistsException, e:

1828

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

1829

use_dbus = False

1830

server_settings[u"use_dbus"] = False

1831

tcp_server.use_dbus = False

1285

1832

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1286

1833

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

1287

1834

servicetype = u"_mandos._tcp",

1288

protocol = protocol)

1835

protocol = protocol, bus = bus)

1289

1836

if server_settings["interface"]:

1290

1837

service.interface = (if_nametoindex

1291

1838

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

1292

1293

global main_loop

1294

global bus

1295

global server

1296

# From the Avahi example code

1297

DBusGMainLoop(set_as_default=True )

1298

main_loop = gobject.MainLoop()

1299

bus = dbus.SystemBus()

1300

server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,

1301

avahi.DBUS_PATH_SERVER),

1302

avahi.DBUS_INTERFACE_SERVER)

1303

# End of Avahi example code

1304

if use_dbus:

1305

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

1839

1840

if not debug:

1841

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

1842

daemon()

1843

1844

global multiprocessing_manager

1845

multiprocessing_manager = multiprocessing.Manager()

1306

1846

1307

1847

client_class = Client

1308

1848

if use_dbus:

1309

client_class = ClientDBus

1310

clients.update(set(

1849

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

1850

def client_config_items(config, section):

1851

special_settings = {

1852

"approved_by_default":

1853

lambda: config.getboolean(section,

1854

"approved_by_default"),

1855

}

1856

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

1857

try:

1858

yield (name, special_settings[name]())

1859

except KeyError:

1860

yield (name, value)

1861

1862

tcp_server.clients.update(set(

1311

1863

client_class(name = section,

1312

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

1864

config= dict(client_config_items(

1865

client_config, section)))

1313

1866

for section in client_config.sections()))

1314

if not clients:

1867

if not tcp_server.clients:

1315

1868

logger.warning(u"No clients defined")

1316

1317

if debug:

1318

# Redirect stdin so all checkers get /dev/null

1319

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

1320

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

1321

if null > 2:

1322

os.close(null)

1323

else:

1324

# No console logging

1325

logger.removeHandler(console)

1326

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

1327

daemon()

1328

1869

1329

1870

try:

1330

with closing(pidfile):

1871

with pidfile:

1331

1872

pid = os.getpid()

1332

1873

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

1333

1874

del pidfile

1339

1880

pass

1340

1881

del pidfilename

1341

1882

1342

def cleanup():

1343

"Cleanup function; run on exit"

1344

global group

1345

# From the Avahi example code

1346

if not group is None:

1347

group.Free()

1348

group = None

1349

# End of Avahi example code

1350

1351

while clients:

1352

client = clients.pop()

1353

client.disable_hook = None

1354

client.disable()

1355

1356

atexit.register(cleanup)

1357

1358

1883

if not debug:

1359

1884

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

1360

1885

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

1367

1892

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

1368

1893

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

1369

1894

1370

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

1371

def ClientAdded(self, objpath, properties):

1895

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

1896

def ClientAdded(self, objpath):

1372

1897

"D-Bus signal"

1373

1898

pass

1374

1899

1375

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

1376

def ClientNotFound(self, fingerprint):

1900

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

1901

def ClientNotFound(self, fingerprint, address):

1377

1902

"D-Bus signal"

1378

1903

pass

1379

1904

1385

1910

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

1386

1911

def GetAllClients(self):

1387

1912

"D-Bus method"

1388

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

1913

return dbus.Array(c.dbus_object_path

1914

for c in tcp_server.clients)

1389

1915

1390

1916

@dbus.service.method(_interface,

1391

1917

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

1392

1918

def GetAllClientsWithProperties(self):

1393

1919

"D-Bus method"

1394

1920

return dbus.Dictionary(

1395

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

1396

for c in clients),

1921

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

1922

for c in tcp_server.clients),

1397

1923

signature=u"oa{sv}")

1398

1924

1399

1925

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

1400

1926

def RemoveClient(self, object_path):

1401

1927

"D-Bus method"

1402

for c in clients:

1928

for c in tcp_server.clients:

1403

1929

if c.dbus_object_path == object_path:

1404

clients.remove(c)

1930

tcp_server.clients.remove(c)

1405

1931

c.remove_from_connection()

1406

1932

# Don't signal anything except ClientRemoved

1407

c.disable(signal=False)

1933

c.disable(quiet=True)

1408

1934

# Emit D-Bus signal

1409

1935

self.ClientRemoved(object_path, c.name)

1410

1936

return

1411

raise KeyError

1937

raise KeyError(object_path)

1412

1938

1413

1939

del _interface

1414

1940

1415

1941

mandos_dbus_service = MandosDBusService()

1416

1942

1417

for client in clients:

1943

def cleanup():

1944

"Cleanup function; run on exit"

1945

service.cleanup()

1946

1947

while tcp_server.clients:

1948

client = tcp_server.clients.pop()

1949

if use_dbus:

1950

client.remove_from_connection()

1951

client.disable_hook = None

1952

# Don't signal anything except ClientRemoved

1953

client.disable(quiet=True)

1954

if use_dbus:

1955

# Emit D-Bus signal

1956

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

1957

client.name)

1958

1959

atexit.register(cleanup)

1960

1961

for client in tcp_server.clients:

1418

1962

if use_dbus:

1419

1963

# Emit D-Bus signal

1420

mandos_dbus_service.ClientAdded(client.dbus_object_path,

1421

client.GetAllProperties())

1964

mandos_dbus_service.ClientAdded(client.dbus_object_path)

1422

1965

client.enable()

1423

1966

1424

1967

tcp_server.enable()

1438

1981

1439

1982

try:

1440

1983

# From the Avahi example code

1441

server.connect_to_signal(u"StateChanged", server_state_changed)

1442

1984

try:

1443

server_state_changed(server.GetState())

1985

service.activate()

1444

1986

except dbus.exceptions.DBusException, error:

1445

1987

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

1988

cleanup()

1446

1989

sys.exit(1)

1447

1990

# End of Avahi example code

1448

1991

1455

1998

main_loop.run()

1456

1999

except AvahiError, error:

1457

2000

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

2001

cleanup()

1458

2002

sys.exit(1)

1459

2003

except KeyboardInterrupt:

1460

2004

if debug:

1461

2005

print >> sys.stderr

1462

2006

logger.debug(u"Server received KeyboardInterrupt")

1463

2007

logger.debug(u"Server exiting")

2008

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

2009

cleanup()

1464

2010

1465

2011

if __name__ == '__main__':

1466

2012

main()