/mandos/trunk : revision 47

1

#!/usr/bin/python

2

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

3

#

4

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

5

#

6

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

7

# service publisher, downloaded from

8

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

9

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

10

# "server_state_changed" and "entry_group_state_changed" functions,

11

# and some lines in "main".

12

#

13

# Everything else is

14

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 <mandos@fukt.bsnet.se>.

30

#

3

31

4

32

from __future__ import division

5

33

24

52

import subprocess

25

53

import atexit

26

54

import stat

55

import logging

56

import logging.handlers

27

57

28

58

import dbus

29

59

import gobject

31

61

from dbus.mainloop.glib import DBusGMainLoop

32

62

import ctypes

33

63

34

import logging

35

import logging.handlers

36

64

37

65

logger = logging.Logger('mandos')

38

66

syslogger = logging.handlers.SysLogHandler\

42

70

logger.addHandler(syslogger)

43

71

del syslogger

44

72

45

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

46

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

47

# Avahi server example code.

48

serviceInterface = avahi.IF_UNSPEC

49

# From the Avahi server example code:

50

serviceName = "Mandos"

51

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

52

servicePort = None # Not known at startup

53

serviceTXT = [] # TXT record for the service

54

domain = "" # Domain to publish on, default to .local

55

host = "" # Host to publish records for, default to localhost

56

group = None #our entry group

57

rename_count = 12 # Counter so we only rename after collisions a

58

# sensible number of times

73

74

class AvahiError(Exception):

75

def __init__(self, value):

76

self.value = value

77

def __str__(self):

78

return repr(self.value)

79

80

class AvahiServiceError(AvahiError):

81

pass

82

83

class AvahiGroupError(AvahiError):

84

pass

85

86

87

class AvahiService(object):

88

"""An Avahi (Zeroconf) service.

89

Attributes:

90

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

91

Used to optionally bind to the specified interface.

92

name: string; Example: 'Mandos'

93

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

94

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

95

port: integer; what port to announce

96

TXT: list of strings; TXT record for the service

97

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

98

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

99

max_renames: integer; maximum number of renames

100

rename_count: integer; counter so we only rename after collisions

101

a sensible number of times

102

"""

103

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

104

type = None, port = None, TXT = None, domain = "",

105

host = "", max_renames = 12):

106

self.interface = interface

107

self.name = name

108

self.type = type

109

self.port = port

110

if TXT is None:

111

self.TXT = []

112

else:

113

self.TXT = TXT

114

self.domain = domain

115

self.host = host

116

self.rename_count = 0

117

def rename(self):

118

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

119

if self.rename_count >= self.max_renames:

120

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

121

u" retries, exiting.", rename_count)

122

raise AvahiServiceError("Too many renames")

123

name = server.GetAlternativeServiceName(name)

124

logger.error(u"Changing name to %r ...", name)

125

self.remove()

126

self.add()

127

self.rename_count += 1

128

def remove(self):

129

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

130

if group is not None:

131

group.Reset()

132

def add(self):

133

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

134

global group

135

if group is None:

136

group = dbus.Interface\

137

(bus.get_object(avahi.DBUS_NAME,

138

server.EntryGroupNew()),

139

avahi.DBUS_INTERFACE_ENTRY_GROUP)

140

group.connect_to_signal('StateChanged',

141

entry_group_state_changed)

142

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

143

service.name, service.type)

144

group.AddService(

145

self.interface, # interface

146

avahi.PROTO_INET6, # protocol

147

dbus.UInt32(0), # flags

148

self.name, self.type,

149

self.domain, self.host,

150

dbus.UInt16(self.port),

151

avahi.string_array_to_txt_array(self.TXT))

152

group.Commit()

153

154

# From the Avahi example code:

155

group = None # our entry group

59

156

# End of Avahi example code

60

157

61

158

67

164

uniquely identify the client

68

165

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

69

166

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

70

created: datetime.datetime()

71

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

72

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

73

this client is invalid

167

created: datetime.datetime(); object creation, not client host

168

last_checked_ok: datetime.datetime() or None if not yet checked OK

169

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

170

until this client is invalid

74

171

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

75

172

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

76

173

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

77

174

to see if the client lives.

78

Is None if no process is running.

175

'None' if no process is running.

79

176

checker_initiator_tag: a gobject event source tag, or None

80

177

stop_initiator_tag: - '' -

81

178

checker_callback_tag: - '' -

82

179

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

83

client lives. %()s expansions are done at

180

client lives. %() expansions are done at

84

181

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

85

182

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

86

183

Private attibutes:

87

184

_timeout: Real variable for 'timeout'

88

185

_interval: Real variable for 'interval'

89

_timeout_milliseconds: Used by gobject.timeout_add()

186

_timeout_milliseconds: Used when calling gobject.timeout_add()

90

187

_interval_milliseconds: - '' -

91

188

"""

92

189

def _set_timeout(self, timeout):

112

209

interval = property(lambda self: self._interval,

113

210

_set_interval)

114

211

del _set_interval

115

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

116

fingerprint=None, secret=None, secfile=None,

117

fqdn=None, timeout=None, interval=-1, checker=None):

212

def __init__(self, name = None, stop_hook=None, config={}):

213

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

214

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

215

attribute."""

118

216

self.name = name

119

# Uppercase and remove spaces from fingerprint

120

# for later comparison purposes with return value of

121

# the fingerprint() function

122

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

123

if secret:

124

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

125

elif secfile:

126

sf = open(secfile)

217

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

218

# Uppercase and remove spaces from fingerprint for later

219

# comparison purposes with return value from the fingerprint()

220

# function

221

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

222

.replace(u" ", u"")

223

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

224

if "secret" in config:

225

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

226

elif "secfile" in config:

227

sf = open(config["secfile"])

127

228

self.secret = sf.read()

128

229

sf.close()

129

230

else:

130

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

131

% self.name)

132

self.fqdn = fqdn # string

231

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

232

% self.name)

233

self.fqdn = config.get("fqdn", "")

133

234

self.created = datetime.datetime.now()

134

self.last_seen = None

135

if timeout is None:

136

self.timeout = options.timeout

137

else:

138

self.timeout = string_to_delta(timeout)

139

if interval == -1:

140

self.interval = options.interval

141

else:

142

self.interval = string_to_delta(interval)

235

self.last_checked_ok = None

236

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

237

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

143

238

self.stop_hook = stop_hook

144

239

self.checker = None

145

240

self.checker_initiator_tag = None

146

241

self.stop_initiator_tag = None

147

242

self.checker_callback_tag = None

148

self.check_command = checker

243

self.check_command = config["checker"]

149

244

def start(self):

150

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

245

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

151

246

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

152

247

# and every interval from then on.

153

248

self.checker_initiator_tag = gobject.timeout_add\

161

256

self.stop)

162

257

def stop(self):

163

258

"""Stop this client.

164

The possibility that this client might be restarted is left

165

open, but not currently used."""

166

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

167

self.secret = None

168

if self.stop_initiator_tag:

259

The possibility that a client might be restarted is left open,

260

but not currently used."""

261

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

262

if self.secret:

263

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

264

self.secret = None

265

else:

266

return False

267

if getattr(self, "stop_initiator_tag", False):

169

268

gobject.source_remove(self.stop_initiator_tag)

170

269

self.stop_initiator_tag = None

171

if self.checker_initiator_tag:

270

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

172

271

gobject.source_remove(self.checker_initiator_tag)

173

272

self.checker_initiator_tag = None

174

273

self.stop_checker()

177

276

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

178

277

return False

179

278

def __del__(self):

180

# Some code duplication here and in stop()

181

if hasattr(self, "stop_initiator_tag") \

182

and self.stop_initiator_tag:

183

gobject.source_remove(self.stop_initiator_tag)

184

self.stop_initiator_tag = None

185

if hasattr(self, "checker_initiator_tag") \

186

and self.checker_initiator_tag:

187

gobject.source_remove(self.checker_initiator_tag)

188

self.checker_initiator_tag = None

189

self.stop_checker()

279

self.stop_hook = None

280

self.stop()

190

281

def checker_callback(self, pid, condition):

191

282

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

192

283

now = datetime.datetime.now()

284

self.checker_callback_tag = None

285

self.checker = None

193

286

if os.WIFEXITED(condition) \

194

287

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

195

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

196

vars(self))

197

self.last_seen = now

288

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

289

vars(self))

290

self.last_checked_ok = now

198

291

gobject.source_remove(self.stop_initiator_tag)

199

292

self.stop_initiator_tag = gobject.timeout_add\

200

293

(self._timeout_milliseconds,

203

296

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

204

297

vars(self))

205

298

else:

206

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

207

vars(self))

208

self.checker = None

209

self.checker_callback_tag = None

299

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

300

vars(self))

210

301

def start_checker(self):

211

302

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

212

303

If a checker already exists, leave it running and do

213

304

nothing."""

305

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

306

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

307

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

308

# client would inevitably timeout, since no checker would get

309

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

310

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

311

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

312

# is as it should be.

214

313

if self.checker is None:

215

314

try:

315

# In case check_command has exactly one % operator

216

316

command = self.check_command % self.fqdn

217

317

except TypeError:

318

# Escape attributes for the shell

218

319

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

219

320

for key, val in

220

321

vars(self).iteritems())

221

322

try:

222

323

command = self.check_command % escaped_attrs

223

324

except TypeError, error:

224

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

225

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

325

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

326

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

226

327

return True # Try again later

227

328

try:

228

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

229

command, self.name)

230

self.checker = subprocess.\

231

Popen(command,

232

close_fds=True, shell=True,

233

cwd="/")

329

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

330

command, self.name)

331

self.checker = subprocess.Popen(command,

332

close_fds=True,

333

shell=True, cwd="/")

234

334

self.checker_callback_tag = gobject.child_watch_add\

235

335

(self.checker.pid,

236

336

self.checker_callback)

241

341

return True

242

342

def stop_checker(self):

243

343

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

244

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

344

if self.checker_callback_tag:

345

gobject.source_remove(self.checker_callback_tag)

346

self.checker_callback_tag = None

347

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

245

348

return

246

gobject.source_remove(self.checker_callback_tag)

247

self.checker_callback_tag = None

248

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

249

if self.checker.poll() is None:

250

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

349

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

350

try:

351

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

352

#os.sleep(0.5)

353

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

354

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

355

except OSError, error:

356

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

357

raise

251

358

self.checker = None

252

def still_valid(self, now=None):

359

def still_valid(self):

253

360

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

254

if now is None:

255

now = datetime.datetime.now()

256

if self.last_seen is None:

361

now = datetime.datetime.now()

362

if self.last_checked_ok is None:

257

363

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

258

364

else:

259

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

365

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

260

366

261

367

262

368

def peer_certificate(session):

263

"Return an OpenPGP data packet string for the peer's certificate"

369

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

264

370

# If not an OpenPGP certificate...

265

371

if gnutls.library.functions.gnutls_certificate_type_get\

266

372

(session._c_object) \

277

383

278

384

279

385

def fingerprint(openpgp):

280

"Convert an OpenPGP data string to a hexdigit fingerprint string"

281

# New empty GnuTLS certificate

282

crt = gnutls.library.types.gnutls_openpgp_crt_t()

283

gnutls.library.functions.gnutls_openpgp_crt_init\

284

(ctypes.byref(crt))

386

"Convert an OpenPGP bytestring to a hexdigit fingerprint string"

285

387

# New GnuTLS "datum" with the OpenPGP public key

286

388

datum = gnutls.library.types.gnutls_datum_t\

287

389

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

288

390

ctypes.POINTER(ctypes.c_ubyte)),

289

391

ctypes.c_uint(len(openpgp)))

392

# New empty GnuTLS certificate

393

crt = gnutls.library.types.gnutls_openpgp_crt_t()

394

gnutls.library.functions.gnutls_openpgp_crt_init\

395

(ctypes.byref(crt))

290

396

# Import the OpenPGP public key into the certificate

291

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

292

(crt,

293

ctypes.byref(datum),

294

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

397

gnutls.library.functions.gnutls_openpgp_crt_import\

398

(crt, ctypes.byref(datum),

399

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

295

400

# New buffer for the fingerprint

296

401

buffer = ctypes.create_string_buffer(20)

297

402

buffer_length = ctypes.c_size_t()

313

418

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

314

419

315

420

def handle(self):

316

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

421

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

317

422

unicode(self.client_address))

318

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

319

gnutls.connection.\

320

X509Credentials())

423

session = gnutls.connection.ClientSession\

424

(self.request, gnutls.connection.X509Credentials())

425

426

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

427

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

428

try:

429

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

430

raise RuntimeError

431

except (ValueError, IndexError, RuntimeError), error:

432

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

433

return

434

435

# Note: gnutls.connection.X509Credentials is really a generic

436

# GnuTLS certificate credentials object so long as no X.509

437

# keys are added to it. Therefore, we can use it here despite

438

# using OpenPGP certificates.

321

439

322

440

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

323

441

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

324

442

# "+DHE-DSS"))

325

priority = "SECURE256"

326

443

priority = "NORMAL" # Fallback default, since this

444

# MUST be set.

445

if self.server.settings["priority"]:

446

priority = self.server.settings["priority"]

327

447

gnutls.library.functions.gnutls_priority_set_direct\

328

448

(session._c_object, priority, None);

329

449

330

450

try:

331

451

session.handshake()

332

452

except gnutls.errors.GNUTLSError, error:

333

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

453

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

334

454

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

335

455

# established. Just abandon the request.

336

456

return

337

457

try:

338

458

fpr = fingerprint(peer_certificate(session))

339

459

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

340

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

460

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

341

461

session.bye()

342

462

return

343

463

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

344

464

client = None

345

for c in clients:

465

for c in self.server.clients:

346

466

if c.fingerprint == fpr:

347

467

client = c

348

468

break

469

if not client:

470

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

471

fpr)

472

session.bye()

473

return

349

474

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

350

475

# that the client timed out while establishing the GnuTLS

351

476

# session.

352

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

353

if client:

354

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

355

vars(client))

356

else:

357

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

358

fpr)

477

if not client.still_valid():

478

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

479

vars(client))

359

480

session.bye()

360

481

return

361

482

sent_size = 0

371

492

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

372

493

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

373

494

Attributes:

374

options: Command line options

495

settings: Server settings

375

496

clients: Set() of Client objects

376

497

"""

377

498

address_family = socket.AF_INET6

378

499

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

379

if "options" in kwargs:

380

self.options = kwargs["options"]

381

del kwargs["options"]

500

if "settings" in kwargs:

501

self.settings = kwargs["settings"]

502

del kwargs["settings"]

382

503

if "clients" in kwargs:

383

504

self.clients = kwargs["clients"]

384

505

del kwargs["clients"]

387

508

"""This overrides the normal server_bind() function

388

509

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

389

510

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

390

if self.options.interface:

391

if not hasattr(socket, "SO_BINDTODEVICE"):

392

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

393

socket.SO_BINDTODEVICE = 25

511

if self.settings["interface"]:

512

# 25 is from /usr/include/asm-i486/socket.h

513

SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)

394

514

try:

395

515

self.socket.setsockopt(socket.SOL_SOCKET,

396

socket.SO_BINDTODEVICE,

397

self.options.interface)

516

SO_BINDTODEVICE,

517

self.settings["interface"])

398

518

except socket.error, error:

399

519

if error[0] == errno.EPERM:

400

logger.warning(u"No permission to"

401

u" bind to interface %s",

402

self.options.interface)

520

logger.error(u"No permission to"

521

u" bind to interface %s",

522

self.settings["interface"])

403

523

else:

404

524

raise error

405

525

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

448

568

return delta

449

569

450

570

451

def add_service():

452

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

453

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

454

domain, host

455

if group is None:

456

group = dbus.Interface(

457

bus.get_object( avahi.DBUS_NAME,

458

server.EntryGroupNew()),

459

avahi.DBUS_INTERFACE_ENTRY_GROUP)

460

group.connect_to_signal('StateChanged',

461

entry_group_state_changed)

462

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

463

serviceName, serviceType)

464

465

group.AddService(

466

serviceInterface, # interface

467

avahi.PROTO_INET6, # protocol

468

dbus.UInt32(0), # flags

469

serviceName, serviceType,

470

domain, host,

471

dbus.UInt16(servicePort),

472

avahi.string_array_to_txt_array(serviceTXT))

473

group.Commit()

474

475

476

def remove_service():

477

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

478

global group

479

480

if not group is None:

481

group.Reset()

482

483

484

571

def server_state_changed(state):

485

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

572

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

486

573

if state == avahi.SERVER_COLLISION:

487

logger.warning(u"Server name collision")

488

remove_service()

574

logger.error(u"Server name collision")

575

service.remove()

489

576

elif state == avahi.SERVER_RUNNING:

490

add_service()

577

service.add()

491

578

492

579

493

580

def entry_group_state_changed(state, error):

494

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

495

global serviceName, server, rename_count

496

581

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

497

582

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

498

583

499

584

if state == avahi.ENTRY_GROUP_ESTABLISHED:

500

585

logger.debug(u"Service established.")

501

586

elif state == avahi.ENTRY_GROUP_COLLISION:

502

503

rename_count = rename_count - 1

504

if rename_count > 0:

505

name = server.GetAlternativeServiceName(name)

506

logger.warning(u"Service name collision, "

507

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

508

remove_service()

509

add_service()

510

511

else:

512

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

513

u" retries, exiting.", n_rename)

514

killme(1)

587

logger.warning(u"Service name collision.")

588

service.rename()

515

589

elif state == avahi.ENTRY_GROUP_FAILURE:

516

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

517

unicode(error))

518

killme(1)

519

590

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

591

unicode(error))

592

raise AvahiGroupError("State changed: %s", str(error))

520

593

521

594

def if_nametoindex(interface):

522

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

595

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

596

global if_nametoindex

523

597

try:

524

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

525

return libc.if_nametoindex(interface)

598

if "ctypes.util" not in sys.modules:

599

import ctypes.util

600

if_nametoindex = ctypes.cdll.LoadLibrary\

601

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

526

602

except (OSError, AttributeError):

527

603

if "struct" not in sys.modules:

528

604

import struct

529

605

if "fcntl" not in sys.modules:

530

606

import fcntl

531

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

532

s = socket.socket()

533

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

534

struct.pack("16s16x", interface))

535

s.close()

536

interface_index = struct.unpack("I", ifreq[16:20])[0]

537

return interface_index

538

539

540

def daemon(nochdir, noclose):

607

def if_nametoindex(interface):

608

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

609

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

610

s = socket.socket()

611

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

612

struct.pack("16s16x", interface))

613

s.close()

614

interface_index = struct.unpack("I", ifreq[16:20])[0]

615

return interface_index

616

return if_nametoindex(interface)

617

618

619

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

541

620

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

542

621

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

543

622

if os.fork():

545

624

os.setsid()

546

625

if not nochdir:

547

626

os.chdir("/")

627

if os.fork():

628

sys.exit()

548

629

if not noclose:

549

630

# Close all standard open file descriptors

550

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

631

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

551

632

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

552

633

raise OSError(errno.ENODEV,

553

634

"/dev/null not a character device")

558

639

os.close(null)

559

640

560

641

561

def killme(status = 0):

562

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

563

exitstatus = status

564

if main_loop_started:

565

main_loop.quit()

566

else:

567

sys.exit(status)

568

569

570

if __name__ == '__main__':

571

exitstatus = 0

642

def main():

643

global main_loop_started

572

644

main_loop_started = False

645

573

646

parser = OptionParser()

574

647

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

575

default=None, metavar="IF",

576

help="Bind to interface IF")

577

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

648

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

649

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

650

help="Address to listen for requests on")

651

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

578

652

help="Port number to receive requests on")

579

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

580

default="1h",

581

help="Amount of downtime allowed for clients")

582

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

583

default="5m",

584

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

585

653

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

586

654

help="Run self-test")

587

655

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

588

help="Debug mode")

656

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

657

" terminal")

658

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

659

" priority string (see GnuTLS documentation)")

660

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

661

help="Zeroconf service name")

662

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

663

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

664

help="Directory to search for configuration"

665

" files")

589

666

(options, args) = parser.parse_args()

590

667

591

668

if options.check:

593

670

doctest.testmod()

594

671

sys.exit()

595

672

596

# Parse the time arguments

597

try:

598

options.timeout = string_to_delta(options.timeout)

599

except ValueError:

600

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

601

try:

602

options.interval = string_to_delta(options.interval)

603

except ValueError:

604

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

605

606

# Parse config file

607

defaults = { "checker": "fping -q -- %%(fqdn)s" }

608

client_config = ConfigParser.SafeConfigParser(defaults)

609

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

610

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

611

612

# From the Avahi server example code

673

# Default values for config file for server-global settings

674

server_defaults = { "interface": "",

675

"address": "",

676

"port": "",

677

"debug": "False",

678

"priority":

679

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

680

"servicename": "Mandos",

681

}

682

683

# Parse config file for server-global settings

684

server_config = ConfigParser.SafeConfigParser(server_defaults)

685

del server_defaults

686

server_config.read(os.path.join(options.configdir, "mandos.conf"))

687

server_section = "server"

688

# Convert the SafeConfigParser object to a dict

689

server_settings = dict(server_config.items(server_section))

690

# Use getboolean on the boolean config option

691

server_settings["debug"] = server_config.getboolean\

692

(server_section, "debug")

693

del server_config

694

695

# Override the settings from the config file with command line

696

# options, if set.

697

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

698

"priority", "servicename", "configdir"):

699

value = getattr(options, option)

700

if value is not None:

701

server_settings[option] = value

702

del options

703

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

704

705

# Parse config file with clients

706

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

707

"interval": "5m",

708

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

709

}

710

client_config = ConfigParser.SafeConfigParser(client_defaults)

711

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

712

"clients.conf"))

713

714

global service

715

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

716

type = "_mandos._tcp", );

717

if server_settings["interface"]:

718

service.interface = if_nametoindex(server_settings["interface"])

719

720

global main_loop

721

global bus

722

global server

723

# From the Avahi example code

613

724

DBusGMainLoop(set_as_default=True )

614

725

main_loop = gobject.MainLoop()

615

726

bus = dbus.SystemBus()

618

729

avahi.DBUS_INTERFACE_SERVER )

619

730

# End of Avahi example code

620

731

621

debug = options.debug

732

debug = server_settings["debug"]

622

733

623

734

if debug:

624

735

console = logging.StreamHandler()

632

743

def remove_from_clients(client):

633

744

clients.remove(client)

634

745

if not clients:

635

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

636

killme()

746

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

747

sys.exit()

637

748

638

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

749

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

639

750

stop_hook = remove_from_clients,

640

**(dict(client_config\

641

.items(section))))

751

config

752

= dict(client_config.items(section)))

642

753

for section in client_config.sections()))

643

754

644

755

if not debug:

645

daemon(False, False)

756

daemon()

646

757

647

758

def cleanup():

648

759

"Cleanup function; run on exit"

649

760

global group

650

# From the Avahi server example code

761

# From the Avahi example code

651

762

if not group is None:

652

763

group.Free()

653

764

group = None

654

765

# End of Avahi example code

655

766

656

for client in clients:

767

while clients:

768

client = clients.pop()

657

769

client.stop_hook = None

658

770

client.stop()

659

771

661

773

662

774

if not debug:

663

775

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

664

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

665

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

776

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

777

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

666

778

667

779

for client in clients:

668

780

client.start()

669

781

670

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

782

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

783

server_settings["port"]),

671

784

tcp_handler,

672

options=options,

785

settings=server_settings,

673

786

clients=clients)

674

# Find out what random port we got

675

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

676

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

677

678

if options.interface is not None:

679

serviceInterface = if_nametoindex(options.interface)

680

681

# From the Avahi server example code

682

server.connect_to_signal("StateChanged", server_state_changed)

683

try:

684

server_state_changed(server.GetState())

685

except dbus.exceptions.DBusException, error:

686

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

687

killme(1)

688

# End of Avahi example code

689

690

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

691

lambda *args, **kwargs:

692

tcp_server.handle_request(*args[2:],

693

**kwargs) or True)

694

try:

787

# Find out what port we got

788

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

789

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

790

u" scope_id %d" % tcp_server.socket.getsockname())

791

792

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

793

794

try:

795

# From the Avahi example code

796

server.connect_to_signal("StateChanged", server_state_changed)

797

try:

798

server_state_changed(server.GetState())

799

except dbus.exceptions.DBusException, error:

800

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

801

sys.exit(1)

802

# End of Avahi example code

803

804

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

805

lambda *args, **kwargs:

806

tcp_server.handle_request\

807

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

808

809

logger.debug("Starting main loop")

695

810

main_loop_started = True

696

811

main_loop.run()

812

except AvahiError, error:

813

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

814

sys.exit(1)

697

815

except KeyboardInterrupt:

698

816

if debug:

699

817

print

700

701

sys.exit(exitstatus)

818

819

if __name__ == '__main__':

820

main()