/mandos/trunk : revision 43

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: "AvahiService.add", "AvahiService.remove",

10

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

11

# 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

# Brief description of the operation of this program:

65

#

66

# This server announces itself as a Zeroconf service. Connecting

67

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

68

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

69

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

70

# supply an OpenPGP certificate, and the fingerprint of this

71

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

72

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

73

# authentication or authorization is done by this server.

74

36

75

37

76

logger = logging.Logger('mandos')

38

77

syslogger = logging.handlers.SysLogHandler\

42

81

logger.addHandler(syslogger)

43

82

del syslogger

44

83

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

84

85

class AvahiError(Exception):

86

def __init__(self, value):

87

self.value = value

88

def __str__(self):

89

return repr(self.value)

90

91

class AvahiServiceError(AvahiError):

92

pass

93

94

class AvahiGroupError(AvahiError):

95

pass

96

97

98

class AvahiService(object):

99

"""

100

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

101

Used to optionally bind to the specified interface.

102

name = string; Example: "Mandos"

103

type = string; Example: "_mandos._tcp".

104

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

105

port = integer; what port to announce

106

TXT = list of strings; TXT record for the service

107

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

108

host = string; Host to publish records for, default to localhost

109

if empty.

110

max_renames = integer; maximum number of renames

111

rename_count = integer; counter so we only rename after collisions

112

a sensible number of times

113

"""

114

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

115

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

116

host = "", max_renames = 12):

117

"""An Avahi (Zeroconf) service. """

118

self.interface = interface

119

self.name = name

120

self.type = type

121

self.port = port

122

if TXT is None:

123

self.TXT = []

124

else:

125

self.TXT = TXT

126

self.domain = domain

127

self.host = host

128

self.rename_count = 0

129

def rename(self):

130

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

131

if self.rename_count >= self.max_renames:

132

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

133

u" retries, exiting.", rename_count)

134

raise AvahiServiceError("Too many renames")

135

name = server.GetAlternativeServiceName(name)

136

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

137

self.remove()

138

self.add()

139

self.rename_count += 1

140

def remove(self):

141

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

142

if group is not None:

143

group.Reset()

144

def add(self):

145

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

146

global group

147

if group is None:

148

group = dbus.Interface\

149

(bus.get_object(avahi.DBUS_NAME,

150

server.EntryGroupNew()),

151

avahi.DBUS_INTERFACE_ENTRY_GROUP)

152

group.connect_to_signal('StateChanged',

153

entry_group_state_changed)

154

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

155

service.name, service.type)

156

group.AddService(

157

self.interface, # interface

158

avahi.PROTO_INET6, # protocol

159

dbus.UInt32(0), # flags

160

self.name, self.type,

161

self.domain, self.host,

162

dbus.UInt16(self.port),

163

avahi.string_array_to_txt_array(self.TXT))

164

group.Commit()

165

166

# From the Avahi example code:

167

group = None # our entry group

59

168

# End of Avahi example code

60

169

61

170

67

176

uniquely identify the client

68

177

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

69

178

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

179

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

180

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

181

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

182

until this client is invalid

74

183

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

75

184

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

76

185

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

77

186

to see if the client lives.

78

Is None if no process is running.

187

'None' if no process is running.

79

188

checker_initiator_tag: a gobject event source tag, or None

80

189

stop_initiator_tag: - '' -

81

190

checker_callback_tag: - '' -

82

191

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

83

client lives. %()s expansions are done at

192

client lives. %() expansions are done at

84

193

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

85

194

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

86

195

Private attibutes:

87

196

_timeout: Real variable for 'timeout'

88

197

_interval: Real variable for 'interval'

89

_timeout_milliseconds: Used by gobject.timeout_add()

198

_timeout_milliseconds: Used when calling gobject.timeout_add()

90

199

_interval_milliseconds: - '' -

91

200

"""

92

201

def _set_timeout(self, timeout):

112

221

interval = property(lambda self: self._interval,

113

222

_set_interval)

114

223

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

224

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

225

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

226

interval=-1, checker=None):

227

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

228

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

118

229

self.name = name

230

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

119

231

# Uppercase and remove spaces from fingerprint

120

232

# for later comparison purposes with return value of

121

233

# the fingerprint() function

122

234

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

235

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

123

236

if secret:

124

237

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

125

238

elif secfile:

127

240

self.secret = sf.read()

128

241

sf.close()

129

242

else:

130

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

131

% self.name)

132

self.fqdn = fqdn # string

243

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

244

% self.name)

245

self.fqdn = fqdn

133

246

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)

247

self.last_checked_ok = None

248

self.timeout = string_to_delta(timeout)

249

self.interval = string_to_delta(interval)

143

250

self.stop_hook = stop_hook

144

251

self.checker = None

145

252

self.checker_initiator_tag = None

147

254

self.checker_callback_tag = None

148

255

self.check_command = checker

149

256

def start(self):

150

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

257

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

151

258

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

152

259

# and every interval from then on.

153

260

self.checker_initiator_tag = gobject.timeout_add\

161

268

self.stop)

162

269

def stop(self):

163

270

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

271

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

272

but not currently used."""

273

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

274

if self.secret:

275

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

276

self.secret = None

277

else:

278

return False

279

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

169

280

gobject.source_remove(self.stop_initiator_tag)

170

281

self.stop_initiator_tag = None

171

if self.checker_initiator_tag:

282

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

172

283

gobject.source_remove(self.checker_initiator_tag)

173

284

self.checker_initiator_tag = None

174

285

self.stop_checker()

177

288

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

178

289

return False

179

290

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

291

self.stop_hook = None

292

self.stop()

190

293

def checker_callback(self, pid, condition):

191

294

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

192

295

now = datetime.datetime.now()

296

self.checker_callback_tag = None

297

self.checker = None

193

298

if os.WIFEXITED(condition) \

194

299

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

195

300

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

196

301

vars(self))

197

self.last_seen = now

302

self.last_checked_ok = now

198

303

gobject.source_remove(self.stop_initiator_tag)

199

304

self.stop_initiator_tag = gobject.timeout_add\

200

305

(self._timeout_milliseconds,

205

310

else:

206

311

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

207

312

vars(self))

208

self.checker = None

209

self.checker_callback_tag = None

210

313

def start_checker(self):

211

314

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

212

315

If a checker already exists, leave it running and do

213

316

nothing."""

317

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

318

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

319

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

320

# client would inevitably timeout, since no checker would get

321

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

322

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

323

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

324

# is as it should be.

214

325

if self.checker is None:

215

326

try:

327

# In case check_command has exactly one % operator

216

328

command = self.check_command % self.fqdn

217

329

except TypeError:

330

# Escape attributes for the shell

218

331

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

219

332

for key, val in

220

333

vars(self).iteritems())

221

334

try:

222

335

command = self.check_command % escaped_attrs

223

336

except TypeError, error:

224

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

225

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

337

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

338

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

226

339

return True # Try again later

227

340

try:

228

341

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

229

342

command, self.name)

230

self.checker = subprocess.\

231

Popen(command,

232

close_fds=True, shell=True,

233

cwd="/")

343

self.checker = subprocess.Popen(command,

344

close_fds=True,

345

shell=True, cwd="/")

234

346

self.checker_callback_tag = gobject.child_watch_add\

235

347

(self.checker.pid,

236

348

self.checker_callback)

241

353

return True

242

354

def stop_checker(self):

243

355

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

244

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

356

if self.checker_callback_tag:

357

gobject.source_remove(self.checker_callback_tag)

358

self.checker_callback_tag = None

359

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

245

360

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)

361

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

362

try:

363

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

364

#os.sleep(0.5)

365

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

366

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

367

except OSError, error:

368

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

369

raise

251

370

self.checker = None

252

def still_valid(self, now=None):

371

def still_valid(self):

253

372

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

373

now = datetime.datetime.now()

374

if self.last_checked_ok is None:

257

375

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

258

376

else:

259

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

377

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

260

378

261

379

262

380

def peer_certificate(session):

263

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

381

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

264

382

# If not an OpenPGP certificate...

265

383

if gnutls.library.functions.gnutls_certificate_type_get\

266

384

(session._c_object) \

277

395

278

396

279

397

def fingerprint(openpgp):

280

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

398

"Convert an OpenPGP bytestring to a hexdigit fingerprint string"

281

399

# New empty GnuTLS certificate

282

400

crt = gnutls.library.types.gnutls_openpgp_crt_t()

283

401

gnutls.library.functions.gnutls_openpgp_crt_init\

315

433

def handle(self):

316

434

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

317

435

unicode(self.client_address))

318

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

319

gnutls.connection.\

320

X509Credentials())

436

session = gnutls.connection.ClientSession\

437

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

438

439

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

440

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

441

try:

442

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

443

raise RuntimeError

444

except (ValueError, IndexError, RuntimeError), error:

445

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

446

return

447

448

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

449

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

450

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

451

# using OpenPGP certificates.

321

452

322

453

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

323

454

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

324

455

# "+DHE-DSS"))

325

priority = "SECURE256"

326

456

priority = "NORMAL" # Fallback default, since this

457

# MUST be set.

458

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

459

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

327

460

gnutls.library.functions.gnutls_priority_set_direct\

328

461

(session._c_object, priority, None);

329

462

342

475

return

343

476

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

344

477

client = None

345

for c in clients:

478

for c in self.server.clients:

346

479

if c.fingerprint == fpr:

347

480

client = c

348

481

break

482

if not client:

483

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

484

session.bye()

485

return

349

486

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

350

487

# that the client timed out while establishing the GnuTLS

351

488

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

489

if not client.still_valid():

490

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

359

491

session.bye()

360

492

return

361

493

sent_size = 0

371

503

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

372

504

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

373

505

Attributes:

374

options: Command line options

506

settings: Server settings

375

507

clients: Set() of Client objects

376

508

"""

377

509

address_family = socket.AF_INET6

378

510

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

379

if "options" in kwargs:

380

self.options = kwargs["options"]

381

del kwargs["options"]

511

if "settings" in kwargs:

512

self.settings = kwargs["settings"]

513

del kwargs["settings"]

382

514

if "clients" in kwargs:

383

515

self.clients = kwargs["clients"]

384

516

del kwargs["clients"]

387

519

"""This overrides the normal server_bind() function

388

520

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

389

521

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

522

if self.settings["interface"]:

523

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

524

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

394

525

try:

395

526

self.socket.setsockopt(socket.SOL_SOCKET,

396

socket.SO_BINDTODEVICE,

397

self.options.interface)

527

SO_BINDTODEVICE,

528

self.settings["interface"])

398

529

except socket.error, error:

399

530

if error[0] == errno.EPERM:

400

531

logger.warning(u"No permission to"

401

532

u" bind to interface %s",

402

self.options.interface)

533

self.settings["interface"])

403

534

else:

404

535

raise error

405

536

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

448

579

return delta

449

580

450

581

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

582

def server_state_changed(state):

485

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

583

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

486

584

if state == avahi.SERVER_COLLISION:

487

585

logger.warning(u"Server name collision")

488

remove_service()

586

service.remove()

489

587

elif state == avahi.SERVER_RUNNING:

490

add_service()

588

service.add()

491

589

492

590

493

591

def entry_group_state_changed(state, error):

494

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

495

global serviceName, server, rename_count

496

592

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

497

593

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

498

594

499

595

if state == avahi.ENTRY_GROUP_ESTABLISHED:

500

596

logger.debug(u"Service established.")

501

597

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)

598

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

599

service.rename()

515

600

elif state == avahi.ENTRY_GROUP_FAILURE:

516

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

517

unicode(error))

518

killme(1)

519

601

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

602

unicode(error))

603

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

520

604

521

605

def if_nametoindex(interface):

522

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

606

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

607

global if_nametoindex

523

608

try:

524

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

525

return libc.if_nametoindex(interface)

609

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

610

import ctypes.util

611

if_nametoindex = ctypes.cdll.LoadLibrary\

612

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

526

613

except (OSError, AttributeError):

527

614

if "struct" not in sys.modules:

528

615

import struct

529

616

if "fcntl" not in sys.modules:

530

617

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

618

def if_nametoindex(interface):

619

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

620

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

621

s = socket.socket()

622

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

623

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

624

s.close()

625

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

626

return interface_index

627

return if_nametoindex(interface)

538

628

539

629

540

630

def daemon(nochdir, noclose):

547

637

os.chdir("/")

548

638

if not noclose:

549

639

# Close all standard open file descriptors

550

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

640

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

551

641

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

552

642

raise OSError(errno.ENODEV,

553

643

"/dev/null not a character device")

558

648

os.close(null)

559

649

560

650

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

651

def main():

652

global main_loop_started

572

653

main_loop_started = False

654

573

655

parser = OptionParser()

574

656

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,

657

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

658

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

659

help="Address to listen for requests on")

660

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

578

661

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

662

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

586

663

help="Run self-test")

587

664

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

588

help="Debug mode")

665

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

666

" terminal")

667

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

668

" priority string (see GnuTLS documentation)")

669

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

670

help="Zeroconf service name")

671

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

672

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

673

help="Directory to search for configuration"

674

" files")

589

675

(options, args) = parser.parse_args()

590

676

591

677

if options.check:

593

679

doctest.testmod()

594

680

sys.exit()

595

681

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

682

# Default values for config file for server-global settings

683

server_defaults = { "interface": "",

684

"address": "",

685

"port": "",

686

"debug": "False",

687

"priority":

688

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

689

"servicename": "Mandos",

690

}

691

692

# Parse config file for server-global settings

693

server_config = ConfigParser.SafeConfigParser(server_defaults)

694

del server_defaults

695

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

696

server_section = "server"

697

# Convert the SafeConfigParser object to a dict

698

server_settings = dict(server_config.items(server_section))

699

# Use getboolean on the boolean config option

700

server_settings["debug"] = server_config.getboolean\

701

(server_section, "debug")

702

del server_config

703

704

# Override the settings from the config file with command line

705

# options, if set.

706

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

707

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

708

value = getattr(options, option)

709

if value is not None:

710

server_settings[option] = value

711

del options

712

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

713

714

# Parse config file with clients

715

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

716

"interval": "5m",

717

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

718

}

719

client_config = ConfigParser.SafeConfigParser(client_defaults)

720

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

721

"clients.conf"))

722

723

global service

724

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

725

type = "_mandos._tcp", );

726

if server_settings["interface"]:

727

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

728

729

global main_loop

730

global bus

731

global server

732

# From the Avahi example code

613

733

DBusGMainLoop(set_as_default=True )

614

734

main_loop = gobject.MainLoop()

615

735

bus = dbus.SystemBus()

618

738

avahi.DBUS_INTERFACE_SERVER )

619

739

# End of Avahi example code

620

740

621

debug = options.debug

741

debug = server_settings["debug"]

622

742

623

743

if debug:

624

744

console = logging.StreamHandler()

633

753

clients.remove(client)

634

754

if not clients:

635

755

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

636

killme()

756

sys.exit()

637

757

638

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

758

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

639

759

stop_hook = remove_from_clients,

640

760

**(dict(client_config\

641

761

.items(section))))

647

767

def cleanup():

648

768

"Cleanup function; run on exit"

649

769

global group

650

# From the Avahi server example code

770

# From the Avahi example code

651

771

if not group is None:

652

772

group.Free()

653

773

group = None

654

774

# End of Avahi example code

655

775

656

for client in clients:

776

while clients:

777

client = clients.pop()

657

778

client.stop_hook = None

658

779

client.stop()

659

780

661

782

662

783

if not debug:

663

784

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

785

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

786

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

666

787

667

788

for client in clients:

668

789

client.start()

669

790

670

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

791

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

792

server_settings["port"]),

671

793

tcp_handler,

672

options=options,

794

settings=server_settings,

673

795

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:

796

# Find out what port we got

797

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

798

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

799

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

800

801

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

802

803

try:

804

# From the Avahi example code

805

server.connect_to_signal("StateChanged", server_state_changed)

806

try:

807

server_state_changed(server.GetState())

808

except dbus.exceptions.DBusException, error:

809

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

810

sys.exit(1)

811

# End of Avahi example code

812

813

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

814

lambda *args, **kwargs:

815

tcp_server.handle_request\

816

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

817

818

logger.debug("Starting main loop")

695

819

main_loop_started = True

696

820

main_loop.run()

821

except AvahiError, error:

822

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

823

sys.exit(1)

697

824

except KeyboardInterrupt:

698

825

if debug:

699

826

print

700

701

sys.exit(exitstatus)

827

828

if __name__ == '__main__':

829

main()