/mandos/trunk : revision 22

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

9

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

10

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

11

# in "main".

12

#

13

# Everything else is

14

13

14

# Påhlsson.

15

#

16

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

17

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

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

28

# <http://www.gnu.org/licenses/>.

27

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

29

28

#

30

# Contact the authors at <mandos@fukt.bsnet.se>.

29

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

30

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

31

#

32

33

from __future__ import division

34

35

import SocketServer

36

import socket

37

import select

37

38

from optparse import OptionParser

38

39

import datetime

39

40

import errno

54

55

import stat

55

56

import logging

56

57

import logging.handlers

57

import pwd

58

59

import dbus

60

import gobject

61

import avahi

62

from dbus.mainloop.glib import DBusGMainLoop

63

import ctypes

64

import ctypes.util

65

66

version = "1.0"

64

65

# Brief description of the operation of this program:

66

#

67

# This server announces itself as a Zeroconf service. Connecting

68

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

69

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

70

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

71

# supply an OpenPGP certificate, and the fingerprint of this

72

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

73

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

74

# authentication or authorization is done by this server.

75

67

76

68

77

logger = logging.Logger('mandos')

69

78

syslogger = logging.handlers.SysLogHandler\

70

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

71

address = "/dev/log")

79

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

72

80

syslogger.setFormatter(logging.Formatter\

73

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

81

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

74

82

logger.addHandler(syslogger)

75

76

console = logging.StreamHandler()

77

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

78

' %(message)s'))

79

logger.addHandler(console)

80

81

class AvahiError(Exception):

82

def __init__(self, value):

83

self.value = value

84

super(AvahiError, self).__init__()

85

def __str__(self):

86

return repr(self.value)

87

88

class AvahiServiceError(AvahiError):

89

pass

90

91

class AvahiGroupError(AvahiError):

92

pass

93

94

95

class AvahiService(object):

96

"""An Avahi (Zeroconf) service.

97

Attributes:

98

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

99

Used to optionally bind to the specified interface.

100

name: string; Example: 'Mandos'

101

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

102

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

103

port: integer; what port to announce

104

TXT: list of strings; TXT record for the service

105

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

106

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

107

max_renames: integer; maximum number of renames

108

rename_count: integer; counter so we only rename after collisions

109

a sensible number of times

110

"""

111

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

112

servicetype = None, port = None, TXT = None, domain = "",

113

host = "", max_renames = 32768):

114

self.interface = interface

115

self.name = name

116

self.type = servicetype

117

self.port = port

118

if TXT is None:

119

self.TXT = []

120

else:

121

self.TXT = TXT

122

self.domain = domain

123

self.host = host

124

self.rename_count = 0

125

self.max_renames = max_renames

126

def rename(self):

127

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

128

if self.rename_count >= self.max_renames:

129

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

130

u" after %i retries, exiting.",

131

self.rename_count)

132

raise AvahiServiceError("Too many renames")

133

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

134

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

135

str(self.name))

136

syslogger.setFormatter(logging.Formatter\

137

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

138

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

139

self.remove()

140

self.add()

141

self.rename_count += 1

142

def remove(self):

143

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

144

if group is not None:

145

group.Reset()

146

def add(self):

147

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

148

global group

149

if group is None:

150

group = dbus.Interface\

151

(bus.get_object(avahi.DBUS_NAME,

152

server.EntryGroupNew()),

153

avahi.DBUS_INTERFACE_ENTRY_GROUP)

154

group.connect_to_signal('StateChanged',

155

entry_group_state_changed)

156

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

157

service.name, service.type)

158

group.AddService(

159

self.interface, # interface

160

avahi.PROTO_INET6, # protocol

161

dbus.UInt32(0), # flags

162

self.name, self.type,

163

self.domain, self.host,

164

dbus.UInt16(self.port),

165

avahi.string_array_to_txt_array(self.TXT))

166

group.Commit()

167

83

del syslogger

84

85

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

86

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

87

# Avahi example code.

88

serviceInterface = avahi.IF_UNSPEC

168

89

# From the Avahi example code:

169

group = None # our entry group

90

serviceName = "Mandos"

91

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

92

servicePort = None # Not known at startup

93

serviceTXT = [] # TXT record for the service

94

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

95

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

96

group = None #our entry group

97

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

98

# sensible number of times

170

99

# End of Avahi example code

171

100

172

101

177

106

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

178

107

uniquely identify the client

179

108

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

180

host: string; available for use by the checker command

181

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

182

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

183

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

184

until this client is invalid

109

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

110

created: datetime.datetime()

111

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

112

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

113

this client is invalid

185

114

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

186

115

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

187

116

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

188

117

to see if the client lives.

189

'None' if no process is running.

118

Is None if no process is running.

190

119

checker_initiator_tag: a gobject event source tag, or None

191

120

stop_initiator_tag: - '' -

192

121

checker_callback_tag: - '' -

193

122

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

194

client lives. %() expansions are done at

123

client lives. %()s expansions are done at

195

124

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

196

125

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

197

126

Private attibutes:

198

127

_timeout: Real variable for 'timeout'

199

128

_interval: Real variable for 'interval'

200

_timeout_milliseconds: Used when calling gobject.timeout_add()

129

_timeout_milliseconds: Used by gobject.timeout_add()

201

130

_interval_milliseconds: - '' -

202

131

"""

203

132

def _set_timeout(self, timeout):

223

152

interval = property(lambda self: self._interval,

224

153

_set_interval)

225

154

del _set_interval

226

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

227

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

228

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

229

attribute."""

230

if config is None:

231

config = {}

155

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

156

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

157

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

158

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

159

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

232

160

self.name = name

233

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

234

# Uppercase and remove spaces from fingerprint for later

235

# comparison purposes with return value from the fingerprint()

236

# function

237

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

238

.replace(u" ", u"")

239

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

240

if "secret" in config:

241

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

242

elif "secfile" in config:

243

secfile = open(config["secfile"])

244

self.secret = secfile.read()

245

secfile.close()

161

# Uppercase and remove spaces from fingerprint

162

# for later comparison purposes with return value of

163

# the fingerprint() function

164

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

165

if secret:

166

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

167

elif secfile:

168

sf = open(secfile)

169

self.secret = sf.read()

170

sf.close()

246

171

else:

247

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

248

% self.name)

249

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

172

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

173

% self.name)

174

self.fqdn = fqdn # string

250

175

self.created = datetime.datetime.now()

251

self.last_checked_ok = None

252

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

253

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

176

self.last_seen = None

177

if timeout is None:

178

self.timeout = options.timeout

179

else:

180

self.timeout = string_to_delta(timeout)

181

if interval == -1:

182

self.interval = options.interval

183

else:

184

self.interval = string_to_delta(interval)

254

185

self.stop_hook = stop_hook

255

186

self.checker = None

256

187

self.checker_initiator_tag = None

257

188

self.stop_initiator_tag = None

258

189

self.checker_callback_tag = None

259

self.check_command = config["checker"]

190

self.check_command = checker

260

191

def start(self):

261

192

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

262

193

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

272

203

self.stop)

273

204

def stop(self):

274

205

"""Stop this client.

275

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

276

but not currently used."""

206

The possibility that this client might be restarted is left

207

open, but not currently used."""

277

208

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

278

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

279

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

209

if self.secret:

210

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

280

211

self.secret = None

281

212

else:

282

213

return False

283

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

214

if hasattr(self, "stop_initiator_tag") \

215

and self.stop_initiator_tag:

284

216

gobject.source_remove(self.stop_initiator_tag)

285

217

self.stop_initiator_tag = None

286

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

218

if hasattr(self, "checker_initiator_tag") \

219

and self.checker_initiator_tag:

287

220

gobject.source_remove(self.checker_initiator_tag)

288

221

self.checker_initiator_tag = None

289

222

self.stop_checker()

301

234

self.checker = None

302

235

if os.WIFEXITED(condition) \

303

236

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

304

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

305

vars(self))

306

self.last_checked_ok = now

237

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

238

vars(self))

239

self.last_seen = now

307

240

gobject.source_remove(self.stop_initiator_tag)

308

241

self.stop_initiator_tag = gobject.timeout_add\

309

242

(self._timeout_milliseconds,

312

245

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

313

246

vars(self))

314

247

else:

315

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

316

vars(self))

248

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

249

vars(self))

317

250

def start_checker(self):

318

251

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

319

252

If a checker already exists, leave it running and do

328

261

# is as it should be.

329

262

if self.checker is None:

330

263

try:

331

# In case check_command has exactly one % operator

332

command = self.check_command % self.host

264

command = self.check_command % self.fqdn

333

265

except TypeError:

334

# Escape attributes for the shell

335

266

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

336

267

for key, val in

337

268

vars(self).iteritems())

338

269

try:

339

270

command = self.check_command % escaped_attrs

340

271

except TypeError, error:

341

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

342

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

272

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

273

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

343

274

return True # Try again later

344

275

try:

345

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

346

command, self.name)

347

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

348

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

349

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

350

# always replaced by /dev/null.)

351

self.checker = subprocess.Popen(command,

352

close_fds=True,

353

shell=True, cwd="/")

276

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

277

command, self.name)

278

self.checker = subprocess.\

279

Popen(command,

280

close_fds=True, shell=True,

281

cwd="/")

354

282

self.checker_callback_tag = gobject.child_watch_add\

355

283

(self.checker.pid,

356

284

self.checker_callback)

357

except OSError, error:

285

except subprocess.OSError, error:

358

286

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

359

287

error)

360

288

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

364

292

if self.checker_callback_tag:

365

293

gobject.source_remove(self.checker_callback_tag)

366

294

self.checker_callback_tag = None

367

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

295

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

368

296

return

369

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

297

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

370

298

try:

371

299

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

372

300

#os.sleep(0.5)

373

301

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

374

302

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

375

303

except OSError, error:

376

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

304

if error.errno != errno.ESRCH:

377

305

raise

378

306

self.checker = None

379

def still_valid(self):

307

def still_valid(self, now=None):

380

308

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

381

now = datetime.datetime.now()

382

if self.last_checked_ok is None:

309

if now is None:

310

now = datetime.datetime.now()

311

if self.last_seen is None:

383

312

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

384

313

else:

385

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

314

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

386

315

387

316

388

317

def peer_certificate(session):

404

333

405

334

def fingerprint(openpgp):

406

335

"Convert an OpenPGP bytestring to a hexdigit fingerprint string"

336

# New empty GnuTLS certificate

337

crt = gnutls.library.types.gnutls_openpgp_crt_t()

338

gnutls.library.functions.gnutls_openpgp_crt_init\

339

(ctypes.byref(crt))

407

340

# New GnuTLS "datum" with the OpenPGP public key

408

341

datum = gnutls.library.types.gnutls_datum_t\

409

342

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

410

343

ctypes.POINTER(ctypes.c_ubyte)),

411

344

ctypes.c_uint(len(openpgp)))

412

# New empty GnuTLS certificate

413

crt = gnutls.library.types.gnutls_openpgp_crt_t()

414

gnutls.library.functions.gnutls_openpgp_crt_init\

415

(ctypes.byref(crt))

416

345

# Import the OpenPGP public key into the certificate

417

gnutls.library.functions.gnutls_openpgp_crt_import\

418

(crt, ctypes.byref(datum),

419

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

420

# Verify the self signature in the key

421

crtverify = ctypes.c_uint()

422

gnutls.library.functions.gnutls_openpgp_crt_verify_self\

423

(crt, 0, ctypes.byref(crtverify))

424

if crtverify.value != 0:

425

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

426

raise gnutls.errors.CertificateSecurityError("Verify failed")

346

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

347

(crt,

348

ctypes.byref(datum),

349

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

427

350

# New buffer for the fingerprint

428

buf = ctypes.create_string_buffer(20)

429

buf_len = ctypes.c_size_t()

351

buffer = ctypes.create_string_buffer(20)

352

buffer_length = ctypes.c_size_t()

430

353

# Get the fingerprint from the certificate into the buffer

431

354

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\

432

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

355

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

433

356

# Deinit the certificate

434

357

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

435

358

# Convert the buffer to a Python bytestring

436

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

359

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

437

360

# Convert the bytestring to hexadecimal notation

438

361

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

439

362

return hex_fpr

440

363

441

364

442

class TCP_handler(SocketServer.BaseRequestHandler, object):

365

class tcp_handler(SocketServer.BaseRequestHandler, object):

443

366

"""A TCP request handler class.

444

367

Instantiated by IPv6_TCPServer for each request to handle it.

445

368

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

446

369

447

370

def handle(self):

448

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

371

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

449

372

unicode(self.client_address))

450

session = gnutls.connection.ClientSession\

451

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

452

453

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

454

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

455

try:

456

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

457

raise RuntimeError

458

except (ValueError, IndexError, RuntimeError), error:

459

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

460

return

461

462

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

463

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

464

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

465

# using OpenPGP certificates.

373

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

374

gnutls.connection.\

375

X509Credentials())

466

376

467

377

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

468

378

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

469

379

# "+DHE-DSS"))

470

priority = "NORMAL" # Fallback default, since this

471

# MUST be set.

472

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

473

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

380

priority = "SECURE256"

381

474

382

gnutls.library.functions.gnutls_priority_set_direct\

475

(session._c_object, priority, None)

383

(session._c_object, priority, None);

476

384

477

385

try:

478

386

session.handshake()

479

387

except gnutls.errors.GNUTLSError, error:

480

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

388

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

481

389

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

482

390

# established. Just abandon the request.

483

391

return

484

392

try:

485

393

fpr = fingerprint(peer_certificate(session))

486

394

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

487

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

395

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

488

396

session.bye()

489

397

return

490

398

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

493

401

if c.fingerprint == fpr:

494

402

client = c

495

403

break

496

if not client:

497

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

498

fpr)

499

session.bye()

500

return

501

404

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

502

405

# that the client timed out while establishing the GnuTLS

503

406

# session.

504

if not client.still_valid():

505

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

506

vars(client))

407

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

408

if client:

409

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

410

vars(client))

411

else:

412

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

413

fpr)

507

414

session.bye()

508

415

return

509

416

sent_size = 0

519

426

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

520

427

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

521

428

Attributes:

522

settings: Server settings

429

options: Command line options

523

430

clients: Set() of Client objects

524

enabled: Boolean; whether this server is activated yet

525

431

"""

526

432

address_family = socket.AF_INET6

527

433

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

528

if "settings" in kwargs:

529

self.settings = kwargs["settings"]

530

del kwargs["settings"]

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

531

437

if "clients" in kwargs:

532

438

self.clients = kwargs["clients"]

533

439

del kwargs["clients"]

534

self.enabled = False

535

super(IPv6_TCPServer, self).__init__(*args, **kwargs)

440

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

536

441

def server_bind(self):

537

442

"""This overrides the normal server_bind() function

538

443

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

539

444

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

540

if self.settings["interface"]:

541

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

542

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

445

if self.options.interface:

446

if not hasattr(socket, "SO_BINDTODEVICE"):

447

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

448

socket.SO_BINDTODEVICE = 25

543

449

try:

544

450

self.socket.setsockopt(socket.SOL_SOCKET,

545

SO_BINDTODEVICE,

546

self.settings["interface"])

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

547

453

except socket.error, error:

548

454

if error[0] == errno.EPERM:

549

logger.error(u"No permission to"

550

u" bind to interface %s",

551

self.settings["interface"])

455

logger.warning(u"No permission to"

456

u" bind to interface %s",

457

self.options.interface)

552

458

else:

553

459

raise error

554

460

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

557

463

in6addr_any = "::"

558

464

self.server_address = (in6addr_any,

559

465

self.server_address[1])

560

elif not self.server_address[1]:

466

elif self.server_address[1] is None:

561

467

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

562

468

0)

563

# if self.settings["interface"]:

564

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

565

# 0, # port

566

# 0, # flowinfo

567

# if_nametoindex

568

# (self.settings

569

# ["interface"]))

570

return super(IPv6_TCPServer, self).server_bind()

571

def server_activate(self):

572

if self.enabled:

573

return super(IPv6_TCPServer, self).server_activate()

574

def enable(self):

575

self.enabled = True

469

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

576

470

577

471

578

472

def string_to_delta(interval):

588

482

datetime.timedelta(1)

589

483

>>> string_to_delta(u'1w')

590

484

datetime.timedelta(7)

591

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

592

datetime.timedelta(0, 330)

593

485

"""

594

timevalue = datetime.timedelta(0)

595

for s in interval.split():

596

try:

597

suffix = unicode(s[-1])

598

value = int(s[:-1])

599

if suffix == u"d":

600

delta = datetime.timedelta(value)

601

elif suffix == u"s":

602

delta = datetime.timedelta(0, value)

603

elif suffix == u"m":

604

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

605

elif suffix == u"h":

606

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

607

elif suffix == u"w":

608

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

609

else:

610

raise ValueError

611

except (ValueError, IndexError):

486

try:

487

suffix=unicode(interval[-1])

488

value=int(interval[:-1])

489

if suffix == u"d":

490

delta = datetime.timedelta(value)

491

elif suffix == u"s":

492

delta = datetime.timedelta(0, value)

493

elif suffix == u"m":

494

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

495

elif suffix == u"h":

496

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

497

elif suffix == u"w":

498

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

499

else:

612

500

raise ValueError

613

timevalue += delta

614

return timevalue

501

except (ValueError, IndexError):

502

raise ValueError

503

return delta

504

505

506

def add_service():

507

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

508

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

509

domain, host

510

if group is None:

511

group = dbus.Interface(

512

bus.get_object( avahi.DBUS_NAME,

513

server.EntryGroupNew()),

514

avahi.DBUS_INTERFACE_ENTRY_GROUP)

515

group.connect_to_signal('StateChanged',

516

entry_group_state_changed)

517

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

518

serviceName, serviceType)

519

520

group.AddService(

521

serviceInterface, # interface

522

avahi.PROTO_INET6, # protocol

523

dbus.UInt32(0), # flags

524

serviceName, serviceType,

525

domain, host,

526

dbus.UInt16(servicePort),

527

avahi.string_array_to_txt_array(serviceTXT))

528

group.Commit()

529

530

531

def remove_service():

532

"""From the Avahi example code"""

533

global group

534

535

if not group is None:

536

group.Reset()

615

537

616

538

617

539

def server_state_changed(state):

618

540

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

619

541

if state == avahi.SERVER_COLLISION:

620

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

621

service.remove()

542

logger.warning(u"Server name collision")

543

remove_service()

622

544

elif state == avahi.SERVER_RUNNING:

623

service.add()

545

add_service()

624

546

625

547

626

548

def entry_group_state_changed(state, error):

627

549

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

628

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

550

global serviceName, server, rename_count

551

552

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

629

553

630

554

if state == avahi.ENTRY_GROUP_ESTABLISHED:

631

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

555

logger.debug(u"Service established.")

632

556

elif state == avahi.ENTRY_GROUP_COLLISION:

633

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

634

service.rename()

557

558

rename_count = rename_count - 1

559

if rename_count > 0:

560

name = server.GetAlternativeServiceName(name)

561

logger.warning(u"Service name collision, "

562

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

563

remove_service()

564

add_service()

565

566

else:

567

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

568

u" retries, exiting.", n_rename)

569

killme(1)

635

570

elif state == avahi.ENTRY_GROUP_FAILURE:

636

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

637

unicode(error))

638

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

571

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

572

unicode(error))

573

killme(1)

574

639

575

640

576

def if_nametoindex(interface):

641

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

642

global if_nametoindex

577

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

643

578

try:

644

if_nametoindex = ctypes.cdll.LoadLibrary\

645

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

579

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

580

return libc.if_nametoindex(interface)

646

581

except (OSError, AttributeError):

647

582

if "struct" not in sys.modules:

648

583

import struct

649

584

if "fcntl" not in sys.modules:

650

585

import fcntl

651

def if_nametoindex(interface):

652

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

653

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

654

s = socket.socket()

655

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

656

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

657

s.close()

658

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

659

return interface_index

660

return if_nametoindex(interface)

661

662

663

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

586

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

587

s = socket.socket()

588

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

589

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

590

s.close()

591

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

592

return interface_index

593

594

595

def daemon(nochdir, noclose):

664

596

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

665

597

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

666

598

if os.fork():

668

600

os.setsid()

669

601

if not nochdir:

670

602

os.chdir("/")

671

if os.fork():

672

sys.exit()

673

603

if not noclose:

674

604

# Close all standard open file descriptors

675

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

605

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

676

606

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

677

607

raise OSError(errno.ENODEV,

678

608

"/dev/null not a character device")

683

613

os.close(null)

684

614

685

615

616

def killme(status = 0):

617

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

618

exitstatus = status

619

if main_loop_started:

620

main_loop.quit()

621

else:

622

sys.exit(status)

623

624

686

625

def main():

687

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

626

global exitstatus

627

exitstatus = 0

628

global main_loop_started

629

main_loop_started = False

630

631

parser = OptionParser()

688

632

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

689

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

690

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

633

default=None, metavar="IF",

634

help="Bind to interface IF")

635

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

691

636

help="Address to listen for requests on")

692

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

637

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

693

638

help="Port number to receive requests on")

639

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

640

default="1h",

641

help="Amount of downtime allowed for clients")

642

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

643

default="5m",

644

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

694

645

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

695

646

help="Run self-test")

696

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

697

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

698

" terminal")

699

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

700

" priority string (see GnuTLS documentation)")

701

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

702

help="Zeroconf service name")

703

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

704

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

705

help="Directory to search for configuration"

706

" files")

707

options = parser.parse_args()[0]

647

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

648

help="Debug mode")

649

(options, args) = parser.parse_args()

708

650

709

651

if options.check:

710

652

import doctest

711

653

doctest.testmod()

712

654

sys.exit()

713

655

714

# Default values for config file for server-global settings

715

server_defaults = { "interface": "",

716

"address": "",

717

"port": "",

718

"debug": "False",

719

"priority":

720

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

721

"servicename": "Mandos",

722

}

723

724

# Parse config file for server-global settings

725

server_config = ConfigParser.SafeConfigParser(server_defaults)

726

del server_defaults

727

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

728

# Convert the SafeConfigParser object to a dict

729

server_settings = server_config.defaults()

730

# Use getboolean on the boolean config option

731

server_settings["debug"] = server_config.getboolean\

732

("DEFAULT", "debug")

733

del server_config

734

735

# Override the settings from the config file with command line

736

# options, if set.

737

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

738

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

739

value = getattr(options, option)

740

if value is not None:

741

server_settings[option] = value

742

del options

743

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

744

745

debug = server_settings["debug"]

746

747

if not debug:

748

syslogger.setLevel(logging.WARNING)

749

console.setLevel(logging.WARNING)

750

751

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

752

syslogger.setFormatter(logging.Formatter\

753

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

754

' %%(message)s'

755

% server_settings["servicename"]))

756

757

# Parse config file with clients

758

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

759

"interval": "5m",

760

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

761

"host": "",

762

}

763

client_config = ConfigParser.SafeConfigParser(client_defaults)

764

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

765

"clients.conf"))

766

767

clients = Set()

768

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

769

server_settings["port"]),

770

TCP_handler,

771

settings=server_settings,

772

clients=clients)

773

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

774

try:

775

pidfile = open(pidfilename, "w")

776

except IOError, error:

777

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

778

779

uid = 65534

780

gid = 65534

781

try:

782

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

783

except KeyError:

784

try:

785

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

786

except KeyError:

787

pass

788

try:

789

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

790

except KeyError:

791

try:

792

gid = pwd.getpwnam("nogroup").pw_gid

793

except KeyError:

794

pass

795

try:

796

os.setuid(uid)

797

os.setgid(gid)

798

except OSError, error:

799

if error[0] != errno.EPERM:

800

raise error

801

802

global service

803

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

804

servicetype = "_mandos._tcp", )

805

if server_settings["interface"]:

806

service.interface = if_nametoindex\

807

(server_settings["interface"])

656

# Parse the time arguments

657

try:

658

options.timeout = string_to_delta(options.timeout)

659

except ValueError:

660

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

661

try:

662

options.interval = string_to_delta(options.interval)

663

except ValueError:

664

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

665

666

# Parse config file

667

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

668

client_config = ConfigParser.SafeConfigParser(defaults)

669

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

670

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

808

671

809

672

global main_loop

810

673

global bus

813

676

DBusGMainLoop(set_as_default=True )

814

677

main_loop = gobject.MainLoop()

815

678

bus = dbus.SystemBus()

816

server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,

817

avahi.DBUS_PATH_SERVER),

818

avahi.DBUS_INTERFACE_SERVER)

679

server = dbus.Interface(

680

bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),

681

avahi.DBUS_INTERFACE_SERVER )

819

682

# End of Avahi example code

820

683

684

debug = options.debug

685

686

if debug:

687

console = logging.StreamHandler()

688

# console.setLevel(logging.DEBUG)

689

console.setFormatter(logging.Formatter\

690

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

691

logger.addHandler(console)

692

del console

693

694

clients = Set()

821

695

def remove_from_clients(client):

822

696

clients.remove(client)

823

697

if not clients:

824

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

825

sys.exit()

698

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

699

killme()

826

700

827

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

701

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

828

702

stop_hook = remove_from_clients,

829

config

830

= dict(client_config.items(section)))

703

**(dict(client_config\

704

.items(section))))

831

705

for section in client_config.sections()))

832

if not clients:

833

logger.critical(u"No clients defined")

834

sys.exit(1)

835

836

if debug:

837

# Redirect stdin so all checkers get /dev/null

838

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

839

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

840

if null > 2:

841

os.close(null)

842

else:

843

# No console logging

844

logger.removeHandler(console)

845

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

846

daemon()

847

848

try:

849

pid = os.getpid()

850

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

851

pidfile.close()

852

del pidfile

853

except IOError:

854

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

855

pidfilename, pid)

856

except NameError:

857

# "pidfile" was never created

858

pass

859

del pidfilename

706

707

if not debug:

708

daemon(False, False)

860

709

861

710

def cleanup():

862

711

"Cleanup function; run on exit"

876

725

877

726

if not debug:

878

727

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

879

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

880

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

728

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

729

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

881

730

882

731

for client in clients:

883

732

client.start()

884

733

885

tcp_server.enable()

886

tcp_server.server_activate()

887

888

# Find out what port we got

889

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

890

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

891

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

892

893

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

894

895

try:

896

# From the Avahi example code

897

server.connect_to_signal("StateChanged", server_state_changed)

898

try:

899

server_state_changed(server.GetState())

900

except dbus.exceptions.DBusException, error:

901

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

902

sys.exit(1)

903

# End of Avahi example code

904

905

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

906

lambda *args, **kwargs:

907

tcp_server.handle_request\

908

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

909

910

logger.debug(u"Starting main loop")

734

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

735

tcp_handler,

736

options=options,

737

clients=clients)

738

# Find out what random port we got

739

global servicePort

740

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

741

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

742

743

if options.interface is not None:

744

global serviceInterface

745

serviceInterface = if_nametoindex(options.interface)

746

747

# From the Avahi example code

748

server.connect_to_signal("StateChanged", server_state_changed)

749

try:

750

server_state_changed(server.GetState())

751

except dbus.exceptions.DBusException, error:

752

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

753

killme(1)

754

# End of Avahi example code

755

756

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

757

lambda *args, **kwargs:

758

tcp_server.handle_request(*args[2:],

759

**kwargs) or True)

760

try:

761

logger.debug("Starting main loop")

762

main_loop_started = True

911

763

main_loop.run()

912

except AvahiError, error:

913

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

914

sys.exit(1)

915

764

except KeyboardInterrupt:

916

765

if debug:

917

766

print

767

768

sys.exit(exitstatus)

918

769

919

770

if __name__ == '__main__':

920

771

main()