/mandos/trunk : revision 25

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

# following functions: "add_service", "remove_service",

10

# "server_state_changed", "entry_group_state_changed", and some lines

11

# in "main".

12

#

13

14

# Påhlsson.

15

#

16

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

17

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

18

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

19

# (at your option) any later version.

20

#

21

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

22

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

23

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

24

# GNU General Public License for more details.

25

#

26

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

27

# along with this program. If not, see <http://www.gnu.org/licenses/>.

28

#

29

# Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and

30

# <https://www.fukt.bsnet.se/~teddy/>.

31

#

2

32

3

33

from __future__ import division

4

34

11

41

import gnutls.crypto

12

42

import gnutls.connection

13

43

import gnutls.errors

44

import gnutls.library.functions

45

import gnutls.library.constants

46

import gnutls.library.types

14

47

import ConfigParser

15

48

import sys

16

49

import re

18

51

import signal

19

52

from sets import Set

20

53

import subprocess

54

import atexit

55

import stat

56

import logging

57

import logging.handlers

21

58

22

59

import dbus

23

60

import gobject

24

61

import avahi

25

62

from dbus.mainloop.glib import DBusGMainLoop

26

27

# This variable is used to optionally bind to a specified

28

# interface.

63

import ctypes

64

65

# Brief description of the operation of this program:

66

#

67

# This server announces itself as a Zeroconf service. Connecting

68

# clients use the TLS protocol, with the unusual quirk that this

69

# server program acts as a TLS "client" while the connecting clients

70

# acts as a TLS "server". The clients (acting as a TLS "server") must

71

# supply an OpenPGP certificate, and the fingerprint of this

72

# certificate is used by this server to look up (in a list read from a

73

# file at start time) which binary blob to give the client. No other

74

# authentication or authorization is done by this server.

75

76

77

logger = logging.Logger('mandos')

78

syslogger = logging.handlers.SysLogHandler\

79

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

80

syslogger.setFormatter(logging.Formatter\

81

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

82

logger.addHandler(syslogger)

83

del syslogger

84

85

# This variable is used to optionally bind to a specified interface.

86

# It is a global variable to fit in with the other variables from the

87

# Avahi example code.

29

88

serviceInterface = avahi.IF_UNSPEC

30

# It is a global variable to fit in with the rest of the

31

# variables from the Avahi server example code:

32

serviceName = "Mandos"

89

# From the Avahi example code:

90

serviceName = None

33

91

serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html

34

92

servicePort = None # Not known at startup

35

93

serviceTXT = [] # TXT record for the service

44

102

class Client(object):

45

103

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

46

104

Attributes:

47

password: string

48

fqdn: string, FQDN (used by the checker)

105

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

106

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

107

uniquely identify the client

108

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

109

fqdn: string (FQDN); available for use by the checker command

49

110

created: datetime.datetime()

50

111

last_seen: datetime.datetime() or None if not yet seen

51

112

timeout: datetime.timedelta(); How long from last_seen until

52

113

this client is invalid

53

114

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

54

timeout_milliseconds: Used by gobject.timeout_add()

55

interval_milliseconds: - '' -

56

115

stop_hook: If set, called by stop() as stop_hook(self)

57

116

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

58

117

to see if the client lives.

60

119

checker_initiator_tag: a gobject event source tag, or None

61

120

stop_initiator_tag: - '' -

62

121

checker_callback_tag: - '' -

122

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

123

client lives. %()s expansions are done at

124

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

125

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

126

Private attibutes:

127

_timeout: Real variable for 'timeout'

128

_interval: Real variable for 'interval'

129

_timeout_milliseconds: Used by gobject.timeout_add()

130

_interval_milliseconds: - '' -

63

131

"""

64

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

65

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

66

timeout=None, interval=-1):

132

def _set_timeout(self, timeout):

133

"Setter function for 'timeout' attribute"

134

self._timeout = timeout

135

self._timeout_milliseconds = ((self.timeout.days

136

* 24 * 60 * 60 * 1000)

137

+ (self.timeout.seconds * 1000)

138

+ (self.timeout.microseconds

139

// 1000))

140

timeout = property(lambda self: self._timeout,

141

_set_timeout)

142

del _set_timeout

143

def _set_interval(self, interval):

144

"Setter function for 'interval' attribute"

145

self._interval = interval

146

self._interval_milliseconds = ((self.interval.days

147

* 24 * 60 * 60 * 1000)

148

+ (self.interval.seconds

149

* 1000)

150

+ (self.interval.microseconds

151

// 1000))

152

interval = property(lambda self: self._interval,

153

_set_interval)

154

del _set_interval

155

def __init__(self, name=None, stop_hook=None, fingerprint=None,

156

secret=None, secfile=None, fqdn=None, timeout=None,

157

interval=-1, checker=None):

158

"""Note: the 'checker' argument sets the 'checker_command'

159

attribute and not the 'checker' attribute.."""

67

160

self.name = name

68

self.dn = dn

69

if password:

70

self.password = password

71

elif passfile:

72

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

161

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

162

# Uppercase and remove spaces from fingerprint

163

# for later comparison purposes with return value of

164

# the fingerprint() function

165

self.fingerprint = fingerprint.upper().replace(u" ", u"")

166

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

167

if secret:

168

self.secret = secret.decode(u"base64")

169

elif secfile:

170

sf = open(secfile)

171

self.secret = sf.read()

172

sf.close()

73

173

else:

74

raise RuntimeError(u"No Password or Passfile for client %s"

174

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

75

175

% self.name)

76

176

self.fqdn = fqdn # string

77

177

self.created = datetime.datetime.now()

78

178

self.last_seen = None

79

if timeout is None:

80

timeout = options.timeout

81

self.timeout = timeout

82

self.timeout_milliseconds = ((self.timeout.days

83

* 24 * 60 * 60 * 1000)

84

+ (self.timeout.seconds * 1000)

85

+ (self.timeout.microseconds

86

// 1000))

87

if interval == -1:

88

interval = options.interval

89

else:

90

interval = string_to_delta(interval)

91

self.interval = interval

92

self.interval_milliseconds = ((self.interval.days

93

* 24 * 60 * 60 * 1000)

94

+ (self.interval.seconds * 1000)

95

+ (self.interval.microseconds

96

// 1000))

179

self.timeout = string_to_delta(timeout)

180

self.interval = string_to_delta(interval)

97

181

self.stop_hook = stop_hook

98

182

self.checker = None

99

183

self.checker_initiator_tag = None

100

184

self.stop_initiator_tag = None

101

185

self.checker_callback_tag = None

186

self.check_command = checker

102

187

def start(self):

103

"""Start this clients checker and timeout hooks"""

188

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

104

189

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

105

190

# and every interval from then on.

106

self.checker_initiator_tag = gobject.\

107

timeout_add(self.interval_milliseconds,

108

self.start_checker)

191

self.checker_initiator_tag = gobject.timeout_add\

192

(self._interval_milliseconds,

193

self.start_checker)

109

194

# Also start a new checker *right now*.

110

195

self.start_checker()

111

196

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

112

self.stop_initiator_tag = gobject.\

113

timeout_add(self.timeout_milliseconds,

114

self.stop)

197

self.stop_initiator_tag = gobject.timeout_add\

198

(self._timeout_milliseconds,

199

self.stop)

115

200

def stop(self):

116

201

"""Stop this client.

117

202

The possibility that this client might be restarted is left

118

203

open, but not currently used."""

119

# print "Stopping client", self.name

120

self.password = None

121

if self.stop_initiator_tag:

204

# If this client doesn't have a secret, it is already stopped.

205

if self.secret:

206

logger.debug(u"Stopping client %s", self.name)

207

self.secret = None

208

else:

209

return False

210

if hasattr(self, "stop_initiator_tag") \

211

and self.stop_initiator_tag:

122

212

gobject.source_remove(self.stop_initiator_tag)

123

213

self.stop_initiator_tag = None

124

if self.checker_initiator_tag:

214

if hasattr(self, "checker_initiator_tag") \

215

and self.checker_initiator_tag:

125

216

gobject.source_remove(self.checker_initiator_tag)

126

217

self.checker_initiator_tag = None

127

218

self.stop_checker()

130

221

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

131

222

return False

132

223

def __del__(self):

133

# Some code duplication here and in stop()

134

if hasattr(self, "stop_initiator_tag") \

135

and self.stop_initiator_tag:

136

gobject.source_remove(self.stop_initiator_tag)

137

self.stop_initiator_tag = None

138

if hasattr(self, "checker_initiator_tag") \

139

and self.checker_initiator_tag:

140

gobject.source_remove(self.checker_initiator_tag)

141

self.checker_initiator_tag = None

142

self.stop_checker()

224

self.stop_hook = None

225

self.stop()

143

226

def checker_callback(self, pid, condition):

144

227

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

145

228

now = datetime.datetime.now()

229

self.checker_callback_tag = None

230

self.checker = None

146

231

if os.WIFEXITED(condition) \

147

232

and (os.WEXITSTATUS(condition) == 0):

148

#print "Checker for %(name)s succeeded" % vars(self)

233

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

234

vars(self))

149

235

self.last_seen = now

150

236

gobject.source_remove(self.stop_initiator_tag)

151

self.stop_initiator_tag = gobject.\

152

timeout_add(self.timeout_milliseconds,

153

self.stop)

154

#else:

155

# if not os.WIFEXITED(condition):

156

# print "Checker for %(name)s crashed?" % vars(self)

157

# else:

158

# print "Checker for %(name)s failed" % vars(self)

159

self.checker = None

160

self.checker_callback_tag = None

237

self.stop_initiator_tag = gobject.timeout_add\

238

(self._timeout_milliseconds,

239

self.stop)

240

elif not os.WIFEXITED(condition):

241

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

242

vars(self))

243

else:

244

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

245

vars(self))

161

246

def start_checker(self):

162

247

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

163

248

If a checker already exists, leave it running and do

164

249

nothing."""

250

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

251

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

252

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

253

# client would inevitably timeout, since no checker would get

254

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

255

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

256

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

257

# is as it should be.

165

258

if self.checker is None:

166

#print "Starting checker for", self.name

167

try:

259

try:

260

command = self.check_command % self.fqdn

261

except TypeError:

262

escaped_attrs = dict((key, re.escape(str(val)))

263

for key, val in

264

vars(self).iteritems())

265

try:

266

command = self.check_command % escaped_attrs

267

except TypeError, error:

268

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

269

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

270

return True # Try again later

271

try:

272

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

273

command, self.name)

168

274

self.checker = subprocess.\

169

Popen("sleep 1; fping -q -- %s"

170

% re.escape(self.fqdn),

171

stdout=subprocess.PIPE,

275

Popen(command,

172

276

close_fds=True, shell=True,

173

277

cwd="/")

174

self.checker_callback_tag = gobject.\

175

child_watch_add(self.checker.pid,

176

self.\

177

checker_callback)

278

self.checker_callback_tag = gobject.child_watch_add\

279

(self.checker.pid,

280

self.checker_callback)

178

281

except subprocess.OSError, error:

179

sys.stderr.write(u"Failed to start subprocess: %s\n"

180

% error)

282

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

283

error)

181

284

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

182

285

return True

183

286

def stop_checker(self):

184

287

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

288

if self.checker_callback_tag:

289

gobject.source_remove(self.checker_callback_tag)

290

self.checker_callback_tag = None

185

291

if not hasattr(self, "checker") or self.checker is None:

186

292

return

187

gobject.source_remove(self.checker_callback_tag)

188

self.checker_callback_tag = None

189

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

190

if self.checker.poll() is None:

191

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

293

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

294

try:

295

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

296

#os.sleep(0.5)

297

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

298

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

299

except OSError, error:

300

if error.errno != errno.ESRCH:

301

raise

192

302

self.checker = None

193

303

def still_valid(self, now=None):

194

304

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

200

310

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

201

311

202

312

313

def peer_certificate(session):

314

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

315

# If not an OpenPGP certificate...

316

if gnutls.library.functions.gnutls_certificate_type_get\

317

(session._c_object) \

318

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:

319

# ...do the normal thing

320

return session.peer_certificate

321

list_size = ctypes.c_uint()

322

cert_list = gnutls.library.functions.gnutls_certificate_get_peers\

323

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

324

if list_size.value == 0:

325

return None

326

cert = cert_list[0]

327

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

328

329

330

def fingerprint(openpgp):

331

"Convert an OpenPGP bytestring to a hexdigit fingerprint string"

332

# New empty GnuTLS certificate

333

crt = gnutls.library.types.gnutls_openpgp_crt_t()

334

gnutls.library.functions.gnutls_openpgp_crt_init\

335

(ctypes.byref(crt))

336

# New GnuTLS "datum" with the OpenPGP public key

337

datum = gnutls.library.types.gnutls_datum_t\

338

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

339

ctypes.POINTER(ctypes.c_ubyte)),

340

ctypes.c_uint(len(openpgp)))

341

# Import the OpenPGP public key into the certificate

342

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

343

(crt,

344

ctypes.byref(datum),

345

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

346

# New buffer for the fingerprint

347

buffer = ctypes.create_string_buffer(20)

348

buffer_length = ctypes.c_size_t()

349

# Get the fingerprint from the certificate into the buffer

350

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\

351

(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))

352

# Deinit the certificate

353

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

354

# Convert the buffer to a Python bytestring

355

fpr = ctypes.string_at(buffer, buffer_length.value)

356

# Convert the bytestring to hexadecimal notation

357

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

358

return hex_fpr

359

360

203

361

class tcp_handler(SocketServer.BaseRequestHandler, object):

204

362

"""A TCP request handler class.

205

363

Instantiated by IPv6_TCPServer for each request to handle it.

206

364

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

365

207

366

def handle(self):

208

#print u"TCP request came"

209

#print u"Request:", self.request

210

#print u"Client Address:", self.client_address

211

#print u"Server:", self.server

212

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

213

self.server\

214

.credentials)

367

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

368

unicode(self.client_address))

369

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

370

gnutls.connection.\

371

X509Credentials())

372

373

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

374

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

375

# "+DHE-DSS"))

376

priority = "NORMAL"

377

if self.server.options.priority:

378

priority = self.server.options.priority

379

gnutls.library.functions.gnutls_priority_set_direct\

380

(session._c_object, priority, None);

381

215

382

try:

216

383

session.handshake()

217

384

except gnutls.errors.GNUTLSError, error:

218

#sys.stderr.write(u"Handshake failed: %s\n" % error)

385

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

219

386

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

220

387

# established. Just abandon the request.

221

388

return

222

#if session.peer_certificate:

223

# print "DN:", session.peer_certificate.subject

224

389

try:

225

session.verify_peer()

226

except gnutls.errors.CertificateError, error:

227

#sys.stderr.write(u"Verify failed: %s\n" % error)

390

fpr = fingerprint(peer_certificate(session))

391

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

392

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

228

393

session.bye()

229

394

return

395

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

230

396

client = None

231

for c in clients:

232

if c.dn == session.peer_certificate.subject:

397

for c in self.server.clients:

398

if c.fingerprint == fpr:

233

399

client = c

234

400

break

235

401

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

236

402

# that the client timed out while establishing the GnuTLS

237

403

# session.

238

if client and client.still_valid():

239

session.send(client.password)

240

else:

241

#if client:

242

# sys.stderr.write(u"Client %(name)s is invalid\n"

243

# % vars(client))

244

#else:

245

# sys.stderr.write(u"Client not found for DN: %s\n"

246

# % session.peer_certificate.subject)

247

#session.send("gazonk")

248

pass

404

if (not client) or (not client.still_valid()):

405

if client:

406

logger.debug(u"Client %(name)s is invalid",

407

vars(client))

408

else:

409

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

410

fpr)

411

session.bye()

412

return

413

sent_size = 0

414

while sent_size < len(client.secret):

415

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

416

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

417

sent, len(client.secret)

418

- (sent_size + sent))

419

sent_size += sent

249

420

session.bye()

250

421

251

422

254

425

Attributes:

255

426

options: Command line options

256

427

clients: Set() of Client objects

257

credentials: GnuTLS X.509 credentials

258

428

"""

259

429

address_family = socket.AF_INET6

260

430

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

264

434

if "clients" in kwargs:

265

435

self.clients = kwargs["clients"]

266

436

del kwargs["clients"]

267

if "credentials" in kwargs:

268

self.credentials = kwargs["credentials"]

269

del kwargs["credentials"]

270

437

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

271

438

def server_bind(self):

272

439

"""This overrides the normal server_bind() function

282

449

self.options.interface)

283

450

except socket.error, error:

284

451

if error[0] == errno.EPERM:

285

sys.stderr.write(u"Warning: No permission to bind to interface %s\n"

286

% self.options.interface)

452

logger.warning(u"No permission to"

453

u" bind to interface %s",

454

self.options.interface)

287

455

else:

288

456

raise error

289

457

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

333

501

334

502

335

503

def add_service():

336

"""From the Avahi server example code"""

504

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

337

505

global group, serviceName, serviceType, servicePort, serviceTXT, \

338

506

domain, host

339

507

if group is None:

343

511

avahi.DBUS_INTERFACE_ENTRY_GROUP)

344

512

group.connect_to_signal('StateChanged',

345

513

entry_group_state_changed)

346

347

# print "Adding service '%s' of type '%s' ..." % (serviceName,

348

# serviceType)

514

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

515

serviceName, serviceType)

349

516

350

517

group.AddService(

351

518

serviceInterface, # interface

359

526

360

527

361

528

def remove_service():

362

"""From the Avahi server example code"""

529

"""From the Avahi example code"""

363

530

global group

364

531

365

532

if not group is None:

367

534

368

535

369

536

def server_state_changed(state):

370

"""From the Avahi server example code"""

537

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

371

538

if state == avahi.SERVER_COLLISION:

372

print "WARNING: Server name collision"

539

logger.warning(u"Server name collision")

373

540

remove_service()

374

541

elif state == avahi.SERVER_RUNNING:

375

542

add_service()

376

543

377

544

378

545

def entry_group_state_changed(state, error):

379

"""From the Avahi server example code"""

546

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

380

547

global serviceName, server, rename_count

381

548

382

# print "state change: %i" % state

549

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

383

550

384

551

if state == avahi.ENTRY_GROUP_ESTABLISHED:

385

pass

386

# print "Service established."

552

logger.debug(u"Service established.")

387

553

elif state == avahi.ENTRY_GROUP_COLLISION:

388

554

389

555

rename_count = rename_count - 1

390

556

if rename_count > 0:

391

557

name = server.GetAlternativeServiceName(name)

392

print "WARNING: Service name collision, changing name to '%s' ..." % name

558

logger.warning(u"Service name collision, "

559

u"changing name to '%s' ...", name)

393

560

remove_service()

394

561

add_service()

395

562

396

563

else:

397

print "ERROR: No suitable service name found after %i retries, exiting." % n_rename

398

main_loop.quit()

564

logger.error(u"No suitable service name found after %i"

565

u" retries, exiting.", n_rename)

566

killme(1)

399

567

elif state == avahi.ENTRY_GROUP_FAILURE:

400

print "Error in group state changed", error

401

main_loop.quit()

402

return

568

logger.error(u"Error in group state changed %s",

569

unicode(error))

570

killme(1)

403

571

404

572

405

573

def if_nametoindex(interface):

406

574

"""Call the C function if_nametoindex()"""

407

575

try:

408

if "ctypes" not in sys.modules:

409

import ctypes

410

576

libc = ctypes.cdll.LoadLibrary("libc.so.6")

411

577

return libc.if_nametoindex(interface)

412

except (ImportError, OSError, AttributeError):

578

except (OSError, AttributeError):

413

579

if "struct" not in sys.modules:

414

580

import struct

415

581

if "fcntl" not in sys.modules:

423

589

return interface_index

424

590

425

591

426

if __name__ == '__main__':

592

def daemon(nochdir, noclose):

593

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

594

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

595

if os.fork():

596

sys.exit()

597

os.setsid()

598

if not nochdir:

599

os.chdir("/")

600

if not noclose:

601

# Close all standard open file descriptors

602

null = os.open("/dev/null", os.O_NOCTTY | os.O_RDWR)

603

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

604

raise OSError(errno.ENODEV,

605

"/dev/null not a character device")

606

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

607

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

608

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

609

if null > 2:

610

os.close(null)

611

612

613

def killme(status = 0):

614

logger.debug("Stopping server with exit status %d", status)

615

exitstatus = status

616

if main_loop_started:

617

main_loop.quit()

618

else:

619

sys.exit(status)

620

621

622

def main():

623

global exitstatus

624

exitstatus = 0

625

global main_loop_started

626

main_loop_started = False

627

427

628

parser = OptionParser()

428

629

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

429

630

default=None, metavar="IF",

430

631

help="Bind to interface IF")

431

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

432

metavar="FILE",

433

help="Public key certificate PEM file to use")

434

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

435

metavar="FILE",

436

help="Private key PEM file to use")

437

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

438

metavar="FILE",

439

help="Certificate Authority certificate PEM file to use")

440

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

441

metavar="FILE",

442

help="Certificate Revokation List PEM file to use")

632

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

633

help="Address to listen for requests on")

443

634

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

444

635

help="Port number to receive requests on")

445

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

446

default="1h",

447

help="Amount of downtime allowed for clients")

448

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

449

default="5m",

450

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

451

636

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

452

637

help="Run self-test")

638

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

639

help="Debug mode")

640

parser.add_option("--priority", type="string",

641

default="SECURE256",

642

help="GnuTLS priority string"

643

" (see GnuTLS documentation)")

644

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

645

default="Mandos", help="Zeroconf service name")

453

646

(options, args) = parser.parse_args()

454

647

455

648

if options.check:

457

650

doctest.testmod()

458

651

sys.exit()

459

652

460

# Parse the time arguments

461

try:

462

options.timeout = string_to_delta(options.timeout)

463

except ValueError:

464

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

465

try:

466

options.interval = string_to_delta(options.interval)

467

except ValueError:

468

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

469

470

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

471

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

472

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

473

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

474

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

475

476

653

# Parse config file

477

defaults = {}

654

defaults = { "timeout": "1h",

655

"interval": "5m",

656

"checker": "fping -q -- %%(fqdn)s",

657

}

478

658

client_config = ConfigParser.SafeConfigParser(defaults)

479

#client_config.readfp(open("secrets.conf"), "secrets.conf")

659

#client_config.readfp(open("global.conf"), "global.conf")

480

660

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

481

661

482

# From the Avahi server example code

662

global serviceName

663

serviceName = options.servicename;

664

665

global main_loop

666

global bus

667

global server

668

# From the Avahi example code

483

669

DBusGMainLoop(set_as_default=True )

484

670

main_loop = gobject.MainLoop()

485

671

bus = dbus.SystemBus()

488

674

avahi.DBUS_INTERFACE_SERVER )

489

675

# End of Avahi example code

490

676

677

debug = options.debug

678

679

if debug:

680

console = logging.StreamHandler()

681

# console.setLevel(logging.DEBUG)

682

console.setFormatter(logging.Formatter\

683

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

684

logger.addHandler(console)

685

del console

686

491

687

clients = Set()

492

688

def remove_from_clients(client):

493

689

clients.remove(client)

494

690

if not clients:

495

print "No clients left, exiting"

496

main_loop.quit()

691

logger.debug(u"No clients left, exiting")

692

killme()

497

693

498

clients.update(Set(Client(name=section, options=options,

694

clients.update(Set(Client(name=section,

499

695

stop_hook = remove_from_clients,

500

696

**(dict(client_config\

501

697

.items(section))))

502

698

for section in client_config.sections()))

699

700

if not debug:

701

daemon(False, False)

702

703

def cleanup():

704

"Cleanup function; run on exit"

705

global group

706

# From the Avahi example code

707

if not group is None:

708

group.Free()

709

group = None

710

# End of Avahi example code

711

712

while clients:

713

client = clients.pop()

714

client.stop_hook = None

715

client.stop()

716

717

atexit.register(cleanup)

718

719

if not debug:

720

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

721

signal.signal(signal.SIGHUP, lambda signum, frame: killme())

722

signal.signal(signal.SIGTERM, lambda signum, frame: killme())

723

503

724

for client in clients:

504

725

client.start()

505

726

506

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

727

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

507

728

tcp_handler,

508

729

options=options,

509

clients=clients,

510

credentials=cred)

730

clients=clients)

511

731

# Find out what random port we got

732

global servicePort

512

733

servicePort = tcp_server.socket.getsockname()[1]

513

#sys.stderr.write("Now listening on port %d\n" % servicePort)

734

logger.debug(u"Now listening on port %d", servicePort)

514

735

515

736

if options.interface is not None:

737

global serviceInterface

516

738

serviceInterface = if_nametoindex(options.interface)

517

739

518

# From the Avahi server example code

740

# From the Avahi example code

519

741

server.connect_to_signal("StateChanged", server_state_changed)

520

server_state_changed(server.GetState())

742

try:

743

server_state_changed(server.GetState())

744

except dbus.exceptions.DBusException, error:

745

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

746

killme(1)

521

747

# End of Avahi example code

522

748

523

749

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

525

751

tcp_server.handle_request(*args[2:],

526

752

**kwargs) or True)

527

753

try:

754

logger.debug("Starting main loop")

755

main_loop_started = True

528

756

main_loop.run()

529

757

except KeyboardInterrupt:

530

print

758

if debug:

759

print

531

760

532

# Cleanup here

761

sys.exit(exitstatus)

533

762

534

# From the Avahi server example code

535

if not group is None:

536

group.Free()

537

# End of Avahi example code

538

539

for client in clients:

540

client.stop_hook = None

541

client.stop()

763

if __name__ == '__main__':

764

main()