/mandos/trunk : revision 409

1

#!/usr/bin/python

2

3

import SocketServer

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

4

37

import socket

5

import select

6

from optparse import OptionParser

38

import optparse

7

39

import datetime

8

40

import errno

9

41

import gnutls.crypto

10

42

import gnutls.connection

11

43

import gnutls.errors

12

import ConfigParser

44

import gnutls.library.functions

45

import gnutls.library.constants

46

import gnutls.library.types

47

import ConfigParser as configparser

13

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

from contextlib import closing

59

import struct

60

import fcntl

61

import functools

62

63

import dbus

64

import dbus.service

65

import gobject

66

import avahi

67

from dbus.mainloop.glib import DBusGMainLoop

68

import ctypes

69

import ctypes.util

70

import xml.dom.minidom

71

import inspect

72

73

try:

74

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

75

except AttributeError:

76

try:

77

from IN import SO_BINDTODEVICE

78

except ImportError:

79

SO_BINDTODEVICE = None

80

81

82

version = "1.0.14"

83

84

logger = logging.Logger(u'mandos')

85

syslogger = (logging.handlers.SysLogHandler

86

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

87

address = "/dev/log"))

88

syslogger.setFormatter(logging.Formatter

89

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

90

u' %(message)s'))

91

logger.addHandler(syslogger)

92

93

console = logging.StreamHandler()

94

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

95

u' %(levelname)s:'

96

u' %(message)s'))

97

logger.addHandler(console)

98

99

class AvahiError(Exception):

100

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

101

self.value = value

102

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

103

def __unicode__(self):

104

return unicode(repr(self.value))

105

106

class AvahiServiceError(AvahiError):

107

pass

108

109

class AvahiGroupError(AvahiError):

110

pass

111

112

113

class AvahiService(object):

114

"""An Avahi (Zeroconf) service.

115

116

Attributes:

117

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

118

Used to optionally bind to the specified interface.

119

name: string; Example: u'Mandos'

120

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

121

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

122

port: integer; what port to announce

123

TXT: list of strings; TXT record for the service

124

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

125

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

126

max_renames: integer; maximum number of renames

127

rename_count: integer; counter so we only rename after collisions

128

a sensible number of times

129

group: D-Bus Entry Group

130

server: D-Bus Server

131

bus: dbus.SystemBus()

132

"""

133

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

134

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

135

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

136

protocol = avahi.PROTO_UNSPEC, bus = None):

137

self.interface = interface

138

self.name = name

139

self.type = servicetype

140

self.port = port

141

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

142

self.domain = domain

143

self.host = host

144

self.rename_count = 0

145

self.max_renames = max_renames

146

self.protocol = protocol

147

self.group = None # our entry group

148

self.server = None

149

self.bus = bus

150

def rename(self):

151

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

152

if self.rename_count >= self.max_renames:

153

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

154

u" after %i retries, exiting.",

155

self.rename_count)

156

raise AvahiServiceError(u"Too many renames")

157

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

158

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

159

unicode(self.name))

160

syslogger.setFormatter(logging.Formatter

161

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

162

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

163

% self.name))

164

self.remove()

165

self.add()

166

self.rename_count += 1

167

def remove(self):

168

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

169

if self.group is not None:

170

self.group.Reset()

171

def add(self):

172

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

173

if self.group is None:

174

self.group = dbus.Interface(

175

self.bus.get_object(avahi.DBUS_NAME,

176

self.server.EntryGroupNew()),

177

avahi.DBUS_INTERFACE_ENTRY_GROUP)

178

self.group.connect_to_signal('StateChanged',

179

self

180

.entry_group_state_changed)

181

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

182

self.name, self.type)

183

self.group.AddService(

184

self.interface,

185

self.protocol,

186

dbus.UInt32(0), # flags

187

self.name, self.type,

188

self.domain, self.host,

189

dbus.UInt16(self.port),

190

avahi.string_array_to_txt_array(self.TXT))

191

self.group.Commit()

192

def entry_group_state_changed(self, state, error):

193

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

194

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

195

196

if state == avahi.ENTRY_GROUP_ESTABLISHED:

197

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

198

elif state == avahi.ENTRY_GROUP_COLLISION:

199

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

200

self.rename()

201

elif state == avahi.ENTRY_GROUP_FAILURE:

202

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

203

unicode(error))

204

raise AvahiGroupError(u"State changed: %s"

205

% unicode(error))

206

def cleanup(self):

207

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

208

if self.group is not None:

209

self.group.Free()

210

self.group = None

211

def server_state_changed(self, state):

212

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

213

if state == avahi.SERVER_COLLISION:

214

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

215

self.remove()

216

elif state == avahi.SERVER_RUNNING:

217

self.add()

218

def activate(self):

219

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

220

if self.server is None:

221

self.server = dbus.Interface(

222

self.bus.get_object(avahi.DBUS_NAME,

223

avahi.DBUS_PATH_SERVER),

224

avahi.DBUS_INTERFACE_SERVER)

225

self.server.connect_to_signal(u"StateChanged",

226

self.server_state_changed)

227

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

14

228

15

229

16

230

class Client(object):

17

def __init__(self, name=None, options=None, dn=None,

18

password=None, passfile=None, fqdn=None,

19

timeout=None, interval=-1):

231

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

232

233

Attributes:

234

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

235

D-Bus identifiers

236

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

237

uniquely identify the client

238

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

239

host: string; available for use by the checker command

240

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

241

last_enabled: datetime.datetime(); (UTC)

242

enabled: bool()

243

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

244

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

245

until this client is invalid

246

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

247

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

248

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

249

to see if the client lives.

250

'None' if no process is running.

251

checker_initiator_tag: a gobject event source tag, or None

252

disable_initiator_tag: - '' -

253

checker_callback_tag: - '' -

254

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

255

client lives. %() expansions are done at

256

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

257

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

258

current_checker_command: string; current running checker_command

259

"""

260

261

@staticmethod

262

def _timedelta_to_milliseconds(td):

263

"Convert a datetime.timedelta() to milliseconds"

264

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

265

+ (td.seconds * 1000)

266

+ (td.microseconds // 1000))

267

268

def timeout_milliseconds(self):

269

"Return the 'timeout' attribute in milliseconds"

270

return self._timedelta_to_milliseconds(self.timeout)

271

272

def interval_milliseconds(self):

273

"Return the 'interval' attribute in milliseconds"

274

return self._timedelta_to_milliseconds(self.interval)

275

276

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

277

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

278

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

279

attribute."""

20

280

self.name = name

21

self.dn = dn

22

if password:

23

self.password = password

24

elif passfile:

25

self.password = open(passfile).readall()

26

else:

27

print "No Password or Passfile in client config file"

28

# raise RuntimeError XXX

29

self.password = "gazonk"

30

self.fqdn = fqdn

31

self.created = datetime.datetime.now()

32

self.last_seen = None

33

if timeout is None:

34

timeout = options.timeout

35

self.timeout = timeout

36

if interval == -1:

37

interval = options.interval

38

self.interval = interval

39

self.next_check = datetime.datetime.now()

40

41

42

class server_metaclass(type):

43

"Common behavior for the UDP and TCP server classes"

44

def __new__(cls, name, bases, attrs):

45

attrs["address_family"] = socket.AF_INET6

46

attrs["allow_reuse_address"] = True

47

def server_bind(self):

48

if self.options.interface:

49

if not hasattr(socket, "SO_BINDTODEVICE"):

50

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

51

socket.SO_BINDTODEVICE = 25

281

if config is None:

282

config = {}

283

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

284

# Uppercase and remove spaces from fingerprint for later

285

# comparison purposes with return value from the fingerprint()

286

# function

287

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

288

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

289

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

290

if u"secret" in config:

291

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

292

elif u"secfile" in config:

293

with closing(open(os.path.expanduser

294

(os.path.expandvars

295

(config[u"secfile"])),

296

"rb")) as secfile:

297

self.secret = secfile.read()

298

else:

299

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

300

% self.name)

301

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

302

self.created = datetime.datetime.utcnow()

303

self.enabled = False

304

self.last_enabled = None

305

self.last_checked_ok = None

306

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

307

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

308

self.disable_hook = disable_hook

309

self.checker = None

310

self.checker_initiator_tag = None

311

self.disable_initiator_tag = None

312

self.checker_callback_tag = None

313

self.checker_command = config[u"checker"]

314

self.current_checker_command = None

315

self.last_connect = None

316

317

def enable(self):

318

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

319

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

320

# Already enabled

321

return

322

self.last_enabled = datetime.datetime.utcnow()

323

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

324

# and every interval from then on.

325

self.checker_initiator_tag = (gobject.timeout_add

326

(self.interval_milliseconds(),

327

self.start_checker))

328

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

329

self.disable_initiator_tag = (gobject.timeout_add

330

(self.timeout_milliseconds(),

331

self.disable))

332

self.enabled = True

333

# Also start a new checker *right now*.

334

self.start_checker()

335

336

def disable(self, quiet=True):

337

"""Disable this client."""

338

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

339

return False

340

if not quiet:

341

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

342

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

343

gobject.source_remove(self.disable_initiator_tag)

344

self.disable_initiator_tag = None

345

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

346

gobject.source_remove(self.checker_initiator_tag)

347

self.checker_initiator_tag = None

348

self.stop_checker()

349

if self.disable_hook:

350

self.disable_hook(self)

351

self.enabled = False

352

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

353

return False

354

355

def __del__(self):

356

self.disable_hook = None

357

self.disable()

358

359

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

360

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

361

self.checker_callback_tag = None

362

self.checker = None

363

if os.WIFEXITED(condition):

364

exitstatus = os.WEXITSTATUS(condition)

365

if exitstatus == 0:

366

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

367

vars(self))

368

self.checked_ok()

369

else:

370

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

371

vars(self))

372

else:

373

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

374

vars(self))

375

376

def checked_ok(self):

377

"""Bump up the timeout for this client.

378

379

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

380

alive and well.

381

"""

382

self.last_checked_ok = datetime.datetime.utcnow()

383

gobject.source_remove(self.disable_initiator_tag)

384

self.disable_initiator_tag = (gobject.timeout_add

385

(self.timeout_milliseconds(),

386

self.disable))

387

388

def start_checker(self):

389

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

390

391

If a checker already exists, leave it running and do

392

nothing."""

393

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

394

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

395

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

396

# client would inevitably timeout, since no checker would get

397

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

398

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

399

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

400

# is as it should be.

401

402

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

403

try:

404

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

405

except (AttributeError, OSError), error:

406

if (isinstance(error, OSError)

407

and error.errno != errno.ECHILD):

408

raise error

409

else:

410

if pid:

411

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

412

gobject.source_remove(self.checker_callback_tag)

413

self.checker_callback(pid, status,

414

self.current_checker_command)

415

# Start a new checker if needed

416

if self.checker is None:

417

try:

418

# In case checker_command has exactly one % operator

419

command = self.checker_command % self.host

420

except TypeError:

421

# Escape attributes for the shell

422

escaped_attrs = dict((key,

423

re.escape(unicode(str(val),

424

errors=

425

u'replace')))

426

for key, val in

427

vars(self).iteritems())

428

try:

429

command = self.checker_command % escaped_attrs

430

except TypeError, error:

431

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

432

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

433

return True # Try again later

434

self.current_checker_command = command

435

try:

436

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

437

command, self.name)

438

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

439

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

440

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

441

# always replaced by /dev/null.)

442

self.checker = subprocess.Popen(command,

443

close_fds=True,

444

shell=True, cwd=u"/")

445

self.checker_callback_tag = (gobject.child_watch_add

446

(self.checker.pid,

447

self.checker_callback,

448

data=command))

449

# The checker may have completed before the gobject

450

# watch was added. Check for this.

451

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

452

if pid:

453

gobject.source_remove(self.checker_callback_tag)

454

self.checker_callback(pid, status, command)

455

except OSError, error:

456

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

457

error)

458

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

459

return True

460

461

def stop_checker(self):

462

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

463

if self.checker_callback_tag:

464

gobject.source_remove(self.checker_callback_tag)

465

self.checker_callback_tag = None

466

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

467

return

468

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

469

try:

470

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

471

#time.sleep(0.5)

472

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

473

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

474

except OSError, error:

475

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

476

raise

477

self.checker = None

478

479

def still_valid(self):

480

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

481

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

482

return False

483

now = datetime.datetime.utcnow()

484

if self.last_checked_ok is None:

485

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

486

else:

487

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

488

489

490

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

491

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

492

"""Decorators for marking methods of a DBusObjectWithProperties to

493

become properties on the D-Bus.

494

495

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

496

and with one argument by "Set".

497

498

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

499

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

500

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

501

"""

502

def decorator(func):

503

func._dbus_is_property = True

504

func._dbus_interface = dbus_interface

505

func._dbus_signature = signature

506

func._dbus_access = access

507

func._dbus_name = func.__name__

508

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

509

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

510

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

511

return func

512

return decorator

513

514

515

class DBusPropertyException(dbus.exceptions.DBusException):

516

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

517

"""

518

def __unicode__(self):

519

return unicode(str(self))

520

521

522

class DBusPropertyAccessException(DBusPropertyException):

523

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

524

"""

525

pass

526

527

528

class DBusPropertyNotFound(DBusPropertyException):

529

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

530

"""

531

pass

532

533

534

class DBusObjectWithProperties(dbus.service.Object):

535

"""A D-Bus object with properties.

536

537

Classes inheriting from this can use the dbus_service_property

538

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

539

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

540

"""

541

542

@staticmethod

543

def _is_dbus_property(obj):

544

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

545

546

def _get_all_dbus_properties(self):

547

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

548

"""

549

return ((prop._dbus_name, prop)

550

for name, prop in

551

inspect.getmembers(self, self._is_dbus_property))

552

553

def _get_dbus_property(self, interface_name, property_name):

554

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

555

property with the specified name and interface.

556

"""

557

for name in (property_name,

558

property_name + u"_dbus_property"):

559

prop = getattr(self, name, None)

560

if (prop is None

561

or not self._is_dbus_property(prop)

562

or prop._dbus_name != property_name

563

or (interface_name and prop._dbus_interface

564

and interface_name != prop._dbus_interface)):

565

continue

566

return prop

567

# No such property

568

raise DBusPropertyNotFound(self.dbus_object_path + u":"

569

+ interface_name + u"."

570

+ property_name)

571

572

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

573

out_signature=u"v")

574

def Get(self, interface_name, property_name):

575

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

576

"""

577

prop = self._get_dbus_property(interface_name, property_name)

578

if prop._dbus_access == u"write":

579

raise DBusPropertyAccessException(property_name)

580

value = prop()

581

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

582

return value

583

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

584

585

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

586

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

587

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

588

"""

589

prop = self._get_dbus_property(interface_name, property_name)

590

if prop._dbus_access == u"read":

591

raise DBusPropertyAccessException(property_name)

592

if prop._dbus_get_args_options[u"byte_arrays"]:

593

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

594

for byte in value))

595

prop(value)

596

597

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

598

out_signature=u"a{sv}")

599

def GetAll(self, interface_name):

600

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

601

standard.

602

603

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

604

"""

605

all = {}

606

for name, prop in self._get_all_dbus_properties():

607

if (interface_name

608

and interface_name != prop._dbus_interface):

609

# Interface non-empty but did not match

610

continue

611

# Ignore write-only properties

612

if prop._dbus_access == u"write":

613

continue

614

value = prop()

615

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

616

all[name] = value

617

continue

618

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

619

value.variant_level+1)

620

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

621

622

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

623

out_signature=u"s",

624

path_keyword='object_path',

625

connection_keyword='connection')

626

def Introspect(self, object_path, connection):

627

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

628

"""

629

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

630

connection)

631

try:

632

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

633

def make_tag(document, name, prop):

634

e = document.createElement(u"property")

635

e.setAttribute(u"name", name)

636

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

637

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

638

return e

639

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

640

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

641

for name, prop

642

in self._get_all_dbus_properties()

643

if prop._dbus_interface

644

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

645

if_tag.appendChild(tag)

646

# Add the names to the return values for the

647

# "org.freedesktop.DBus.Properties" methods

648

if (if_tag.getAttribute(u"name")

649

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

650

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

651

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

652

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

653

if (arg.getAttribute(u"direction")

654

== u"out"):

655

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

656

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

657

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

658

if (arg.getAttribute(u"direction")

659

== u"out"):

660

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

661

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

662

document.unlink()

663

except (AttributeError, xml.dom.DOMException,

664

xml.parsers.expat.ExpatError), error:

665

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

666

error)

667

return xmlstring

668

669

670

class ClientDBus(Client, DBusObjectWithProperties):

671

"""A Client class using D-Bus

672

673

Attributes:

674

dbus_object_path: dbus.ObjectPath

675

bus: dbus.SystemBus()

676

"""

677

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

678

679

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

680

self.bus = bus

681

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

682

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

683

# the D-Bus

684

self.dbus_object_path = (dbus.ObjectPath

685

(u"/clients/"

686

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

687

DBusObjectWithProperties.__init__(self, self.bus,

688

self.dbus_object_path)

689

690

@staticmethod

691

def _datetime_to_dbus(dt, variant_level=0):

692

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

693

return dbus.String(dt.isoformat(),

694

variant_level=variant_level)

695

696

def enable(self):

697

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

698

r = Client.enable(self)

699

if oldstate != self.enabled:

700

# Emit D-Bus signals

701

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

702

dbus.Boolean(True, variant_level=1))

703

self.PropertyChanged(

704

dbus.String(u"last_enabled"),

705

self._datetime_to_dbus(self.last_enabled,

706

variant_level=1))

707

return r

708

709

def disable(self, quiet = False):

710

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

711

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

712

if not quiet and oldstate != self.enabled:

713

# Emit D-Bus signal

714

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

715

dbus.Boolean(False, variant_level=1))

716

return r

717

718

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

719

try:

720

self.remove_from_connection()

721

except LookupError:

722

pass

723

if hasattr(DBusObjectWithProperties, u"__del__"):

724

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

725

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

726

727

def checker_callback(self, pid, condition, command,

728

*args, **kwargs):

729

self.checker_callback_tag = None

730

self.checker = None

731

# Emit D-Bus signal

732

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

733

dbus.Boolean(False, variant_level=1))

734

if os.WIFEXITED(condition):

735

exitstatus = os.WEXITSTATUS(condition)

736

# Emit D-Bus signal

737

self.CheckerCompleted(dbus.Int16(exitstatus),

738

dbus.Int64(condition),

739

dbus.String(command))

740

else:

741

# Emit D-Bus signal

742

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

743

dbus.Int64(condition),

744

dbus.String(command))

745

746

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

747

*args, **kwargs)

748

749

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

750

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

751

# Emit D-Bus signal

752

self.PropertyChanged(

753

dbus.String(u"last_checked_ok"),

754

(self._datetime_to_dbus(self.last_checked_ok,

755

variant_level=1)))

756

return r

757

758

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

759

old_checker = self.checker

760

if self.checker is not None:

761

old_checker_pid = self.checker.pid

762

else:

763

old_checker_pid = None

764

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

765

# Only if new checker process was started

766

if (self.checker is not None

767

and old_checker_pid != self.checker.pid):

768

# Emit D-Bus signal

769

self.CheckerStarted(self.current_checker_command)

770

self.PropertyChanged(

771

dbus.String(u"checker_running"),

772

dbus.Boolean(True, variant_level=1))

773

return r

774

775

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

776

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

777

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

778

if (old_checker is not None

779

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

780

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

781

dbus.Boolean(False, variant_level=1))

782

return r

783

784

## D-Bus methods & signals

785

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

786

787

# CheckedOK - method

788

@dbus.service.method(_interface)

789

def CheckedOK(self):

790

return self.checked_ok()

791

792

# CheckerCompleted - signal

793

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

794

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

795

"D-Bus signal"

796

pass

797

798

# CheckerStarted - signal

799

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

800

def CheckerStarted(self, command):

801

"D-Bus signal"

802

pass

803

804

# PropertyChanged - signal

805

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

806

def PropertyChanged(self, property, value):

807

"D-Bus signal"

808

pass

809

810

# GotSecret - signal

811

@dbus.service.signal(_interface)

812

def GotSecret(self):

813

"D-Bus signal"

814

pass

815

816

# Rejected - signal

817

@dbus.service.signal(_interface)

818

def Rejected(self):

819

"D-Bus signal"

820

pass

821

822

# Enable - method

823

@dbus.service.method(_interface)

824

def Enable(self):

825

"D-Bus method"

826

self.enable()

827

828

# StartChecker - method

829

@dbus.service.method(_interface)

830

def StartChecker(self):

831

"D-Bus method"

832

self.start_checker()

833

834

# Disable - method

835

@dbus.service.method(_interface)

836

def Disable(self):

837

"D-Bus method"

838

self.disable()

839

840

# StopChecker - method

841

@dbus.service.method(_interface)

842

def StopChecker(self):

843

self.stop_checker()

844

845

# name - property

846

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

847

def name_dbus_property(self):

848

return dbus.String(self.name)

849

850

# fingerprint - property

851

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

852

def fingerprint_dbus_property(self):

853

return dbus.String(self.fingerprint)

854

855

# host - property

856

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

857

access=u"readwrite")

858

def host_dbus_property(self, value=None):

859

if value is None: # get

860

return dbus.String(self.host)

861

self.host = value

862

# Emit D-Bus signal

863

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

864

dbus.String(value, variant_level=1))

865

866

# created - property

867

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

868

def created_dbus_property(self):

869

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

870

871

# last_enabled - property

872

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

873

def last_enabled_dbus_property(self):

874

if self.last_enabled is None:

875

return dbus.String(u"")

876

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

877

878

# enabled - property

879

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

880

access=u"readwrite")

881

def enabled_dbus_property(self, value=None):

882

if value is None: # get

883

return dbus.Boolean(self.enabled)

884

if value:

885

self.enable()

886

else:

887

self.disable()

888

889

# last_checked_ok - property

890

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

891

access=u"readwrite")

892

def last_checked_ok_dbus_property(self, value=None):

893

if value is not None:

894

self.checked_ok()

895

return

896

if self.last_checked_ok is None:

897

return dbus.String(u"")

898

return dbus.String(self._datetime_to_dbus(self

899

.last_checked_ok))

900

901

# timeout - property

902

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

903

access=u"readwrite")

904

def timeout_dbus_property(self, value=None):

905

if value is None: # get

906

return dbus.UInt64(self.timeout_milliseconds())

907

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

908

# Emit D-Bus signal

909

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

910

dbus.UInt64(value, variant_level=1))

911

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

912

return

913

# Reschedule timeout

914

gobject.source_remove(self.disable_initiator_tag)

915

self.disable_initiator_tag = None

916

time_to_die = (self.

917

_timedelta_to_milliseconds((self

918

.last_checked_ok

919

+ self.timeout)

920

- datetime.datetime

921

.utcnow()))

922

if time_to_die <= 0:

923

# The timeout has passed

924

self.disable()

925

else:

926

self.disable_initiator_tag = (gobject.timeout_add

927

(time_to_die, self.disable))

928

929

# interval - property

930

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

931

access=u"readwrite")

932

def interval_dbus_property(self, value=None):

933

if value is None: # get

934

return dbus.UInt64(self.interval_milliseconds())

935

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

936

# Emit D-Bus signal

937

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

938

dbus.UInt64(value, variant_level=1))

939

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

940

return

941

# Reschedule checker run

942

gobject.source_remove(self.checker_initiator_tag)

943

self.checker_initiator_tag = (gobject.timeout_add

944

(value, self.start_checker))

945

self.start_checker() # Start one now, too

946

947

# checker - property

948

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

949

access=u"readwrite")

950

def checker_dbus_property(self, value=None):

951

if value is None: # get

952

return dbus.String(self.checker_command)

953

self.checker_command = value

954

# Emit D-Bus signal

955

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

956

dbus.String(self.checker_command,

957

variant_level=1))

958

959

# checker_running - property

960

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

961

access=u"readwrite")

962

def checker_running_dbus_property(self, value=None):

963

if value is None: # get

964

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

965

if value:

966

self.start_checker()

967

else:

968

self.stop_checker()

969

970

# object_path - property

971

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

972

def object_path_dbus_property(self):

973

return self.dbus_object_path # is already a dbus.ObjectPath

974

975

# secret = property

976

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

977

access=u"write", byte_arrays=True)

978

def secret_dbus_property(self, value):

979

self.secret = str(value)

980

981

del _interface

982

983

984

class ClientHandler(socketserver.BaseRequestHandler, object):

985

"""A class to handle client connections.

986

987

Instantiated once for each connection to handle it.

988

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

989

990

def handle(self):

991

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

992

unicode(self.client_address))

993

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

994

# Open IPC pipe to parent process

995

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

996

session = (gnutls.connection

997

.ClientSession(self.request,

998

gnutls.connection

999

.X509Credentials()))

1000

1001

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

1002

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

1003

try:

1004

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

1005

raise RuntimeError

1006

except (ValueError, IndexError, RuntimeError), error:

1007

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

1008

return

1009

1010

# Note: gnutls.connection.X509Credentials is really a

1011

# generic GnuTLS certificate credentials object so long as

1012

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

1013

# here despite using OpenPGP certificates.

1014

1015

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

1016

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

1017

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

1018

# u"+DHE-DSS"))

1019

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

1020

priority = self.server.gnutls_priority

1021

if priority is None:

1022

priority = u"NORMAL"

1023

(gnutls.library.functions

1024

.gnutls_priority_set_direct(session._c_object,

1025

priority, None))

1026

1027

try:

1028

session.handshake()

1029

except gnutls.errors.GNUTLSError, error:

1030

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

1031

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

1032

# established. Just abandon the request.

1033

return

1034

logger.debug(u"Handshake succeeded")

1035

try:

1036

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

1037

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

1038

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

1039

session.bye()

1040

return

1041

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

1042

1043

for c in self.server.clients:

1044

if c.fingerprint == fpr:

1045

client = c

1046

break

1047

else:

1048

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

1049

% (fpr, unicode(self.client_address)))

1050

session.bye()

1051

return

1052

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

1053

# possible that the client timed out while establishing

1054

# the GnuTLS session.

1055

if not client.still_valid():

1056

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

1057

session.bye()

1058

return

1059

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

1060

sent_size = 0

1061

while sent_size < len(client.secret):

1062

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

1063

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

1064

sent, len(client.secret)

1065

- (sent_size + sent))

1066

sent_size += sent

1067

session.bye()

1068

1069

@staticmethod

1070

def peer_certificate(session):

1071

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

1072

# If not an OpenPGP certificate...

1073

if (gnutls.library.functions

1074

.gnutls_certificate_type_get(session._c_object)

1075

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1076

# ...do the normal thing

1077

return session.peer_certificate

1078

list_size = ctypes.c_uint(1)

1079

cert_list = (gnutls.library.functions

1080

.gnutls_certificate_get_peers

1081

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

1082

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

1083

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

1084

u" certificate")

1085

if list_size.value == 0:

1086

return None

1087

cert = cert_list[0]

1088

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

1089

1090

@staticmethod

1091

def fingerprint(openpgp):

1092

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

1093

# New GnuTLS "datum" with the OpenPGP public key

1094

datum = (gnutls.library.types

1095

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

1096

ctypes.POINTER

1097

(ctypes.c_ubyte)),

1098

ctypes.c_uint(len(openpgp))))

1099

# New empty GnuTLS certificate

1100

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1101

(gnutls.library.functions

1102

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

1103

# Import the OpenPGP public key into the certificate

1104

(gnutls.library.functions

1105

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

1106

gnutls.library.constants

1107

.GNUTLS_OPENPGP_FMT_RAW))

1108

# Verify the self signature in the key

1109

crtverify = ctypes.c_uint()

1110

(gnutls.library.functions

1111

.gnutls_openpgp_crt_verify_self(crt, 0,

1112

ctypes.byref(crtverify)))

1113

if crtverify.value != 0:

1114

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1115

raise (gnutls.errors.CertificateSecurityError

1116

(u"Verify failed"))

1117

# New buffer for the fingerprint

1118

buf = ctypes.create_string_buffer(20)

1119

buf_len = ctypes.c_size_t()

1120

# Get the fingerprint from the certificate into the buffer

1121

(gnutls.library.functions

1122

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

1123

ctypes.byref(buf_len)))

1124

# Deinit the certificate

1125

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1126

# Convert the buffer to a Python bytestring

1127

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

1128

# Convert the bytestring to hexadecimal notation

1129

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

1130

return hex_fpr

1131

1132

1133

class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):

1134

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

1135

def process_request(self, request, client_address):

1136

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

1137

1138

This function creates a new pipe in self.pipe

1139

"""

1140

self.pipe = os.pipe()

1141

super(ForkingMixInWithPipe,

1142

self).process_request(request, client_address)

1143

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

1144

self.add_pipe(self.pipe[0])

1145

def add_pipe(self, pipe):

1146

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

1147

os.close(pipe)

1148

1149

1150

class IPv6_TCPServer(ForkingMixInWithPipe,

1151

socketserver.TCPServer, object):

1152

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

1153

1154

Attributes:

1155

enabled: Boolean; whether this server is activated yet

1156

interface: None or a network interface name (string)

1157

use_ipv6: Boolean; to use IPv6 or not

1158

"""

1159

def __init__(self, server_address, RequestHandlerClass,

1160

interface=None, use_ipv6=True):

1161

self.interface = interface

1162

if use_ipv6:

1163

self.address_family = socket.AF_INET6

1164

socketserver.TCPServer.__init__(self, server_address,

1165

RequestHandlerClass)

1166

def server_bind(self):

1167

"""This overrides the normal server_bind() function

1168

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

1169

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

1170

if self.interface is not None:

1171

if SO_BINDTODEVICE is None:

1172

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

1173

u" cannot bind to interface %s",

1174

self.interface)

1175

else:

52

1176

try:

53

1177

self.socket.setsockopt(socket.SOL_SOCKET,

54

socket.SO_BINDTODEVICE,

55

self.options.interface)

1178

SO_BINDTODEVICE,

1179

str(self.interface

1180

+ u'\0'))

56

1181

except socket.error, error:

57

1182

if error[0] == errno.EPERM:

58

print "Warning: No permission to bind to interface", \

59

self.options.interface

1183

logger.error(u"No permission to"

1184

u" bind to interface %s",

1185

self.interface)

1186

elif error[0] == errno.ENOPROTOOPT:

1187

logger.error(u"SO_BINDTODEVICE not available;"

1188

u" cannot bind to interface %s",

1189

self.interface)

60

1190

else:

61

raise error

62

return super(type(self), self).server_bind()

63

attrs["server_bind"] = server_bind

64

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

65

if "options" in kwargs:

66

self.options = kwargs["options"]

67

del kwargs["options"]

68

if "clients" in kwargs:

69

self.clients = kwargs["clients"]

70

del kwargs["clients"]

71

if "credentials" in kwargs:

72

self.credentials = kwargs["credentials"]

73

del kwargs["credentials"]

74

return super(type(self), self).__init__(*args, **kwargs)

75

attrs["__init__"] = init

76

return type.__new__(cls, name, bases, attrs)

77

78

79

class udp_handler(SocketServer.DatagramRequestHandler, object):

80

def handle(self):

81

self.wfile.write("Polo")

82

print "UDP request answered"

83

84

85

class IPv6_UDPServer(SocketServer.UDPServer, object):

86

__metaclass__ = server_metaclass

87

def verify_request(self, request, client_address):

88

print "UDP request came"

89

return request[0] == "Marco"

90

91

92

class tcp_handler(SocketServer.BaseRequestHandler, object):

93

def handle(self):

94

print "TCP request came"

95

print "Request:", self.request

96

print "Client Address:", self.client_address

97

print "Server:", self.server

98

session = gnutls.connection.ServerSession(self.request,

99

self.server.credentials)

100

session.handshake()

101

if session.peer_certificate:

102

print "DN:", session.peer_certificate.subject

103

try:

104

session.verify_peer()

105

except gnutls.errors.CertificateError, error:

106

print "Verify failed", error

107

session.bye()

108

return

109

try:

110

session.send(dict((client.dn, client.password)

111

for client in self.server.clients)

112

[session.peer_certificate.subject])

113

except KeyError:

114

session.send("gazonk")

115

# Log maybe? XXX

116

session.bye()

117

118

119

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

120

__metaclass__ = server_metaclass

121

request_queue_size = 1024

122

123

124

in6addr_any = "::"

125

126

cred = None

1191

raise

1192

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

1193

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

1194

if not self.server_address[0]:

1195

if self.address_family == socket.AF_INET6:

1196

any_address = u"::" # in6addr_any

1197

else:

1198

any_address = socket.INADDR_ANY

1199

self.server_address = (any_address,

1200

self.server_address[1])

1201

elif not self.server_address[1]:

1202

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

1203

0)

1204

# if self.interface:

1205

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

1206

# 0, # port

1207

# 0, # flowinfo

1208

# if_nametoindex

1209

# (self.interface))

1210

return socketserver.TCPServer.server_bind(self)

1211

1212

1213

class MandosServer(IPv6_TCPServer):

1214

"""Mandos server.

1215

1216

Attributes:

1217

clients: set of Client objects

1218

gnutls_priority GnuTLS priority string

1219

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

1220

1221

Assumes a gobject.MainLoop event loop.

1222

"""

1223

def __init__(self, server_address, RequestHandlerClass,

1224

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

1225

gnutls_priority=None, use_dbus=True):

1226

self.enabled = False

1227

self.clients = clients

1228

if self.clients is None:

1229

self.clients = set()

1230

self.use_dbus = use_dbus

1231

self.gnutls_priority = gnutls_priority

1232

IPv6_TCPServer.__init__(self, server_address,

1233

RequestHandlerClass,

1234

interface = interface,

1235

use_ipv6 = use_ipv6)

1236

def server_activate(self):

1237

if self.enabled:

1238

return socketserver.TCPServer.server_activate(self)

1239

def enable(self):

1240

self.enabled = True

1241

def add_pipe(self, pipe):

1242

# Call "handle_ipc" for both data and EOF events

1243

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

1244

self.handle_ipc)

1245

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

1246

condition_names = {

1247

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

1248

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

1249

# blocking).

1250

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

1251

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

1252

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

1253

# broken, usually for pipes and

1254

# sockets).

1255

}

1256

conditions_string = ' | '.join(name

1257

for cond, name in

1258

condition_names.iteritems()

1259

if cond & condition)

1260

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

1261

conditions_string)

1262

1263

# Turn the pipe file descriptor into a Python file object

1264

if source not in file_objects:

1265

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

1266

1267

# Read a line from the file object

1268

cmdline = file_objects[source].readline()

1269

if not cmdline: # Empty line means end of file

1270

# close the IPC pipe

1271

file_objects[source].close()

1272

del file_objects[source]

1273

1274

# Stop calling this function

1275

return False

1276

1277

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

1278

1279

# Parse and act on command

1280

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

1281

1282

if cmd == u"NOTFOUND":

1283

fpr, address = args.split(None, 1)

1284

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

1285

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

1286

if self.use_dbus:

1287

# Emit D-Bus signal

1288

mandos_dbus_service.ClientNotFound(fpr, address)

1289

elif cmd == u"INVALID":

1290

for client in self.clients:

1291

if client.name == args:

1292

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

1293

if self.use_dbus:

1294

# Emit D-Bus signal

1295

client.Rejected()

1296

break

1297

else:

1298

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

1299

elif cmd == u"SENDING":

1300

for client in self.clients:

1301

if client.name == args:

1302

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

1303

client.checked_ok()

1304

if self.use_dbus:

1305

# Emit D-Bus signal

1306

client.GotSecret()

1307

break

1308

else:

1309

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

1310

args)

1311

else:

1312

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

1313

1314

# Keep calling this function

1315

return True

1316

127

1317

128

1318

def string_to_delta(interval):

129

1319

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

130

131

>>> string_to_delta('7d')

1320

1321

>>> string_to_delta(u'7d')

132

1322

datetime.timedelta(7)

133

>>> string_to_delta('60s')

1323

>>> string_to_delta(u'60s')

134

1324

datetime.timedelta(0, 60)

135

>>> string_to_delta('60m')

1325

>>> string_to_delta(u'60m')

136

1326

datetime.timedelta(0, 3600)

137

>>> string_to_delta('24h')

1327

>>> string_to_delta(u'24h')

138

1328

datetime.timedelta(1)

139

1329

>>> string_to_delta(u'1w')

140

1330

datetime.timedelta(7)

1331

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

1332

datetime.timedelta(0, 330)

141

1333

"""

1334

timevalue = datetime.timedelta(0)

1335

for s in interval.split():

1336

try:

1337

suffix = unicode(s[-1])

1338

value = int(s[:-1])

1339

if suffix == u"d":

1340

delta = datetime.timedelta(value)

1341

elif suffix == u"s":

1342

delta = datetime.timedelta(0, value)

1343

elif suffix == u"m":

1344

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

1345

elif suffix == u"h":

1346

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

1347

elif suffix == u"w":

1348

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

1349

else:

1350

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

1351

except (ValueError, IndexError), e:

1352

raise ValueError(e.message)

1353

timevalue += delta

1354

return timevalue

1355

1356

1357

def if_nametoindex(interface):

1358

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

1359

1360

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

1361

global if_nametoindex

142

1362

try:

143

suffix=unicode(interval[-1])

144

value=int(interval[:-1])

145

if suffix == u"d":

146

delta = datetime.timedelta(value)

147

elif suffix == u"s":

148

delta = datetime.timedelta(0, value)

149

elif suffix == u"m":

150

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

151

elif suffix == u"h":

152

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

153

elif suffix == u"w":

154

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

155

else:

156

raise ValueError

157

except (ValueError, IndexError):

158

raise ValueError

159

return delta

1363

if_nametoindex = (ctypes.cdll.LoadLibrary

1364

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

1365

.if_nametoindex)

1366

except (OSError, AttributeError):

1367

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

1368

def if_nametoindex(interface):

1369

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

1370

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

1371

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

1372

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1373

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

1374

interface))

1375

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

1376

ifreq[16:20])[0]

1377

return interface_index

1378

return if_nametoindex(interface)

1379

1380

1381

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

1382

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

1383

1384

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

1385

if os.fork():

1386

sys.exit()

1387

os.setsid()

1388

if not nochdir:

1389

os.chdir(u"/")

1390

if os.fork():

1391

sys.exit()

1392

if not noclose:

1393

# Close all standard open file descriptors

1394

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

1395

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

1396

raise OSError(errno.ENODEV,

1397

u"%s not a character device"

1398

% os.path.devnull)

1399

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

1400

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

1401

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

1402

if null > 2:

1403

os.close(null)

1404

160

1405

161

1406

def main():

162

parser = OptionParser()

163

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

164

default="eth0", metavar="IF",

165

help="Interface to bind to")

166

parser.add_option("--cert", type="string", default="cert.pem",

167

metavar="FILE",

168

help="Public key certificate to use")

169

parser.add_option("--key", type="string", default="key.pem",

170

metavar="FILE",

171

help="Private key to use")

172

parser.add_option("--ca", type="string", default="ca.pem",

173

metavar="FILE",

174

help="Certificate Authority certificate to use")

175

parser.add_option("--crl", type="string", default="crl.pem",

176

metavar="FILE",

177

help="Certificate Revokation List to use")

178

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

179

help="Port number to receive requests on")

180

parser.add_option("--dh", type="int", metavar="BITS",

181

help="DH group to use")

182

parser.add_option("-t", "--timeout", type="string", # Parsed later

183

default="15m",

184

help="Amount of downtime allowed for clients")

185

parser.add_option("--interval", type="string", # Parsed later

186

default="5m",

187

help="How often to check that a client is up")

188

parser.add_option("--check", action="store_true", default=False,

189

help="Run self-test")

190

(options, args) = parser.parse_args()

191

1407

1408

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

1409

# Parsing of options, both command line and config file

1410

1411

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

1412

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

1413

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

1414

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

1415

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

1416

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

1417

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

1418

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

1419

help=u"Run self-test")

1420

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

1421

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

1422

u" terminal")

1423

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

1424

u" priority string (see GnuTLS documentation)")

1425

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

1426

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

1427

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

1428

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

1429

help=u"Directory to search for configuration"

1430

u" files")

1431

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

1432

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

1433

u" system bus interface")

1434

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

1435

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

1436

options = parser.parse_args()[0]

1437

192

1438

if options.check:

193

1439

import doctest

194

1440

doctest.testmod()

195

1441

sys.exit()

196

1442

197

# Parse the time arguments

198

try:

199

options.timeout = string_to_delta(options.timeout)

200

except ValueError:

201

parser.error("option --timeout: Unparseable time")

202

203

try:

204

options.interval = string_to_delta(options.interval)

205

except ValueError:

206

parser.error("option --interval: Unparseable time")

207

208

cert = gnutls.crypto.X509Certificate(open(options.cert).read())

209

key = gnutls.crypto.X509PrivateKey(open(options.key).read())

210

ca = gnutls.crypto.X509Certificate(open(options.ca).read())

211

crl = gnutls.crypto.X509CRL(open(options.crl).read())

212

cred = gnutls.connection.X509Credentials(cert, key, [ca], [crl])

213

214

# Parse config file

215

defaults = {}

216

client_config_object = ConfigParser.SafeConfigParser(defaults)

217

client_config_object.read("mandos-clients.conf")

218

clients = [Client(name=section, options=options,

219

**(dict(client_config_object.items(section))))

220

for section in client_config_object.sections()]

221

222

udp_server = IPv6_UDPServer((in6addr_any, options.port),

223

udp_handler,

224

options=options)

225

226

tcp_server = IPv6_TCPServer((in6addr_any, options.port),

227

tcp_handler,

228

options=options,

229

clients=clients,

230

credentials=cred)

231

232

while True:

233

in_, out, err = select.select((udp_server,

234

tcp_server), (), ())

235

for server in in_:

236

server.handle_request()

237

238

239

if __name__ == "__main__":

1443

# Default values for config file for server-global settings

1444

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

1445

u"address": u"",

1446

u"port": u"",

1447

u"debug": u"False",

1448

u"priority":

1449

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

1450

u"servicename": u"Mandos",

1451

u"use_dbus": u"True",

1452

u"use_ipv6": u"True",

1453

}

1454

1455

# Parse config file for server-global settings

1456

server_config = configparser.SafeConfigParser(server_defaults)

1457

del server_defaults

1458

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

1459

u"mandos.conf"))

1460

# Convert the SafeConfigParser object to a dict

1461

server_settings = server_config.defaults()

1462

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

1463

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

1464

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

1465

option)

1466

if server_settings["port"]:

1467

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

1468

u"port")

1469

del server_config

1470

1471

# Override the settings from the config file with command line

1472

# options, if set.

1473

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

1474

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

1475

u"use_dbus", u"use_ipv6"):

1476

value = getattr(options, option)

1477

if value is not None:

1478

server_settings[option] = value

1479

del options

1480

# Force all strings to be unicode

1481

for option in server_settings.keys():

1482

if type(server_settings[option]) is str:

1483

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

1484

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

1485

1486

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

1487

1488

# For convenience

1489

debug = server_settings[u"debug"]

1490

use_dbus = server_settings[u"use_dbus"]

1491

use_ipv6 = server_settings[u"use_ipv6"]

1492

1493

if not debug:

1494

syslogger.setLevel(logging.WARNING)

1495

console.setLevel(logging.WARNING)

1496

1497

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

1498

syslogger.setFormatter(logging.Formatter

1499

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

1500

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

1501

% server_settings[u"servicename"]))

1502

1503

# Parse config file with clients

1504

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

1505

u"interval": u"5m",

1506

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

1507

u"host": u"",

1508

}

1509

client_config = configparser.SafeConfigParser(client_defaults)

1510

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

1511

u"clients.conf"))

1512

1513

global mandos_dbus_service

1514

mandos_dbus_service = None

1515

1516

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

1517

server_settings[u"port"]),

1518

ClientHandler,

1519

interface=server_settings[u"interface"],

1520

use_ipv6=use_ipv6,

1521

gnutls_priority=

1522

server_settings[u"priority"],

1523

use_dbus=use_dbus)

1524

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

1525

try:

1526

pidfile = open(pidfilename, u"w")

1527

except IOError:

1528

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

1529

1530

try:

1531

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

1532

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

1533

except KeyError:

1534

try:

1535

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

1536

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

1537

except KeyError:

1538

try:

1539

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

1540

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

1541

except KeyError:

1542

uid = 65534

1543

gid = 65534

1544

try:

1545

os.setgid(gid)

1546

os.setuid(uid)

1547

except OSError, error:

1548

if error[0] != errno.EPERM:

1549

raise error

1550

1551

# Enable all possible GnuTLS debugging

1552

if debug:

1553

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

1554

# - GnuTLS manual

1555

gnutls.library.functions.gnutls_global_set_log_level(11)

1556

1557

@gnutls.library.types.gnutls_log_func

1558

def debug_gnutls(level, string):

1559

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

1560

1561

(gnutls.library.functions

1562

.gnutls_global_set_log_function(debug_gnutls))

1563

1564

global main_loop

1565

# From the Avahi example code

1566

DBusGMainLoop(set_as_default=True )

1567

main_loop = gobject.MainLoop()

1568

bus = dbus.SystemBus()

1569

# End of Avahi example code

1570

if use_dbus:

1571

try:

1572

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

1573

bus, do_not_queue=True)

1574

except dbus.exceptions.NameExistsException, e:

1575

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

1576

use_dbus = False

1577

server_settings[u"use_dbus"] = False

1578

tcp_server.use_dbus = False

1579

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1580

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

1581

servicetype = u"_mandos._tcp",

1582

protocol = protocol, bus = bus)

1583

if server_settings["interface"]:

1584

service.interface = (if_nametoindex

1585

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

1586

1587

client_class = Client

1588

if use_dbus:

1589

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

1590

tcp_server.clients.update(set(

1591

client_class(name = section,

1592

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

1593

for section in client_config.sections()))

1594

if not tcp_server.clients:

1595

logger.warning(u"No clients defined")

1596

1597

if debug:

1598

# Redirect stdin so all checkers get /dev/null

1599

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

1600

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

1601

if null > 2:

1602

os.close(null)

1603

else:

1604

# No console logging

1605

logger.removeHandler(console)

1606

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

1607

daemon()

1608

1609

try:

1610

with closing(pidfile):

1611

pid = os.getpid()

1612

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

1613

del pidfile

1614

except IOError:

1615

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

1616

pidfilename, pid)

1617

except NameError:

1618

# "pidfile" was never created

1619

pass

1620

del pidfilename

1621

1622

if not debug:

1623

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

1624

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

1625

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

1626

1627

if use_dbus:

1628

class MandosDBusService(dbus.service.Object):

1629

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

1630

def __init__(self):

1631

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

1632

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

1633

1634

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

1635

def ClientAdded(self, objpath, properties):

1636

"D-Bus signal"

1637

pass

1638

1639

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

1640

def ClientNotFound(self, fingerprint, address):

1641

"D-Bus signal"

1642

pass

1643

1644

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

1645

def ClientRemoved(self, objpath, name):

1646

"D-Bus signal"

1647

pass

1648

1649

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

1650

def GetAllClients(self):

1651

"D-Bus method"

1652

return dbus.Array(c.dbus_object_path

1653

for c in tcp_server.clients)

1654

1655

@dbus.service.method(_interface,

1656

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

1657

def GetAllClientsWithProperties(self):

1658

"D-Bus method"

1659

return dbus.Dictionary(

1660

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

1661

for c in tcp_server.clients),

1662

signature=u"oa{sv}")

1663

1664

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

1665

def RemoveClient(self, object_path):

1666

"D-Bus method"

1667

for c in tcp_server.clients:

1668

if c.dbus_object_path == object_path:

1669

tcp_server.clients.remove(c)

1670

c.remove_from_connection()

1671

# Don't signal anything except ClientRemoved

1672

c.disable(quiet=True)

1673

# Emit D-Bus signal

1674

self.ClientRemoved(object_path, c.name)

1675

return

1676

raise KeyError(object_path)

1677

1678

del _interface

1679

1680

mandos_dbus_service = MandosDBusService()

1681

1682

def cleanup():

1683

"Cleanup function; run on exit"

1684

service.cleanup()

1685

1686

while tcp_server.clients:

1687

client = tcp_server.clients.pop()

1688

if use_dbus:

1689

client.remove_from_connection()

1690

client.disable_hook = None

1691

# Don't signal anything except ClientRemoved

1692

client.disable(quiet=True)

1693

if use_dbus:

1694

# Emit D-Bus signal

1695

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

1696

client.name)

1697

1698

atexit.register(cleanup)

1699

1700

for client in tcp_server.clients:

1701

if use_dbus:

1702

# Emit D-Bus signal

1703

mandos_dbus_service.ClientAdded(client.dbus_object_path,

1704

client.GetAll(u""))

1705

client.enable()

1706

1707

tcp_server.enable()

1708

tcp_server.server_activate()

1709

1710

# Find out what port we got

1711

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

1712

if use_ipv6:

1713

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

1714

" flowinfo %d, scope_id %d"

1715

% tcp_server.socket.getsockname())

1716

else: # IPv4

1717

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

1718

% tcp_server.socket.getsockname())

1719

1720

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

1721

1722

try:

1723

# From the Avahi example code

1724

try:

1725

service.activate()

1726

except dbus.exceptions.DBusException, error:

1727

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

1728

cleanup()

1729

sys.exit(1)

1730

# End of Avahi example code

1731

1732

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

1733

lambda *args, **kwargs:

1734

(tcp_server.handle_request

1735

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

1736

1737

logger.debug(u"Starting main loop")

1738

main_loop.run()

1739

except AvahiError, error:

1740

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

1741

cleanup()

1742

sys.exit(1)

1743

except KeyboardInterrupt:

1744

if debug:

1745

print >> sys.stderr

1746

logger.debug(u"Server received KeyboardInterrupt")

1747

logger.debug(u"Server exiting")

1748

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

1749

cleanup()

1750

1751

if __name__ == '__main__':

240

1752

main()

241