/mandos/trunk : revision 24.2.1

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

#

4

# Mandos server - give out binary blobs to connecting clients.

5

#

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

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

19

# the Free Software Foundation, either version 3 of the License, or

20

# (at your option) any later version.

21

#

22

# This program is distributed in the hope that it will be useful,

23

# but WITHOUT ANY WARRANTY; without even the implied warranty of

24

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

25

# GNU General Public License for more details.

26

#

27

# You should have received a copy of the GNU General Public License

28

# along with this program. If not, see

29

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

30

#

31

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

32

#

33

34

from __future__ import division, with_statement, absolute_import

35

36

import SocketServer as socketserver

37

import socket

38

import optparse

39

import datetime

40

import errno

41

import gnutls.crypto

42

import gnutls.connection

43

import gnutls.errors

44

import gnutls.library.functions

45

import gnutls.library.constants

46

import gnutls.library.types

47

import ConfigParser as configparser

48

import sys

49

import re

50

import os

51

import signal

52

import subprocess

53

import atexit

54

import stat

55

import logging

56

import logging.handlers

57

import pwd

58

import contextlib

59

import struct

60

import fcntl

61

import functools

62

import cPickle as pickle

63

import multiprocessing

64

65

import dbus

66

import dbus.service

67

import gobject

68

import avahi

69

from dbus.mainloop.glib import DBusGMainLoop

70

import ctypes

71

import ctypes.util

72

import xml.dom.minidom

73

import inspect

74

75

try:

76

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

77

except AttributeError:

78

try:

79

from IN import SO_BINDTODEVICE

80

except ImportError:

81

SO_BINDTODEVICE = None

82

83

84

version = "1.0.14"

85

86

logger = logging.Logger(u'mandos')

87

syslogger = (logging.handlers.SysLogHandler

88

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

89

address = "/dev/log"))

90

syslogger.setFormatter(logging.Formatter

91

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

92

u' %(message)s'))

93

logger.addHandler(syslogger)

94

95

console = logging.StreamHandler()

96

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

97

u' %(levelname)s:'

98

u' %(message)s'))

99

logger.addHandler(console)

100

101

multiprocessing_manager = multiprocessing.Manager()

102

103

class AvahiError(Exception):

104

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

105

self.value = value

106

super(AvahiError, self).__init__(value, *args, **kwargs)

107

def __unicode__(self):

108

return unicode(repr(self.value))

109

110

class AvahiServiceError(AvahiError):

111

pass

112

113

class AvahiGroupError(AvahiError):

114

pass

115

116

117

class AvahiService(object):

118

"""An Avahi (Zeroconf) service.

119

120

Attributes:

121

interface: integer; avahi.IF_UNSPEC or an interface index.

122

Used to optionally bind to the specified interface.

123

name: string; Example: u'Mandos'

124

type: string; Example: u'_mandos._tcp'.

125

See <http://www.dns-sd.org/ServiceTypes.html>

126

port: integer; what port to announce

127

TXT: list of strings; TXT record for the service

128

domain: string; Domain to publish on, default to .local if empty.

129

host: string; Host to publish records for, default is localhost

130

max_renames: integer; maximum number of renames

131

rename_count: integer; counter so we only rename after collisions

132

a sensible number of times

133

group: D-Bus Entry Group

134

server: D-Bus Server

135

bus: dbus.SystemBus()

136

"""

137

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

138

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

139

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

140

protocol = avahi.PROTO_UNSPEC, bus = None):

141

self.interface = interface

142

self.name = name

143

self.type = servicetype

144

self.port = port

145

self.TXT = TXT if TXT is not None else []

146

self.domain = domain

147

self.host = host

148

self.rename_count = 0

149

self.max_renames = max_renames

150

self.protocol = protocol

151

self.group = None # our entry group

152

self.server = None

153

self.bus = bus

154

def rename(self):

155

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

156

if self.rename_count >= self.max_renames:

157

logger.critical(u"No suitable Zeroconf service name found"

158

u" after %i retries, exiting.",

159

self.rename_count)

160

raise AvahiServiceError(u"Too many renames")

161

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

162

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

163

unicode(self.name))

164

syslogger.setFormatter(logging.Formatter

165

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

166

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

167

% self.name))

168

self.remove()

169

self.add()

170

self.rename_count += 1

171

def remove(self):

172

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

173

if self.group is not None:

174

self.group.Reset()

175

def add(self):

176

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

177

if self.group is None:

178

self.group = dbus.Interface(

179

self.bus.get_object(avahi.DBUS_NAME,

180

self.server.EntryGroupNew()),

181

avahi.DBUS_INTERFACE_ENTRY_GROUP)

182

self.group.connect_to_signal('StateChanged',

183

self

184

.entry_group_state_changed)

185

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

186

self.name, self.type)

187

self.group.AddService(

188

self.interface,

189

self.protocol,

190

dbus.UInt32(0), # flags

191

self.name, self.type,

192

self.domain, self.host,

193

dbus.UInt16(self.port),

194

avahi.string_array_to_txt_array(self.TXT))

195

self.group.Commit()

196

def entry_group_state_changed(self, state, error):

197

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

198

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

199

200

if state == avahi.ENTRY_GROUP_ESTABLISHED:

201

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

202

elif state == avahi.ENTRY_GROUP_COLLISION:

203

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

204

self.rename()

205

elif state == avahi.ENTRY_GROUP_FAILURE:

206

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

207

unicode(error))

208

raise AvahiGroupError(u"State changed: %s"

209

% unicode(error))

210

def cleanup(self):

211

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

212

if self.group is not None:

213

self.group.Free()

214

self.group = None

215

def server_state_changed(self, state):

216

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

217

if state == avahi.SERVER_COLLISION:

218

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

219

self.remove()

220

elif state == avahi.SERVER_RUNNING:

221

self.add()

222

def activate(self):

223

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

224

if self.server is None:

225

self.server = dbus.Interface(

226

self.bus.get_object(avahi.DBUS_NAME,

227

avahi.DBUS_PATH_SERVER),

228

avahi.DBUS_INTERFACE_SERVER)

229

self.server.connect_to_signal(u"StateChanged",

230

self.server_state_changed)

231

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

232

233

234

class Client(object):

235

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

236

237

Attributes:

238

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

239

D-Bus identifiers

240

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

241

uniquely identify the client

242

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

243

host: string; available for use by the checker command

244

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

245

last_enabled: datetime.datetime(); (UTC)

246

enabled: bool()

247

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

248

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

249

until this client is disabled

250

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

251

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

252

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

253

to see if the client lives.

254

'None' if no process is running.

255

checker_initiator_tag: a gobject event source tag, or None

256

disable_initiator_tag: - '' -

257

checker_callback_tag: - '' -

258

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

259

client lives. %() expansions are done at

260

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

261

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

262

current_checker_command: string; current running checker_command

263

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

264

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

265

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

266

"""

267

268

@staticmethod

269

def _timedelta_to_milliseconds(td):

270

"Convert a datetime.timedelta() to milliseconds"

271

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

272

+ (td.seconds * 1000)

273

+ (td.microseconds // 1000))

274

275

def timeout_milliseconds(self):

276

"Return the 'timeout' attribute in milliseconds"

277

return self._timedelta_to_milliseconds(self.timeout)

278

279

def interval_milliseconds(self):

280

"Return the 'interval' attribute in milliseconds"

281

return self._timedelta_to_milliseconds(self.interval)

282

283

def approved_delay_milliseconds(self):

284

return self._timedelta_to_milliseconds(self.approved_delay)

285

286

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

287

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

288

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

289

attribute."""

290

self.name = name

291

if config is None:

292

config = {}

293

logger.debug(u"Creating client %r", self.name)

294

# Uppercase and remove spaces from fingerprint for later

295

# comparison purposes with return value from the fingerprint()

296

# function

297

self.fingerprint = (config[u"fingerprint"].upper()

298

.replace(u" ", u""))

299

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

300

if u"secret" in config:

301

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

302

elif u"secfile" in config:

303

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

304

(config[u"secfile"])),

305

"rb") as secfile:

306

self.secret = secfile.read()

307

else:

308

#XXX Need to allow secret on demand!

309

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

310

% self.name)

311

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

312

self.created = datetime.datetime.utcnow()

313

self.enabled = False

314

self.last_enabled = None

315

self.last_checked_ok = None

316

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

317

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

318

self.disable_hook = disable_hook

319

self.checker = None

320

self.checker_initiator_tag = None

321

self.disable_initiator_tag = None

322

self.checker_callback_tag = None

323

self.checker_command = config[u"checker"]

324

self.current_checker_command = None

325

self.last_connect = None

326

self.approvals_pending = 0

327

self._approved = None

328

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

329

True)

330

self.approved_delay = string_to_delta(

331

config[u"approved_delay"])

332

self.approved_duration = string_to_delta(

333

config[u"approved_duration"])

334

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

335

336

def send_changedstate(self):

337

self.changedstate.acquire()

338

self.changedstate.notify_all()

339

self.changedstate.release()

340

341

def enable(self):

342

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

343

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

344

# Already enabled

345

return

346

self.send_changedstate()

347

self.last_enabled = datetime.datetime.utcnow()

348

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

349

# and every interval from then on.

350

self.checker_initiator_tag = (gobject.timeout_add

351

(self.interval_milliseconds(),

352

self.start_checker))

353

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

354

self.disable_initiator_tag = (gobject.timeout_add

355

(self.timeout_milliseconds(),

356

self.disable))

357

self.enabled = True

358

# Also start a new checker *right now*.

359

self.start_checker()

360

361

def disable(self, quiet=True):

362

"""Disable this client."""

363

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

364

return False

365

if not quiet:

366

self.send_changedstate()

367

if not quiet:

368

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

369

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

370

gobject.source_remove(self.disable_initiator_tag)

371

self.disable_initiator_tag = None

372

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

373

gobject.source_remove(self.checker_initiator_tag)

374

self.checker_initiator_tag = None

375

self.stop_checker()

376

if self.disable_hook:

377

self.disable_hook(self)

378

self.enabled = False

379

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

380

return False

381

382

def __del__(self):

383

self.disable_hook = None

384

self.disable()

385

386

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

387

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

388

self.checker_callback_tag = None

389

self.checker = None

390

if os.WIFEXITED(condition):

391

exitstatus = os.WEXITSTATUS(condition)

392

if exitstatus == 0:

393

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

394

vars(self))

395

self.checked_ok()

396

else:

397

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

398

vars(self))

399

else:

400

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

401

vars(self))

402

403

def checked_ok(self):

404

"""Bump up the timeout for this client.

405

406

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

407

alive and well.

408

"""

409

self.last_checked_ok = datetime.datetime.utcnow()

410

gobject.source_remove(self.disable_initiator_tag)

411

self.disable_initiator_tag = (gobject.timeout_add

412

(self.timeout_milliseconds(),

413

self.disable))

414

415

def start_checker(self):

416

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

417

418

If a checker already exists, leave it running and do

419

nothing."""

420

# The reason for not killing a running checker is that if we

421

# did that, then if a checker (for some reason) started

422

# running slowly and taking more than 'interval' time, the

423

# client would inevitably timeout, since no checker would get

424

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

425

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

426

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

427

# should be.

428

429

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

430

try:

431

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

432

except (AttributeError, OSError), error:

433

if (isinstance(error, OSError)

434

and error.errno != errno.ECHILD):

435

raise error

436

else:

437

if pid:

438

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

439

gobject.source_remove(self.checker_callback_tag)

440

self.checker_callback(pid, status,

441

self.current_checker_command)

442

# Start a new checker if needed

443

if self.checker is None:

444

try:

445

# In case checker_command has exactly one % operator

446

command = self.checker_command % self.host

447

except TypeError:

448

# Escape attributes for the shell

449

escaped_attrs = dict((key,

450

re.escape(unicode(str(val),

451

errors=

452

u'replace')))

453

for key, val in

454

vars(self).iteritems())

455

try:

456

command = self.checker_command % escaped_attrs

457

except TypeError, error:

458

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

459

u' %s', self.checker_command, error)

460

return True # Try again later

461

self.current_checker_command = command

462

try:

463

logger.info(u"Starting checker %r for %s",

464

command, self.name)

465

# We don't need to redirect stdout and stderr, since

466

# in normal mode, that is already done by daemon(),

467

# and in debug mode we don't want to. (Stdin is

468

# always replaced by /dev/null.)

469

self.checker = subprocess.Popen(command,

470

close_fds=True,

471

shell=True, cwd=u"/")

472

self.checker_callback_tag = (gobject.child_watch_add

473

(self.checker.pid,

474

self.checker_callback,

475

data=command))

476

# The checker may have completed before the gobject

477

# watch was added. Check for this.

478

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

479

if pid:

480

gobject.source_remove(self.checker_callback_tag)

481

self.checker_callback(pid, status, command)

482

except OSError, error:

483

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

484

error)

485

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

486

return True

487

488

def stop_checker(self):

489

"""Force the checker process, if any, to stop."""

490

if self.checker_callback_tag:

491

gobject.source_remove(self.checker_callback_tag)

492

self.checker_callback_tag = None

493

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

494

return

495

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

496

try:

497

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

498

#time.sleep(0.5)

499

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

500

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

501

except OSError, error:

502

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

503

raise

504

self.checker = None

505

506

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

507

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

508

"""Decorators for marking methods of a DBusObjectWithProperties to

509

become properties on the D-Bus.

510

511

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

512

and with one argument by "Set".

513

514

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

515

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

516

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

517

"""

518

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

519

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

520

if byte_arrays and signature != u"ay":

521

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

522

u" signature %r" % signature)

523

def decorator(func):

524

func._dbus_is_property = True

525

func._dbus_interface = dbus_interface

526

func._dbus_signature = signature

527

func._dbus_access = access

528

func._dbus_name = func.__name__

529

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

530

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

531

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

532

return func

533

return decorator

534

535

536

class DBusPropertyException(dbus.exceptions.DBusException):

537

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

538

"""

539

def __unicode__(self):

540

return unicode(str(self))

541

542

543

class DBusPropertyAccessException(DBusPropertyException):

544

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

545

"""

546

pass

547

548

549

class DBusPropertyNotFound(DBusPropertyException):

550

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

551

"""

552

pass

553

554

555

class DBusObjectWithProperties(dbus.service.Object):

556

"""A D-Bus object with properties.

557

558

Classes inheriting from this can use the dbus_service_property

559

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

560

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

561

"""

562

563

@staticmethod

564

def _is_dbus_property(obj):

565

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

566

567

def _get_all_dbus_properties(self):

568

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

569

"""

570

return ((prop._dbus_name, prop)

571

for name, prop in

572

inspect.getmembers(self, self._is_dbus_property))

573

574

def _get_dbus_property(self, interface_name, property_name):

575

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

576

property with the specified name and interface.

577

"""

578

for name in (property_name,

579

property_name + u"_dbus_property"):

580

prop = getattr(self, name, None)

581

if (prop is None

582

or not self._is_dbus_property(prop)

583

or prop._dbus_name != property_name

584

or (interface_name and prop._dbus_interface

585

and interface_name != prop._dbus_interface)):

586

continue

587

return prop

588

# No such property

589

raise DBusPropertyNotFound(self.dbus_object_path + u":"

590

+ interface_name + u"."

591

+ property_name)

592

593

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

594

out_signature=u"v")

595

def Get(self, interface_name, property_name):

596

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

597

"""

598

prop = self._get_dbus_property(interface_name, property_name)

599

if prop._dbus_access == u"write":

600

raise DBusPropertyAccessException(property_name)

601

value = prop()

602

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

603

return value

604

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

605

606

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

607

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

608

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

609

"""

610

prop = self._get_dbus_property(interface_name, property_name)

611

if prop._dbus_access == u"read":

612

raise DBusPropertyAccessException(property_name)

613

if prop._dbus_get_args_options[u"byte_arrays"]:

614

# The byte_arrays option is not supported yet on

615

# signatures other than "ay".

616

if prop._dbus_signature != u"ay":

617

raise ValueError

618

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

619

for byte in value))

620

prop(value)

621

622

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

623

out_signature=u"a{sv}")

624

def GetAll(self, interface_name):

625

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

626

standard.

627

628

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

629

"""

630

all = {}

631

for name, prop in self._get_all_dbus_properties():

632

if (interface_name

633

and interface_name != prop._dbus_interface):

634

# Interface non-empty but did not match

635

continue

636

# Ignore write-only properties

637

if prop._dbus_access == u"write":

638

continue

639

value = prop()

640

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

641

all[name] = value

642

continue

643

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

644

value.variant_level+1)

645

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

646

647

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

648

out_signature=u"s",

649

path_keyword='object_path',

650

connection_keyword='connection')

651

def Introspect(self, object_path, connection):

652

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

653

"""

654

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

655

connection)

656

try:

657

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

658

def make_tag(document, name, prop):

659

e = document.createElement(u"property")

660

e.setAttribute(u"name", name)

661

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

662

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

663

return e

664

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

665

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

666

for name, prop

667

in self._get_all_dbus_properties()

668

if prop._dbus_interface

669

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

670

if_tag.appendChild(tag)

671

# Add the names to the return values for the

672

# "org.freedesktop.DBus.Properties" methods

673

if (if_tag.getAttribute(u"name")

674

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

675

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

676

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

677

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

678

if (arg.getAttribute(u"direction")

679

== u"out"):

680

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

681

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

682

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

683

if (arg.getAttribute(u"direction")

684

== u"out"):

685

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

686

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

687

document.unlink()

688

except (AttributeError, xml.dom.DOMException,

689

xml.parsers.expat.ExpatError), error:

690

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

691

error)

692

return xmlstring

693

694

695

class ClientDBus(Client, DBusObjectWithProperties):

696

"""A Client class using D-Bus

697

698

Attributes:

699

dbus_object_path: dbus.ObjectPath

700

bus: dbus.SystemBus()

701

"""

702

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

703

704

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

705

self.bus = bus

706

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

707

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

708

# the D-Bus

709

self.dbus_object_path = (dbus.ObjectPath

710

(u"/clients/"

711

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

712

DBusObjectWithProperties.__init__(self, self.bus,

713

self.dbus_object_path)

714

715

@staticmethod

716

def _datetime_to_dbus(dt, variant_level=0):

717

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

718

return dbus.String(dt.isoformat(),

719

variant_level=variant_level)

720

721

def enable(self):

722

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

723

r = Client.enable(self)

724

if oldstate != self.enabled:

725

# Emit D-Bus signals

726

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

727

dbus.Boolean(True, variant_level=1))

728

self.PropertyChanged(

729

dbus.String(u"last_enabled"),

730

self._datetime_to_dbus(self.last_enabled,

731

variant_level=1))

732

return r

733

734

def disable(self, quiet = False):

735

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

736

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

737

if not quiet and oldstate != self.enabled:

738

# Emit D-Bus signal

739

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

740

dbus.Boolean(False, variant_level=1))

741

return r

742

743

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

744

try:

745

self.remove_from_connection()

746

except LookupError:

747

pass

748

if hasattr(DBusObjectWithProperties, u"__del__"):

749

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

750

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

751

752

def checker_callback(self, pid, condition, command,

753

*args, **kwargs):

754

self.checker_callback_tag = None

755

self.checker = None

756

# Emit D-Bus signal

757

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

758

dbus.Boolean(False, variant_level=1))

759

if os.WIFEXITED(condition):

760

exitstatus = os.WEXITSTATUS(condition)

761

# Emit D-Bus signal

762

self.CheckerCompleted(dbus.Int16(exitstatus),

763

dbus.Int64(condition),

764

dbus.String(command))

765

else:

766

# Emit D-Bus signal

767

self.CheckerCompleted(dbus.Int16(-1),

768

dbus.Int64(condition),

769

dbus.String(command))

770

771

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

772

*args, **kwargs)

773

774

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

775

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

776

# Emit D-Bus signal

777

self.PropertyChanged(

778

dbus.String(u"last_checked_ok"),

779

(self._datetime_to_dbus(self.last_checked_ok,

780

variant_level=1)))

781

return r

782

783

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

784

old_checker = self.checker

785

if self.checker is not None:

786

old_checker_pid = self.checker.pid

787

else:

788

old_checker_pid = None

789

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

790

# Only if new checker process was started

791

if (self.checker is not None

792

and old_checker_pid != self.checker.pid):

793

# Emit D-Bus signal

794

self.CheckerStarted(self.current_checker_command)

795

self.PropertyChanged(

796

dbus.String(u"checker_running"),

797

dbus.Boolean(True, variant_level=1))

798

return r

799

800

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

801

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

802

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

803

if (old_checker is not None

804

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

805

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

806

dbus.Boolean(False, variant_level=1))

807

return r

808

809

def _reset_approved(self):

810

self._approved = None

811

return False

812

813

def approve(self, value=True):

814

self._approved = value

815

gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration, self._reset_approved))

816

817

def approved_pending(self):

818

return self.approvals_pending > 0

819

820

821

## D-Bus methods, signals & properties

822

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

823

824

## Signals

825

826

# CheckerCompleted - signal

827

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

828

def CheckerCompleted(self, exitcode, waitstatus, command):

829

"D-Bus signal"

830

pass

831

832

# CheckerStarted - signal

833

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

834

def CheckerStarted(self, command):

835

"D-Bus signal"

836

pass

837

838

# PropertyChanged - signal

839

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

840

def PropertyChanged(self, property, value):

841

"D-Bus signal"

842

pass

843

844

# GotSecret - signal

845

@dbus.service.signal(_interface)

846

def GotSecret(self):

847

"D-Bus signal"

848

if self.approved_pending():

849

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

850

dbus.Boolean(False, variant_level=1))

851

852

# Rejected - signal

853

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

854

def Rejected(self, reason):

855

"D-Bus signal"

856

if self.approved_pending():

857

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

858

dbus.Boolean(False, variant_level=1))

859

860

# NeedApproval - signal

861

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

862

def NeedApproval(self, timeout, default):

863

"D-Bus signal"

864

if not self.approved_pending():

865

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

866

dbus.Boolean(True, variant_level=1))

867

868

## Methods

869

870

# Approve - method

871

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

872

def Approve(self, value):

873

self.approve(value)

874

875

# CheckedOK - method

876

@dbus.service.method(_interface)

877

def CheckedOK(self):

878

return self.checked_ok()

879

880

# Enable - method

881

@dbus.service.method(_interface)

882

def Enable(self):

883

"D-Bus method"

884

self.enable()

885

886

# StartChecker - method

887

@dbus.service.method(_interface)

888

def StartChecker(self):

889

"D-Bus method"

890

self.start_checker()

891

892

# Disable - method

893

@dbus.service.method(_interface)

894

def Disable(self):

895

"D-Bus method"

896

self.disable()

897

898

# StopChecker - method

899

@dbus.service.method(_interface)

900

def StopChecker(self):

901

self.stop_checker()

902

903

## Properties

904

905

# approved_pending - property

906

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

907

def approved_pending_dbus_property(self):

908

return dbus.Boolean(self.approved_pending())

909

910

# approved_by_default - property

911

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

912

access=u"readwrite")

913

def approved_by_default_dbus_property(self):

914

return dbus.Boolean(self.approved_by_default)

915

916

# approved_delay - property

917

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

918

access=u"readwrite")

919

def approved_delay_dbus_property(self):

920

return dbus.UInt64(self.approved_delay_milliseconds())

921

922

# approved_duration - property

923

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

924

access=u"readwrite")

925

def approved_duration_dbus_property(self):

926

return dbus.UInt64(self._timedelta_to_milliseconds(

927

self.approved_duration))

928

929

# name - property

930

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

931

def name_dbus_property(self):

932

return dbus.String(self.name)

933

934

# fingerprint - property

935

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

936

def fingerprint_dbus_property(self):

937

return dbus.String(self.fingerprint)

938

939

# host - property

940

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

941

access=u"readwrite")

942

def host_dbus_property(self, value=None):

943

if value is None: # get

944

return dbus.String(self.host)

945

self.host = value

946

# Emit D-Bus signal

947

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

948

dbus.String(value, variant_level=1))

949

950

# created - property

951

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

952

def created_dbus_property(self):

953

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

954

955

# last_enabled - property

956

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

957

def last_enabled_dbus_property(self):

958

if self.last_enabled is None:

959

return dbus.String(u"")

960

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

961

962

# enabled - property

963

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

964

access=u"readwrite")

965

def enabled_dbus_property(self, value=None):

966

if value is None: # get

967

return dbus.Boolean(self.enabled)

968

if value:

969

self.enable()

970

else:

971

self.disable()

972

973

# last_checked_ok - property

974

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

975

access=u"readwrite")

976

def last_checked_ok_dbus_property(self, value=None):

977

if value is not None:

978

self.checked_ok()

979

return

980

if self.last_checked_ok is None:

981

return dbus.String(u"")

982

return dbus.String(self._datetime_to_dbus(self

983

.last_checked_ok))

984

985

# timeout - property

986

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

987

access=u"readwrite")

988

def timeout_dbus_property(self, value=None):

989

if value is None: # get

990

return dbus.UInt64(self.timeout_milliseconds())

991

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

992

# Emit D-Bus signal

993

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

994

dbus.UInt64(value, variant_level=1))

995

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

996

return

997

# Reschedule timeout

998

gobject.source_remove(self.disable_initiator_tag)

999

self.disable_initiator_tag = None

1000

time_to_die = (self.

1001

_timedelta_to_milliseconds((self

1002

.last_checked_ok

1003

+ self.timeout)

1004

- datetime.datetime

1005

.utcnow()))

1006

if time_to_die <= 0:

1007

# The timeout has passed

1008

self.disable()

1009

else:

1010

self.disable_initiator_tag = (gobject.timeout_add

1011

(time_to_die, self.disable))

1012

1013

# interval - property

1014

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

1015

access=u"readwrite")

1016

def interval_dbus_property(self, value=None):

1017

if value is None: # get

1018

return dbus.UInt64(self.interval_milliseconds())

1019

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

1020

# Emit D-Bus signal

1021

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

1022

dbus.UInt64(value, variant_level=1))

1023

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

1024

return

1025

# Reschedule checker run

1026

gobject.source_remove(self.checker_initiator_tag)

1027

self.checker_initiator_tag = (gobject.timeout_add

1028

(value, self.start_checker))

1029

self.start_checker() # Start one now, too

1030

1031

# checker - property

1032

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

1033

access=u"readwrite")

1034

def checker_dbus_property(self, value=None):

1035

if value is None: # get

1036

return dbus.String(self.checker_command)

1037

self.checker_command = value

1038

# Emit D-Bus signal

1039

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

1040

dbus.String(self.checker_command,

1041

variant_level=1))

1042

1043

# checker_running - property

1044

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

1045

access=u"readwrite")

1046

def checker_running_dbus_property(self, value=None):

1047

if value is None: # get

1048

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

1049

if value:

1050

self.start_checker()

1051

else:

1052

self.stop_checker()

1053

1054

# object_path - property

1055

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

1056

def object_path_dbus_property(self):

1057

return self.dbus_object_path # is already a dbus.ObjectPath

1058

1059

# secret = property

1060

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

1061

access=u"write", byte_arrays=True)

1062

def secret_dbus_property(self, value):

1063

self.secret = str(value)

1064

1065

del _interface

1066

1067

1068

class ProxyClient(object):

1069

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

1070

self._pipe = child_pipe

1071

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

1072

if not self._pipe.recv():

1073

raise KeyError()

1074

1075

def __getattribute__(self, name):

1076

if(name == '_pipe'):

1077

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

1078

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

1079

data = self._pipe.recv()

1080

if data[0] == 'data':

1081

return data[1]

1082

if data[0] == 'function':

1083

def func(*args, **kwargs):

1084

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

1085

return self._pipe.recv()[1]

1086

return func

1087

1088

def __setattr__(self, name, value):

1089

if(name == '_pipe'):

1090

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

1091

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

1092

1093

1094

class ClientHandler(socketserver.BaseRequestHandler, object):

1095

"""A class to handle client connections.

1096

1097

Instantiated once for each connection to handle it.

1098

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

1099

1100

def handle(self):

1101

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

1102

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

1103

unicode(self.client_address))

1104

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

1105

self.server.child_pipe.fileno())

1106

1107

session = (gnutls.connection

1108

.ClientSession(self.request,

1109

gnutls.connection

1110

.X509Credentials()))

1111

1112

# Note: gnutls.connection.X509Credentials is really a

1113

# generic GnuTLS certificate credentials object so long as

1114

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

1115

# here despite using OpenPGP certificates.

1116

1117

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

1118

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

1119

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

1120

# u"+DHE-DSS"))

1121

# Use a fallback default, since this MUST be set.

1122

priority = self.server.gnutls_priority

1123

if priority is None:

1124

priority = u"NORMAL"

1125

(gnutls.library.functions

1126

.gnutls_priority_set_direct(session._c_object,

1127

priority, None))

1128

1129

# Start communication using the Mandos protocol

1130

# Get protocol number

1131

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

1132

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

1133

try:

1134

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

1135

raise RuntimeError

1136

except (ValueError, IndexError, RuntimeError), error:

1137

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

1138

return

1139

1140

# Start GnuTLS connection

1141

try:

1142

session.handshake()

1143

except gnutls.errors.GNUTLSError, error:

1144

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

1145

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

1146

# established. Just abandon the request.

1147

return

1148

logger.debug(u"Handshake succeeded")

1149

1150

approval_required = False

1151

try:

1152

try:

1153

fpr = self.fingerprint(self.peer_certificate

1154

(session))

1155

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

1156

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

1157

return

1158

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

1159

1160

try:

1161

client = ProxyClient(child_pipe, fpr,

1162

self.client_address)

1163

except KeyError:

1164

return

1165

1166

if client.approved_delay:

1167

delay = client.approved_delay

1168

client.approvals_pending += 1

1169

approval_required = True

1170

1171

while True:

1172

if not client.enabled:

1173

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

1174

client.name)

1175

if self.server.use_dbus:

1176

# Emit D-Bus signal

1177

client.Rejected("Disabled")

1178

return

1179

1180

if client._approved or not client.approved_delay:

1181

#We are approved or approval is disabled

1182

break

1183

elif client._approved is None:

1184

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

1185

client.name)

1186

if self.server.use_dbus:

1187

# Emit D-Bus signal

1188

client.NeedApproval(

1189

client.approved_delay_milliseconds(),

1190

client.approved_by_default)

1191

else:

1192

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

1193

client.name)

1194

if self.server.use_dbus:

1195

# Emit D-Bus signal

1196

client.Rejected("Disapproved")

1197

return

1198

1199

#wait until timeout or approved

1200

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

1201

time = datetime.datetime.now()

1202

client.changedstate.acquire()

1203

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

1204

client.changedstate.release()

1205

time2 = datetime.datetime.now()

1206

if (time2 - time) >= delay:

1207

if not client.approved_by_default:

1208

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

1209

" waiting for approval",

1210

client.name)

1211

if self.server.use_dbus:

1212

# Emit D-Bus signal

1213

client.Rejected("Time out")

1214

return

1215

else:

1216

break

1217

else:

1218

delay -= time2 - time

1219

1220

sent_size = 0

1221

while sent_size < len(client.secret):

1222

# XXX handle session exception

1223

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

1224

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

1225

sent, len(client.secret)

1226

- (sent_size + sent))

1227

sent_size += sent

1228

1229

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

1230

# bump the timeout as if seen

1231

client.checked_ok()

1232

if self.server.use_dbus:

1233

# Emit D-Bus signal

1234

client.GotSecret()

1235

1236

finally:

1237

if approval_required:

1238

client.approvals_pending -= 1

1239

session.bye()

1240

1241

@staticmethod

1242

def peer_certificate(session):

1243

"Return the peer's OpenPGP certificate as a bytestring"

1244

# If not an OpenPGP certificate...

1245

if (gnutls.library.functions

1246

.gnutls_certificate_type_get(session._c_object)

1247

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1248

# ...do the normal thing

1249

return session.peer_certificate

1250

list_size = ctypes.c_uint(1)

1251

cert_list = (gnutls.library.functions

1252

.gnutls_certificate_get_peers

1253

(session._c_object, ctypes.byref(list_size)))

1254

if not bool(cert_list) and list_size.value != 0:

1255

raise gnutls.errors.GNUTLSError(u"error getting peer"

1256

u" certificate")

1257

if list_size.value == 0:

1258

return None

1259

cert = cert_list[0]

1260

return ctypes.string_at(cert.data, cert.size)

1261

1262

@staticmethod

1263

def fingerprint(openpgp):

1264

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

1265

# New GnuTLS "datum" with the OpenPGP public key

1266

datum = (gnutls.library.types

1267

.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),

1268

ctypes.POINTER

1269

(ctypes.c_ubyte)),

1270

ctypes.c_uint(len(openpgp))))

1271

# New empty GnuTLS certificate

1272

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1273

(gnutls.library.functions

1274

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

1275

# Import the OpenPGP public key into the certificate

1276

(gnutls.library.functions

1277

.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),

1278

gnutls.library.constants

1279

.GNUTLS_OPENPGP_FMT_RAW))

1280

# Verify the self signature in the key

1281

crtverify = ctypes.c_uint()

1282

(gnutls.library.functions

1283

.gnutls_openpgp_crt_verify_self(crt, 0,

1284

ctypes.byref(crtverify)))

1285

if crtverify.value != 0:

1286

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1287

raise (gnutls.errors.CertificateSecurityError

1288

(u"Verify failed"))

1289

# New buffer for the fingerprint

1290

buf = ctypes.create_string_buffer(20)

1291

buf_len = ctypes.c_size_t()

1292

# Get the fingerprint from the certificate into the buffer

1293

(gnutls.library.functions

1294

.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),

1295

ctypes.byref(buf_len)))

1296

# Deinit the certificate

1297

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1298

# Convert the buffer to a Python bytestring

1299

fpr = ctypes.string_at(buf, buf_len.value)

1300

# Convert the bytestring to hexadecimal notation

1301

hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)

1302

return hex_fpr

1303

1304

1305

class MultiprocessingMixIn(object):

1306

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

1307

def sub_process_main(self, request, address):

1308

try:

1309

self.finish_request(request, address)

1310

except:

1311

self.handle_error(request, address)

1312

self.close_request(request)

1313

1314

def process_request(self, request, address):

1315

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

1316

multiprocessing.Process(target = self.sub_process_main,

1317

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

1318

1319

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1320

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

1321

def process_request(self, request, client_address):

1322

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

1323

1324

This function creates a new pipe in self.pipe

1325

"""

1326

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1327

1328

super(MultiprocessingMixInWithPipe,

1329

self).process_request(request, client_address)

1330

self.add_pipe(parent_pipe)

1331

def add_pipe(self, parent_pipe):

1332

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

1333

pass

1334

1335

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1336

socketserver.TCPServer, object):

1337

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

1338

1339

Attributes:

1340

enabled: Boolean; whether this server is activated yet

1341

interface: None or a network interface name (string)

1342

use_ipv6: Boolean; to use IPv6 or not

1343

"""

1344

def __init__(self, server_address, RequestHandlerClass,

1345

interface=None, use_ipv6=True):

1346

self.interface = interface

1347

if use_ipv6:

1348

self.address_family = socket.AF_INET6

1349

socketserver.TCPServer.__init__(self, server_address,

1350

RequestHandlerClass)

1351

def server_bind(self):

1352

"""This overrides the normal server_bind() function

1353

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

1354

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

1355

if self.interface is not None:

1356

if SO_BINDTODEVICE is None:

1357

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

1358

u" cannot bind to interface %s",

1359

self.interface)

1360

else:

1361

try:

1362

self.socket.setsockopt(socket.SOL_SOCKET,

1363

SO_BINDTODEVICE,

1364

str(self.interface

1365

+ u'\0'))

1366

except socket.error, error:

1367

if error[0] == errno.EPERM:

1368

logger.error(u"No permission to"

1369

u" bind to interface %s",

1370

self.interface)

1371

elif error[0] == errno.ENOPROTOOPT:

1372

logger.error(u"SO_BINDTODEVICE not available;"

1373

u" cannot bind to interface %s",

1374

self.interface)

1375

else:

1376

raise

1377

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

1378

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

1379

if not self.server_address[0]:

1380

if self.address_family == socket.AF_INET6:

1381

any_address = u"::" # in6addr_any

1382

else:

1383

any_address = socket.INADDR_ANY

1384

self.server_address = (any_address,

1385

self.server_address[1])

1386

elif not self.server_address[1]:

1387

self.server_address = (self.server_address[0],

1388

0)

1389

# if self.interface:

1390

# self.server_address = (self.server_address[0],

1391

# 0, # port

1392

# 0, # flowinfo

1393

# if_nametoindex

1394

# (self.interface))

1395

return socketserver.TCPServer.server_bind(self)

1396

1397

1398

class MandosServer(IPv6_TCPServer):

1399

"""Mandos server.

1400

1401

Attributes:

1402

clients: set of Client objects

1403

gnutls_priority GnuTLS priority string

1404

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

1405

1406

Assumes a gobject.MainLoop event loop.

1407

"""

1408

def __init__(self, server_address, RequestHandlerClass,

1409

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

1410

gnutls_priority=None, use_dbus=True):

1411

self.enabled = False

1412

self.clients = clients

1413

if self.clients is None:

1414

self.clients = set()

1415

self.use_dbus = use_dbus

1416

self.gnutls_priority = gnutls_priority

1417

IPv6_TCPServer.__init__(self, server_address,

1418

RequestHandlerClass,

1419

interface = interface,

1420

use_ipv6 = use_ipv6)

1421

def server_activate(self):

1422

if self.enabled:

1423

return socketserver.TCPServer.server_activate(self)

1424

def enable(self):

1425

self.enabled = True

1426

def add_pipe(self, parent_pipe):

1427

# Call "handle_ipc" for both data and EOF events

1428

gobject.io_add_watch(parent_pipe.fileno(),

1429

gobject.IO_IN | gobject.IO_HUP,

1430

functools.partial(self.handle_ipc,

1431

parent_pipe = parent_pipe))

1432

1433

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

1434

client_object=None):

1435

condition_names = {

1436

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

1437

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

1438

# blocking).

1439

gobject.IO_PRI: u"PRI", # There is urgent data to read.

1440

gobject.IO_ERR: u"ERR", # Error condition.

1441

gobject.IO_HUP: u"HUP" # Hung up (the connection has been

1442

# broken, usually for pipes and

1443

# sockets).

1444

}

1445

conditions_string = ' | '.join(name

1446

for cond, name in

1447

condition_names.iteritems()

1448

if cond & condition)

1449

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

1450

conditions_string)

1451

1452

# Read a request from the child

1453

request = parent_pipe.recv()

1454

command = request[0]

1455

1456

if command == 'init':

1457

fpr = request[1]

1458

address = request[2]

1459

1460

for c in self.clients:

1461

if c.fingerprint == fpr:

1462

client = c

1463

break

1464

else:

1465

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

1466

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

1467

if self.use_dbus:

1468

# Emit D-Bus signal

1469

mandos_dbus_service.ClientNotFound(fpr, address)

1470

parent_pipe.send(False)

1471

return False

1472

1473

gobject.io_add_watch(parent_pipe.fileno(),

1474

gobject.IO_IN | gobject.IO_HUP,

1475

functools.partial(self.handle_ipc,

1476

parent_pipe = parent_pipe,

1477

client_object = client))

1478

parent_pipe.send(True)

1479

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

1480

return False

1481

if command == 'funcall':

1482

funcname = request[1]

1483

args = request[2]

1484

kwargs = request[3]

1485

1486

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

1487

1488

if command == 'getattr':

1489

attrname = request[1]

1490

if callable(client_object.__getattribute__(attrname)):

1491

parent_pipe.send(('function',))

1492

else:

1493

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

1494

1495

if command == 'setattr':

1496

attrname = request[1]

1497

value = request[2]

1498

setattr(client_object, attrname, value)

1499

1500

return True

1501

1502

1503

def string_to_delta(interval):

1504

"""Parse a string and return a datetime.timedelta

1505

1506

>>> string_to_delta(u'7d')

1507

datetime.timedelta(7)

1508

>>> string_to_delta(u'60s')

1509

datetime.timedelta(0, 60)

1510

>>> string_to_delta(u'60m')

1511

datetime.timedelta(0, 3600)

1512

>>> string_to_delta(u'24h')

1513

datetime.timedelta(1)

1514

>>> string_to_delta(u'1w')

1515

datetime.timedelta(7)

1516

>>> string_to_delta(u'5m 30s')

1517

datetime.timedelta(0, 330)

1518

"""

1519

timevalue = datetime.timedelta(0)

1520

for s in interval.split():

1521

try:

1522

suffix = unicode(s[-1])

1523

value = int(s[:-1])

1524

if suffix == u"d":

1525

delta = datetime.timedelta(value)

1526

elif suffix == u"s":

1527

delta = datetime.timedelta(0, value)

1528

elif suffix == u"m":

1529

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

1530

elif suffix == u"h":

1531

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

1532

elif suffix == u"w":

1533

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

1534

else:

1535

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

1536

except (ValueError, IndexError), e:

1537

raise ValueError(e.message)

1538

timevalue += delta

1539

return timevalue

1540

1541

1542

def if_nametoindex(interface):

1543

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

1544

1545

Note: This function cannot accept a unicode string."""

1546

global if_nametoindex

1547

try:

1548

if_nametoindex = (ctypes.cdll.LoadLibrary

1549

(ctypes.util.find_library(u"c"))

1550

.if_nametoindex)

1551

except (OSError, AttributeError):

1552

logger.warning(u"Doing if_nametoindex the hard way")

1553

def if_nametoindex(interface):

1554

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

1555

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

1556

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

1557

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1558

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

1559

interface))

1560

interface_index = struct.unpack(str(u"I"),

1561

ifreq[16:20])[0]

1562

return interface_index

1563

return if_nametoindex(interface)

1564

1565

1566

def daemon(nochdir = False, noclose = False):

1567

"""See daemon(3). Standard BSD Unix function.

1568

1569

This should really exist as os.daemon, but it doesn't (yet)."""

1570

if os.fork():

1571

sys.exit()

1572

os.setsid()

1573

if not nochdir:

1574

os.chdir(u"/")

1575

if os.fork():

1576

sys.exit()

1577

if not noclose:

1578

# Close all standard open file descriptors

1579

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

1580

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

1581

raise OSError(errno.ENODEV,

1582

u"%s not a character device"

1583

% os.path.devnull)

1584

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

1585

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

1586

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

1587

if null > 2:

1588

os.close(null)

1589

1590

1591

def main():

1592

1593

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

1594

# Parsing of options, both command line and config file

1595

1596

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

1597

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

1598

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

1599

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

1600

help=u"Address to listen for requests on")

1601

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

1602

help=u"Port number to receive requests on")

1603

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

1604

help=u"Run self-test")

1605

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

1606

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

1607

u" terminal")

1608

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

1609

u" priority string (see GnuTLS documentation)")

1610

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

1611

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

1612

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

1613

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

1614

help=u"Directory to search for configuration"

1615

u" files")

1616

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

1617

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

1618

u" system bus interface")

1619

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

1620

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

1621

options = parser.parse_args()[0]

1622

1623

if options.check:

1624

import doctest

1625

doctest.testmod()

1626

sys.exit()

1627

1628

# Default values for config file for server-global settings

1629

server_defaults = { u"interface": u"",

1630

u"address": u"",

1631

u"port": u"",

1632

u"debug": u"False",

1633

u"priority":

1634

u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",

1635

u"servicename": u"Mandos",

1636

u"use_dbus": u"True",

1637

u"use_ipv6": u"True",

1638

}

1639

1640

# Parse config file for server-global settings

1641

server_config = configparser.SafeConfigParser(server_defaults)

1642

del server_defaults

1643

server_config.read(os.path.join(options.configdir,

1644

u"mandos.conf"))

1645

# Convert the SafeConfigParser object to a dict

1646

server_settings = server_config.defaults()

1647

# Use the appropriate methods on the non-string config options

1648

for option in (u"debug", u"use_dbus", u"use_ipv6"):

1649

server_settings[option] = server_config.getboolean(u"DEFAULT",

1650

option)

1651

if server_settings["port"]:

1652

server_settings["port"] = server_config.getint(u"DEFAULT",

1653

u"port")

1654

del server_config

1655

1656

# Override the settings from the config file with command line

1657

# options, if set.

1658

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

1659

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

1660

u"use_dbus", u"use_ipv6"):

1661

value = getattr(options, option)

1662

if value is not None:

1663

server_settings[option] = value

1664

del options

1665

# Force all strings to be unicode

1666

for option in server_settings.keys():

1667

if type(server_settings[option]) is str:

1668

server_settings[option] = unicode(server_settings[option])

1669

# Now we have our good server settings in "server_settings"

1670

1671

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

1672

1673

# For convenience

1674

debug = server_settings[u"debug"]

1675

use_dbus = server_settings[u"use_dbus"]

1676

use_ipv6 = server_settings[u"use_ipv6"]

1677

1678

if not debug:

1679

syslogger.setLevel(logging.WARNING)

1680

console.setLevel(logging.WARNING)

1681

1682

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

1683

syslogger.setFormatter(logging.Formatter

1684

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

1685

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

1686

% server_settings[u"servicename"]))

1687

1688

# Parse config file with clients

1689

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

1690

u"interval": u"5m",

1691

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

1692

u"host": u"",

1693

u"approved_delay": u"0s",

1694

u"approved_duration": u"1s",

1695

}

1696

client_config = configparser.SafeConfigParser(client_defaults)

1697

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

1698

u"clients.conf"))

1699

1700

global mandos_dbus_service

1701

mandos_dbus_service = None

1702

1703

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

1704

server_settings[u"port"]),

1705

ClientHandler,

1706

interface=server_settings[u"interface"],

1707

use_ipv6=use_ipv6,

1708

gnutls_priority=

1709

server_settings[u"priority"],

1710

use_dbus=use_dbus)

1711

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

1712

try:

1713

pidfile = open(pidfilename, u"w")

1714

except IOError:

1715

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

1716

1717

try:

1718

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

1719

gid = pwd.getpwnam(u"_mandos").pw_gid

1720

except KeyError:

1721

try:

1722

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

1723

gid = pwd.getpwnam(u"mandos").pw_gid

1724

except KeyError:

1725

try:

1726

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

1727

gid = pwd.getpwnam(u"nobody").pw_gid

1728

except KeyError:

1729

uid = 65534

1730

gid = 65534

1731

try:

1732

os.setgid(gid)

1733

os.setuid(uid)

1734

except OSError, error:

1735

if error[0] != errno.EPERM:

1736

raise error

1737

1738

# Enable all possible GnuTLS debugging

1739

if debug:

1740

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

1741

# - GnuTLS manual

1742

gnutls.library.functions.gnutls_global_set_log_level(11)

1743

1744

@gnutls.library.types.gnutls_log_func

1745

def debug_gnutls(level, string):

1746

logger.debug(u"GnuTLS: %s", string[:-1])

1747

1748

(gnutls.library.functions

1749

.gnutls_global_set_log_function(debug_gnutls))

1750

1751

global main_loop

1752

# From the Avahi example code

1753

DBusGMainLoop(set_as_default=True )

1754

main_loop = gobject.MainLoop()

1755

bus = dbus.SystemBus()

1756

# End of Avahi example code

1757

if use_dbus:

1758

try:

1759

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

1760

bus, do_not_queue=True)

1761

except dbus.exceptions.NameExistsException, e:

1762

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

1763

use_dbus = False

1764

server_settings[u"use_dbus"] = False

1765

tcp_server.use_dbus = False

1766

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1767

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

1768

servicetype = u"_mandos._tcp",

1769

protocol = protocol, bus = bus)

1770

if server_settings["interface"]:

1771

service.interface = (if_nametoindex

1772

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

1773

1774

client_class = Client

1775

if use_dbus:

1776

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

1777

def client_config_items(config, section):

1778

special_settings = {

1779

"approved_by_default":

1780

lambda: config.getboolean(section,

1781

"approved_by_default"),

1782

}

1783

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

1784

try:

1785

yield (name, special_settings[name]())

1786

except KeyError:

1787

yield (name, value)

1788

1789

tcp_server.clients.update(set(

1790

client_class(name = section,

1791

config= dict(client_config_items(

1792

client_config, section)))

1793

for section in client_config.sections()))

1794

if not tcp_server.clients:

1795

logger.warning(u"No clients defined")

1796

1797

if debug:

1798

# Redirect stdin so all checkers get /dev/null

1799

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

1800

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

1801

if null > 2:

1802

os.close(null)

1803

else:

1804

# No console logging

1805

logger.removeHandler(console)

1806

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

1807

daemon()

1808

1809

try:

1810

with pidfile:

1811

pid = os.getpid()

1812

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

1813

del pidfile

1814

except IOError:

1815

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

1816

pidfilename, pid)

1817

except NameError:

1818

# "pidfile" was never created

1819

pass

1820

del pidfilename

1821

1822

if not debug:

1823

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

1824

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

1825

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

1826

1827

if use_dbus:

1828

class MandosDBusService(dbus.service.Object):

1829

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

1830

def __init__(self):

1831

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

1832

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

1833

1834

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

1835

def ClientAdded(self, objpath):

1836

"D-Bus signal"

1837

pass

1838

1839

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

1840

def ClientNotFound(self, fingerprint, address):

1841

"D-Bus signal"

1842

pass

1843

1844

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

1845

def ClientRemoved(self, objpath, name):

1846

"D-Bus signal"

1847

pass

1848

1849

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

1850

def GetAllClients(self):

1851

"D-Bus method"

1852

return dbus.Array(c.dbus_object_path

1853

for c in tcp_server.clients)

1854

1855

@dbus.service.method(_interface,

1856

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

1857

def GetAllClientsWithProperties(self):

1858

"D-Bus method"

1859

return dbus.Dictionary(

1860

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

1861

for c in tcp_server.clients),

1862

signature=u"oa{sv}")

1863

1864

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

1865

def RemoveClient(self, object_path):

1866

"D-Bus method"

1867

for c in tcp_server.clients:

1868

if c.dbus_object_path == object_path:

1869

tcp_server.clients.remove(c)

1870

c.remove_from_connection()

1871

# Don't signal anything except ClientRemoved

1872

c.disable(quiet=True)

1873

# Emit D-Bus signal

1874

self.ClientRemoved(object_path, c.name)

1875

return

1876

raise KeyError(object_path)

1877

1878

del _interface

1879

1880

mandos_dbus_service = MandosDBusService()

1881

1882

def cleanup():

1883

"Cleanup function; run on exit"

1884

service.cleanup()

1885

1886

while tcp_server.clients:

1887

client = tcp_server.clients.pop()

1888

if use_dbus:

1889

client.remove_from_connection()

1890

client.disable_hook = None

1891

# Don't signal anything except ClientRemoved

1892

client.disable(quiet=True)

1893

if use_dbus:

1894

# Emit D-Bus signal

1895

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

1896

client.name)

1897

1898

atexit.register(cleanup)

1899

1900

for client in tcp_server.clients:

1901

if use_dbus:

1902

# Emit D-Bus signal

1903

mandos_dbus_service.ClientAdded(client.dbus_object_path)

1904

client.enable()

1905

1906

tcp_server.enable()

1907

tcp_server.server_activate()

1908

1909

# Find out what port we got

1910

service.port = tcp_server.socket.getsockname()[1]

1911

if use_ipv6:

1912

logger.info(u"Now listening on address %r, port %d,"

1913

" flowinfo %d, scope_id %d"

1914

% tcp_server.socket.getsockname())

1915

else: # IPv4

1916

logger.info(u"Now listening on address %r, port %d"

1917

% tcp_server.socket.getsockname())

1918

1919

#service.interface = tcp_server.socket.getsockname()[3]

1920

1921

try:

1922

# From the Avahi example code

1923

try:

1924

service.activate()

1925

except dbus.exceptions.DBusException, error:

1926

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

1927

cleanup()

1928

sys.exit(1)

1929

# End of Avahi example code

1930

1931

gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,

1932

lambda *args, **kwargs:

1933

(tcp_server.handle_request

1934

(*args[2:], **kwargs) or True))

1935

1936

logger.debug(u"Starting main loop")

1937

main_loop.run()

1938

except AvahiError, error:

1939

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

1940

cleanup()

1941

sys.exit(1)

1942

except KeyboardInterrupt:

1943

if debug:

1944

print >> sys.stderr

1945

logger.debug(u"Server received KeyboardInterrupt")

1946

logger.debug(u"Server exiting")

1947

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

1948

cleanup()

1949

1950

if __name__ == '__main__':

1951

main()