/mandos/trunk : revision 87

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

64

version = "1.0"

36

65

37

66

logger = logging.Logger('mandos')

38

67

syslogger = logging.handlers.SysLogHandler\

39

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

68

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

69

address = "/dev/log")

40

70

syslogger.setFormatter(logging.Formatter\

41

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

71

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

42

72

logger.addHandler(syslogger)

43

del syslogger

44

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

console = logging.StreamHandler()

75

console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'

76

' %(message)s'))

77

logger.addHandler(console)

78

79

class AvahiError(Exception):

80

def __init__(self, value):

81

self.value = value

82

def __str__(self):

83

return repr(self.value)

84

85

class AvahiServiceError(AvahiError):

86

pass

87

88

class AvahiGroupError(AvahiError):

89

pass

90

91

92

class AvahiService(object):

93

"""An Avahi (Zeroconf) service.

94

Attributes:

95

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

96

Used to optionally bind to the specified interface.

97

name: string; Example: 'Mandos'

98

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

99

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

100

port: integer; what port to announce

101

TXT: list of strings; TXT record for the service

102

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

103

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

104

max_renames: integer; maximum number of renames

105

rename_count: integer; counter so we only rename after collisions

106

a sensible number of times

107

"""

108

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

109

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

110

host = "", max_renames = 32768):

111

self.interface = interface

112

self.name = name

113

self.type = type

114

self.port = port

115

if TXT is None:

116

self.TXT = []

117

else:

118

self.TXT = TXT

119

self.domain = domain

120

self.host = host

121

self.rename_count = 0

122

self.max_renames = max_renames

123

def rename(self):

124

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

125

if self.rename_count >= self.max_renames:

126

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

127

u" retries, exiting.", rename_count)

128

raise AvahiServiceError("Too many renames")

129

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

130

logger.info(u"Changing name to %r ...", str(self.name))

131

syslogger.setFormatter(logging.Formatter\

132

('Mandos (%s): %%(levelname)s:'

133

' %%(message)s' % self.name))

134

self.remove()

135

self.add()

136

self.rename_count += 1

137

def remove(self):

138

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

139

if group is not None:

140

group.Reset()

141

def add(self):

142

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

143

global group

144

if group is None:

145

group = dbus.Interface\

146

(bus.get_object(avahi.DBUS_NAME,

147

server.EntryGroupNew()),

148

avahi.DBUS_INTERFACE_ENTRY_GROUP)

149

group.connect_to_signal('StateChanged',

150

entry_group_state_changed)

151

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

152

service.name, service.type)

153

group.AddService(

154

self.interface, # interface

155

avahi.PROTO_INET6, # protocol

156

dbus.UInt32(0), # flags

157

self.name, self.type,

158

self.domain, self.host,

159

dbus.UInt16(self.port),

160

avahi.string_array_to_txt_array(self.TXT))

161

group.Commit()

162

163

# From the Avahi example code:

164

group = None # our entry group

59

165

# End of Avahi example code

60

166

61

167

66

172

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

67

173

uniquely identify the client

68

174

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

69

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

175

host: string; available for use by the checker command

176

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

177

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

178

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

179

until this client is invalid

74

180

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

75

181

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

76

182

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

77

183

to see if the client lives.

78

Is None if no process is running.

184

'None' if no process is running.

79

185

checker_initiator_tag: a gobject event source tag, or None

80

186

stop_initiator_tag: - '' -

81

187

checker_callback_tag: - '' -

82

188

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

83

client lives. %()s expansions are done at

189

client lives. %() expansions are done at

84

190

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

85

191

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

86

192

Private attibutes:

87

193

_timeout: Real variable for 'timeout'

88

194

_interval: Real variable for 'interval'

89

_timeout_milliseconds: Used by gobject.timeout_add()

195

_timeout_milliseconds: Used when calling gobject.timeout_add()

90

196

_interval_milliseconds: - '' -

91

197

"""

92

198

def _set_timeout(self, timeout):

112

218

interval = property(lambda self: self._interval,

113

219

_set_interval)

114

220

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):

221

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

222

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

223

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

224

attribute."""

118

225

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)

226

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

227

# Uppercase and remove spaces from fingerprint for later

228

# comparison purposes with return value from the fingerprint()

229

# function

230

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

231

.replace(u" ", u"")

232

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

233

if "secret" in config:

234

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

235

elif "secfile" in config:

236

sf = open(config["secfile"])

127

237

self.secret = sf.read()

128

238

sf.close()

129

239

else:

130

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

131

% self.name)

132

self.fqdn = fqdn # string

240

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

241

% self.name)

242

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

133

243

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)

244

self.last_checked_ok = None

245

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

246

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

143

247

self.stop_hook = stop_hook

144

248

self.checker = None

145

249

self.checker_initiator_tag = None

146

250

self.stop_initiator_tag = None

147

251

self.checker_callback_tag = None

148

self.check_command = checker

252

self.check_command = config["checker"]

149

253

def start(self):

150

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

254

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

151

255

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

152

256

# and every interval from then on.

153

257

self.checker_initiator_tag = gobject.timeout_add\

161

265

self.stop)

162

266

def stop(self):

163

267

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

268

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

269

but not currently used."""

270

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

271

if hasattr(self, "secret") and self.secret:

272

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

273

self.secret = None

274

else:

275

return False

276

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

169

277

gobject.source_remove(self.stop_initiator_tag)

170

278

self.stop_initiator_tag = None

171

if self.checker_initiator_tag:

279

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

172

280

gobject.source_remove(self.checker_initiator_tag)

173

281

self.checker_initiator_tag = None

174

282

self.stop_checker()

177

285

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

178

286

return False

179

287

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()

288

self.stop_hook = None

289

self.stop()

190

290

def checker_callback(self, pid, condition):

191

291

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

192

292

now = datetime.datetime.now()

293

self.checker_callback_tag = None

294

self.checker = None

193

295

if os.WIFEXITED(condition) \

194

296

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

195

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

196

vars(self))

197

self.last_seen = now

297

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

298

vars(self))

299

self.last_checked_ok = now

198

300

gobject.source_remove(self.stop_initiator_tag)

199

301

self.stop_initiator_tag = gobject.timeout_add\

200

302

(self._timeout_milliseconds,

203

305

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

204

306

vars(self))

205

307

else:

206

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

207

vars(self))

208

self.checker = None

209

self.checker_callback_tag = None

308

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

309

vars(self))

210

310

def start_checker(self):

211

311

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

212

312

If a checker already exists, leave it running and do

213

313

nothing."""

314

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

315

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

316

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

317

# client would inevitably timeout, since no checker would get

318

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

319

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

320

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

321

# is as it should be.

214

322

if self.checker is None:

215

323

try:

216

command = self.check_command % self.fqdn

324

# In case check_command has exactly one % operator

325

command = self.check_command % self.host

217

326

except TypeError:

327

# Escape attributes for the shell

218

328

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

219

329

for key, val in

220

330

vars(self).iteritems())

221

331

try:

222

332

command = self.check_command % escaped_attrs

223

333

except TypeError, error:

224

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

225

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

334

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

335

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

226

336

return True # Try again later

227

337

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="/")

338

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

339

command, self.name)

340

self.checker = subprocess.Popen(command,

341

close_fds=True,

342

shell=True, cwd="/")

234

343

self.checker_callback_tag = gobject.child_watch_add\

235

344

(self.checker.pid,

236

345

self.checker_callback)

241

350

return True

242

351

def stop_checker(self):

243

352

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

244

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

353

if self.checker_callback_tag:

354

gobject.source_remove(self.checker_callback_tag)

355

self.checker_callback_tag = None

356

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

245

357

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)

358

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

359

try:

360

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

361

#os.sleep(0.5)

362

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

363

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

364

except OSError, error:

365

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

366

raise

251

367

self.checker = None

252

def still_valid(self, now=None):

368

def still_valid(self):

253

369

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

370

now = datetime.datetime.now()

371

if self.last_checked_ok is None:

257

372

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

258

373

else:

259

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

374

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

260

375

261

376

262

377

def peer_certificate(session):

263

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

378

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

264

379

# If not an OpenPGP certificate...

265

380

if gnutls.library.functions.gnutls_certificate_type_get\

266

381

(session._c_object) \

277

392

278

393

279

394

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))

395

"Convert an OpenPGP bytestring to a hexdigit fingerprint string"

285

396

# New GnuTLS "datum" with the OpenPGP public key

286

397

datum = gnutls.library.types.gnutls_datum_t\

287

398

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

288

399

ctypes.POINTER(ctypes.c_ubyte)),

289

400

ctypes.c_uint(len(openpgp)))

401

# New empty GnuTLS certificate

402

crt = gnutls.library.types.gnutls_openpgp_crt_t()

403

gnutls.library.functions.gnutls_openpgp_crt_init\

404

(ctypes.byref(crt))

290

405

# 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)

406

gnutls.library.functions.gnutls_openpgp_crt_import\

407

(crt, ctypes.byref(datum),

408

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

295

409

# New buffer for the fingerprint

296

410

buffer = ctypes.create_string_buffer(20)

297

411

buffer_length = ctypes.c_size_t()

313

427

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

314

428

315

429

def handle(self):

316

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

430

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

317

431

unicode(self.client_address))

318

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

319

gnutls.connection.\

320

X509Credentials())

432

session = gnutls.connection.ClientSession\

433

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

434

435

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

436

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

437

try:

438

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

439

raise RuntimeError

440

except (ValueError, IndexError, RuntimeError), error:

441

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

442

return

443

444

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

445

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

446

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

447

# using OpenPGP certificates.

321

448

322

449

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

323

450

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

324

451

# "+DHE-DSS"))

325

priority = "SECURE256"

326

452

priority = "NORMAL" # Fallback default, since this

453

# MUST be set.

454

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

455

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

327

456

gnutls.library.functions.gnutls_priority_set_direct\

328

457

(session._c_object, priority, None);

329

458

330

459

try:

331

460

session.handshake()

332

461

except gnutls.errors.GNUTLSError, error:

333

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

462

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

334

463

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

335

464

# established. Just abandon the request.

336

465

return

337

466

try:

338

467

fpr = fingerprint(peer_certificate(session))

339

468

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

340

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

469

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

341

470

session.bye()

342

471

return

343

472

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

344

473

client = None

345

for c in clients:

474

for c in self.server.clients:

346

475

if c.fingerprint == fpr:

347

476

client = c

348

477

break

478

if not client:

479

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

480

fpr)

481

session.bye()

482

return

349

483

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

350

484

# that the client timed out while establishing the GnuTLS

351

485

# 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)

486

if not client.still_valid():

487

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

488

vars(client))

359

489

session.bye()

360

490

return

361

491

sent_size = 0

371

501

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

372

502

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

373

503

Attributes:

374

options: Command line options

504

settings: Server settings

375

505

clients: Set() of Client objects

376

506

"""

377

507

address_family = socket.AF_INET6

378

508

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

379

if "options" in kwargs:

380

self.options = kwargs["options"]

381

del kwargs["options"]

509

if "settings" in kwargs:

510

self.settings = kwargs["settings"]

511

del kwargs["settings"]

382

512

if "clients" in kwargs:

383

513

self.clients = kwargs["clients"]

384

514

del kwargs["clients"]

387

517

"""This overrides the normal server_bind() function

388

518

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

389

519

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

520

if self.settings["interface"]:

521

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

522

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

394

523

try:

395

524

self.socket.setsockopt(socket.SOL_SOCKET,

396

socket.SO_BINDTODEVICE,

397

self.options.interface)

525

SO_BINDTODEVICE,

526

self.settings["interface"])

398

527

except socket.error, error:

399

528

if error[0] == errno.EPERM:

400

logger.warning(u"No permission to"

401

u" bind to interface %s",

402

self.options.interface)

529

logger.error(u"No permission to"

530

u" bind to interface %s",

531

self.settings["interface"])

403

532

else:

404

533

raise error

405

534

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

408

537

in6addr_any = "::"

409

538

self.server_address = (in6addr_any,

410

539

self.server_address[1])

411

elif self.server_address[1] is None:

540

elif not self.server_address[1]:

412

541

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

413

542

0)

543

# if self.settings["interface"]:

544

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

545

# 0, # port

546

# 0, # flowinfo

547

# if_nametoindex

548

# (self.settings

549

# ["interface"]))

414

550

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

415

551

416

552

448

584

return delta

449

585

450

586

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

587

def server_state_changed(state):

485

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

588

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

486

589

if state == avahi.SERVER_COLLISION:

487

logger.warning(u"Server name collision")

488

remove_service()

590

logger.error(u"Server name collision")

591

service.remove()

489

592

elif state == avahi.SERVER_RUNNING:

490

add_service()

593

service.add()

491

594

492

595

493

596

def entry_group_state_changed(state, error):

494

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

495

global serviceName, server, rename_count

496

597

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

497

598

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

498

599

499

600

if state == avahi.ENTRY_GROUP_ESTABLISHED:

500

601

logger.debug(u"Service established.")

501

602

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)

603

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

604

service.rename()

515

605

elif state == avahi.ENTRY_GROUP_FAILURE:

516

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

517

unicode(error))

518

killme(1)

519

606

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

607

unicode(error))

608

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

520

609

521

610

def if_nametoindex(interface):

522

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

611

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

612

global if_nametoindex

523

613

try:

524

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

525

return libc.if_nametoindex(interface)

614

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

615

import ctypes.util

616

if_nametoindex = ctypes.cdll.LoadLibrary\

617

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

526

618

except (OSError, AttributeError):

527

619

if "struct" not in sys.modules:

528

620

import struct

529

621

if "fcntl" not in sys.modules:

530

622

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):

623

def if_nametoindex(interface):

624

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

625

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

626

s = socket.socket()

627

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

628

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

629

s.close()

630

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

631

return interface_index

632

return if_nametoindex(interface)

633

634

635

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

541

636

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

542

637

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

543

638

if os.fork():

545

640

os.setsid()

546

641

if not nochdir:

547

642

os.chdir("/")

643

if os.fork():

644

sys.exit()

548

645

if not noclose:

549

646

# Close all standard open file descriptors

550

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

647

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

551

648

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

552

649

raise OSError(errno.ENODEV,

553

650

"/dev/null not a character device")

558

655

os.close(null)

559

656

560

657

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

658

def main():

659

global main_loop_started

572

660

main_loop_started = False

573

parser = OptionParser()

661

662

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

574

663

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,

664

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

665

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

666

help="Address to listen for requests on")

667

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

578

668

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

669

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

586

670

help="Run self-test")

587

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

588

help="Debug mode")

671

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

672

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

673

" terminal")

674

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

675

" priority string (see GnuTLS documentation)")

676

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

677

help="Zeroconf service name")

678

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

679

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

680

help="Directory to search for configuration"

681

" files")

589

682

(options, args) = parser.parse_args()

590

683

591

684

if options.check:

593

686

doctest.testmod()

594

687

sys.exit()

595

688

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

689

# Default values for config file for server-global settings

690

server_defaults = { "interface": "",

691

"address": "",

692

"port": "",

693

"debug": "False",

694

"priority":

695

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

696

"servicename": "Mandos",

697

}

698

699

# Parse config file for server-global settings

700

server_config = ConfigParser.SafeConfigParser(server_defaults)

701

del server_defaults

702

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

703

server_section = "server"

704

# Convert the SafeConfigParser object to a dict

705

server_settings = dict(server_config.items(server_section))

706

# Use getboolean on the boolean config option

707

server_settings["debug"] = server_config.getboolean\

708

(server_section, "debug")

709

del server_config

710

711

# Override the settings from the config file with command line

712

# options, if set.

713

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

714

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

715

value = getattr(options, option)

716

if value is not None:

717

server_settings[option] = value

718

del options

719

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

720

721

debug = server_settings["debug"]

722

723

if not debug:

724

syslogger.setLevel(logging.WARNING)

725

console.setLevel(logging.WARNING)

726

727

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

728

syslogger.setFormatter(logging.Formatter\

729

('Mandos (%s): %%(levelname)s:'

730

' %%(message)s'

731

% server_settings["servicename"]))

732

733

# Parse config file with clients

734

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

735

"interval": "5m",

736

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

737

}

738

client_config = ConfigParser.SafeConfigParser(client_defaults)

739

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

740

"clients.conf"))

741

742

global service

743

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

744

type = "_mandos._tcp", );

745

if server_settings["interface"]:

746

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

747

748

global main_loop

749

global bus

750

global server

751

# From the Avahi example code

613

752

DBusGMainLoop(set_as_default=True )

614

753

main_loop = gobject.MainLoop()

615

754

bus = dbus.SystemBus()

618

757

avahi.DBUS_INTERFACE_SERVER )

619

758

# End of Avahi example code

620

759

621

debug = options.debug

622

623

if debug:

624

console = logging.StreamHandler()

625

# console.setLevel(logging.DEBUG)

626

console.setFormatter(logging.Formatter\

627

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

628

logger.addHandler(console)

629

del console

630

631

760

clients = Set()

632

761

def remove_from_clients(client):

633

762

clients.remove(client)

634

763

if not clients:

635

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

636

killme()

764

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

765

sys.exit()

637

766

638

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

767

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

639

768

stop_hook = remove_from_clients,

640

**(dict(client_config\

641

.items(section))))

769

config

770

= dict(client_config.items(section)))

642

771

for section in client_config.sections()))

772

if not clients:

773

logger.critical(u"No clients defined")

774

sys.exit(1)

643

775

644

776

if not debug:

645

daemon(False, False)

777

logger.removeHandler(console)

778

daemon()

779

780

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

781

pid = os.getpid()

782

try:

783

pidfile = open(pidfilename, "w")

784

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

785

pidfile.close()

786

del pidfile

787

except IOError, err:

788

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

789

pidfilename, os.getpid())

646

790

647

791

def cleanup():

648

792

"Cleanup function; run on exit"

649

793

global group

650

# From the Avahi server example code

794

# From the Avahi example code

651

795

if not group is None:

652

796

group.Free()

653

797

group = None

654

798

# End of Avahi example code

655

799

656

for client in clients:

800

while clients:

801

client = clients.pop()

657

802

client.stop_hook = None

658

803

client.stop()

659

804

661

806

662

807

if not debug:

663

808

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())

809

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

810

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

666

811

667

812

for client in clients:

668

813

client.start()

669

814

670

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

815

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

816

server_settings["port"]),

671

817

tcp_handler,

672

options=options,

818

settings=server_settings,

673

819

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:

820

# Find out what port we got

821

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

822

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

823

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

824

825

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

826

827

try:

828

# From the Avahi example code

829

server.connect_to_signal("StateChanged", server_state_changed)

830

try:

831

server_state_changed(server.GetState())

832

except dbus.exceptions.DBusException, error:

833

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

834

sys.exit(1)

835

# End of Avahi example code

836

837

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

838

lambda *args, **kwargs:

839

tcp_server.handle_request\

840

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

841

842

logger.debug(u"Starting main loop")

695

843

main_loop_started = True

696

844

main_loop.run()

845

except AvahiError, error:

846

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

847

sys.exit(1)

697

848

except KeyboardInterrupt:

698

849

if debug:

699

850

print

700

701

sys.exit(exitstatus)

851

852

if __name__ == '__main__':

853

main()