/mandos/trunk : revision 183

6

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

7

# service publisher, downloaded from

8

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

9

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

10

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

11

# in "main".

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

14

# Påhlsson.

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

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

27

# along with this program. If not, see

28

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

28

29

#

29

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

30

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

30

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

31

#

32

33

from __future__ import division

55

import stat

56

import logging

57

import logging.handlers

58

import pwd

58

59

60

import dbus

60

61

import gobject

62

63

from dbus.mainloop.glib import DBusGMainLoop

63

64

import ctypes

64

65

# Brief description of the operation of this program:

66

#

67

# This server announces itself as a Zeroconf service. Connecting

68

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

69

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

70

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

71

# supply an OpenPGP certificate, and the fingerprint of this

72

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

73

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

74

# authentication or authorization is done by this server.

75

66

version = "1.0"

76

67

77

68

logger = logging.Logger('mandos')

78

69

syslogger = logging.handlers.SysLogHandler\

79

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

70

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

71

address = "/dev/log")

80

72

syslogger.setFormatter(logging.Formatter\

81

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

73

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

82

74

logger.addHandler(syslogger)

83

del syslogger

84

85

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

86

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

87

# Avahi example code.

88

serviceInterface = avahi.IF_UNSPEC

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

def __str__(self):

85

return repr(self.value)

86

87

class AvahiServiceError(AvahiError):

88

pass

89

90

class AvahiGroupError(AvahiError):

91

pass

92

93

94

class AvahiService(object):

95

"""An Avahi (Zeroconf) service.

96

Attributes:

97

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

98

Used to optionally bind to the specified interface.

99

name: string; Example: 'Mandos'

100

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

101

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

102

port: integer; what port to announce

103

TXT: list of strings; TXT record for the service

104

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

105

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

106

max_renames: integer; maximum number of renames

107

rename_count: integer; counter so we only rename after collisions

108

a sensible number of times

109

"""

110

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

111

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

112

host = "", max_renames = 32768):

113

self.interface = interface

114

self.name = name

115

self.type = type

116

self.port = port

117

if TXT is None:

118

self.TXT = []

119

else:

120

self.TXT = TXT

121

self.domain = domain

122

self.host = host

123

self.rename_count = 0

124

self.max_renames = max_renames

125

def rename(self):

126

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

127

if self.rename_count >= self.max_renames:

128

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

129

u" after %i retries, exiting.",

130

rename_count)

131

raise AvahiServiceError("Too many renames")

132

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

133

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

134

str(self.name))

135

syslogger.setFormatter(logging.Formatter\

136

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

137

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

138

self.remove()

139

self.add()

140

self.rename_count += 1

141

def remove(self):

142

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

143

if group is not None:

144

group.Reset()

145

def add(self):

146

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

147

global group

148

if group is None:

149

group = dbus.Interface\

150

(bus.get_object(avahi.DBUS_NAME,

151

server.EntryGroupNew()),

152

avahi.DBUS_INTERFACE_ENTRY_GROUP)

153

group.connect_to_signal('StateChanged',

154

entry_group_state_changed)

155

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

156

service.name, service.type)

157

group.AddService(

158

self.interface, # interface

159

avahi.PROTO_INET6, # protocol

160

dbus.UInt32(0), # flags

161

self.name, self.type,

162

self.domain, self.host,

163

dbus.UInt16(self.port),

164

avahi.string_array_to_txt_array(self.TXT))

165

group.Commit()

166

89

167

# From the Avahi example code:

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

168

group = None # our entry group

99

169

# End of Avahi example code

100

170

101

171

106

176

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

107

177

uniquely identify the client

108

178

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

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

179

host: string; available for use by the checker command

180

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

181

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

182

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

183

until this client is invalid

114

184

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

115

185

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

116

186

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

117

187

to see if the client lives.

118

Is None if no process is running.

188

'None' if no process is running.

119

189

checker_initiator_tag: a gobject event source tag, or None

120

190

stop_initiator_tag: - '' -

121

191

checker_callback_tag: - '' -

122

192

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

123

client lives. %()s expansions are done at

193

client lives. %() expansions are done at

124

194

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

125

195

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

126

196

Private attibutes:

127

197

_timeout: Real variable for 'timeout'

128

198

_interval: Real variable for 'interval'

129

_timeout_milliseconds: Used by gobject.timeout_add()

199

_timeout_milliseconds: Used when calling gobject.timeout_add()

130

200

_interval_milliseconds: - '' -

131

201

"""

132

202

def _set_timeout(self, timeout):

152

222

interval = property(lambda self: self._interval,

153

223

_set_interval)

154

224

del _set_interval

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

225

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

226

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

227

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

228

attribute."""

160

229

self.name = name

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)

230

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

231

# Uppercase and remove spaces from fingerprint for later

232

# comparison purposes with return value from the fingerprint()

233

# function

234

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

235

.replace(u" ", u"")

236

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

237

if "secret" in config:

238

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

239

elif "secfile" in config:

240

sf = open(config["secfile"])

169

241

self.secret = sf.read()

170

242

sf.close()

171

243

else:

172

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

173

% self.name)

174

self.fqdn = fqdn # string

244

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

245

% self.name)

246

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

175

247

self.created = datetime.datetime.now()

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)

248

self.last_checked_ok = None

249

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

250

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

185

251

self.stop_hook = stop_hook

186

252

self.checker = None

187

253

self.checker_initiator_tag = None

188

254

self.stop_initiator_tag = None

189

255

self.checker_callback_tag = None

190

self.check_command = checker

256

self.check_command = config["checker"]

191

257

def start(self):

192

258

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

193

259

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

203

269

self.stop)

204

270

def stop(self):

205

271

"""Stop this client.

206

The possibility that this client might be restarted is left

207

open, but not currently used."""

272

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

273

but not currently used."""

208

274

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

209

if self.secret:

210

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

275

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

276

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

211

277

self.secret = None

212

278

else:

213

279

return False

214

if hasattr(self, "stop_initiator_tag") \

215

and self.stop_initiator_tag:

280

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

216

281

gobject.source_remove(self.stop_initiator_tag)

217

282

self.stop_initiator_tag = None

218

if hasattr(self, "checker_initiator_tag") \

219

and self.checker_initiator_tag:

283

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

220

284

gobject.source_remove(self.checker_initiator_tag)

221

285

self.checker_initiator_tag = None

222

286

self.stop_checker()

234

298

self.checker = None

235

299

if os.WIFEXITED(condition) \

236

300

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

237

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

238

vars(self))

239

self.last_seen = now

301

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

302

vars(self))

303

self.last_checked_ok = now

240

304

gobject.source_remove(self.stop_initiator_tag)

241

305

self.stop_initiator_tag = gobject.timeout_add\

242

306

(self._timeout_milliseconds,

245

309

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

246

310

vars(self))

247

311

else:

248

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

249

vars(self))

312

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

313

vars(self))

250

314

def start_checker(self):

251

315

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

252

316

If a checker already exists, leave it running and do

261

325

# is as it should be.

262

326

if self.checker is None:

263

327

try:

264

command = self.check_command % self.fqdn

328

# In case check_command has exactly one % operator

329

command = self.check_command % self.host

265

330

except TypeError:

331

# Escape attributes for the shell

266

332

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

267

333

for key, val in

268

334

vars(self).iteritems())

269

335

try:

270

336

command = self.check_command % escaped_attrs

271

337

except TypeError, error:

272

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

273

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

338

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

339

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

274

340

return True # Try again later

275

341

try:

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

342

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

343

command, self.name)

344

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

345

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

346

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

347

# always replaced by /dev/null.)

348

self.checker = subprocess.Popen(command,

349

close_fds=True,

350

shell=True, cwd="/")

282

351

self.checker_callback_tag = gobject.child_watch_add\

283

352

(self.checker.pid,

284

353

self.checker_callback)

285

except subprocess.OSError, error:

354

except OSError, error:

286

355

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

287

356

error)

288

357

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

292

361

if self.checker_callback_tag:

293

362

gobject.source_remove(self.checker_callback_tag)

294

363

self.checker_callback_tag = None

295

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

364

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

296

365

return

297

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

366

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

298

367

try:

299

368

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

300

369

#os.sleep(0.5)

301

370

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

302

371

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

303

372

except OSError, error:

304

if error.errno != errno.ESRCH:

373

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

305

374

raise

306

375

self.checker = None

307

def still_valid(self, now=None):

376

def still_valid(self):

308

377

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

309

if now is None:

310

now = datetime.datetime.now()

311

if self.last_seen is None:

378

now = datetime.datetime.now()

379

if self.last_checked_ok is None:

312

380

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

313

381

else:

314

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

382

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

315

383

316

384

317

385

def peer_certificate(session):

333

401

334

402

def fingerprint(openpgp):

335

403

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

340

404

# New GnuTLS "datum" with the OpenPGP public key

341

405

datum = gnutls.library.types.gnutls_datum_t\

342

406

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

343

407

ctypes.POINTER(ctypes.c_ubyte)),

344

408

ctypes.c_uint(len(openpgp)))

409

# New empty GnuTLS certificate

410

crt = gnutls.library.types.gnutls_openpgp_crt_t()

411

gnutls.library.functions.gnutls_openpgp_crt_init\

412

(ctypes.byref(crt))

345

413

# Import the OpenPGP public key into the certificate

346

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

347

(crt,

348

ctypes.byref(datum),

349

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

414

gnutls.library.functions.gnutls_openpgp_crt_import\

415

(crt, ctypes.byref(datum),

416

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

417

# Verify the self signature in the key

418

crtverify = ctypes.c_uint();

419

gnutls.library.functions.gnutls_openpgp_crt_verify_self\

420

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

421

if crtverify.value != 0:

422

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

423

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

350

424

# New buffer for the fingerprint

351

425

buffer = ctypes.create_string_buffer(20)

352

426

buffer_length = ctypes.c_size_t()

368

442

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

369

443

370

444

def handle(self):

371

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

445

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

372

446

unicode(self.client_address))

373

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

374

gnutls.connection.\

375

X509Credentials())

447

session = gnutls.connection.ClientSession\

448

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

449

450

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

451

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

452

try:

453

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

454

raise RuntimeError

455

except (ValueError, IndexError, RuntimeError), error:

456

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

457

return

458

459

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

460

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

461

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

462

# using OpenPGP certificates.

376

463

377

464

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

378

465

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

379

466

# "+DHE-DSS"))

380

priority = "SECURE256"

381

467

priority = "NORMAL" # Fallback default, since this

468

# MUST be set.

469

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

470

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

382

471

gnutls.library.functions.gnutls_priority_set_direct\

383

472

(session._c_object, priority, None);

384

473

385

474

try:

386

475

session.handshake()

387

476

except gnutls.errors.GNUTLSError, error:

388

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

477

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

389

478

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

390

479

# established. Just abandon the request.

391

480

return

392

481

try:

393

482

fpr = fingerprint(peer_certificate(session))

394

483

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

395

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

484

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

396

485

session.bye()

397

486

return

398

487

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

401

490

if c.fingerprint == fpr:

402

491

client = c

403

492

break

493

if not client:

494

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

495

fpr)

496

session.bye()

497

return

404

498

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

405

499

# that the client timed out while establishing the GnuTLS

406

500

# session.

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)

501

if not client.still_valid():

502

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

503

vars(client))

414

504

session.bye()

415

505

return

416

506

sent_size = 0

426

516

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

427

517

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

428

518

Attributes:

429

options: Command line options

519

settings: Server settings

430

520

clients: Set() of Client objects

521

enabled: Boolean; whether this server is activated yet

431

522

"""

432

523

address_family = socket.AF_INET6

433

524

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

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

525

if "settings" in kwargs:

526

self.settings = kwargs["settings"]

527

del kwargs["settings"]

437

528

if "clients" in kwargs:

438

529

self.clients = kwargs["clients"]

439

530

del kwargs["clients"]

531

self.enabled = False

440

532

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

441

533

def server_bind(self):

442

534

"""This overrides the normal server_bind() function

443

535

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

444

536

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

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

537

if self.settings["interface"]:

538

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

539

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

449

540

try:

450

541

self.socket.setsockopt(socket.SOL_SOCKET,

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

542

SO_BINDTODEVICE,

543

self.settings["interface"])

453

544

except socket.error, error:

454

545

if error[0] == errno.EPERM:

455

logger.warning(u"No permission to"

456

u" bind to interface %s",

457

self.options.interface)

546

logger.error(u"No permission to"

547

u" bind to interface %s",

548

self.settings["interface"])

458

549

else:

459

550

raise error

460

551

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

463

554

in6addr_any = "::"

464

555

self.server_address = (in6addr_any,

465

556

self.server_address[1])

466

elif self.server_address[1] is None:

557

elif not self.server_address[1]:

467

558

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

468

559

0)

560

# if self.settings["interface"]:

561

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

562

# 0, # port

563

# 0, # flowinfo

564

# if_nametoindex

565

# (self.settings

566

# ["interface"]))

469

567

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

568

def server_activate(self):

569

if self.enabled:

570

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

571

def enable(self):

572

self.enabled = True

470

573

471

574

472

575

def string_to_delta(interval):

482

585

datetime.timedelta(1)

483

586

>>> string_to_delta(u'1w')

484

587

datetime.timedelta(7)

588

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

589

datetime.timedelta(0, 330)

485

590

"""

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:

591

timevalue = datetime.timedelta(0)

592

for s in interval.split():

593

try:

594

suffix=unicode(s[-1])

595

value=int(s[:-1])

596

if suffix == u"d":

597

delta = datetime.timedelta(value)

598

elif suffix == u"s":

599

delta = datetime.timedelta(0, value)

600

elif suffix == u"m":

601

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

602

elif suffix == u"h":

603

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

604

elif suffix == u"w":

605

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

606

else:

607

raise ValueError

608

except (ValueError, IndexError):

500

609

raise ValueError

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

610

timevalue += delta

611

return timevalue

537

612

538

613

539

614

def server_state_changed(state):

540

615

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

541

616

if state == avahi.SERVER_COLLISION:

542

logger.warning(u"Server name collision")

543

remove_service()

617

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

618

service.remove()

544

619

elif state == avahi.SERVER_RUNNING:

545

add_service()

620

service.add()

546

621

547

622

548

623

def entry_group_state_changed(state, error):

549

624

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

550

global serviceName, server, rename_count

551

552

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

625

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

553

626

554

627

if state == avahi.ENTRY_GROUP_ESTABLISHED:

555

logger.debug(u"Service established.")

628

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

556

629

elif state == avahi.ENTRY_GROUP_COLLISION:

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)

630

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

631

service.rename()

570

632

elif state == avahi.ENTRY_GROUP_FAILURE:

571

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

572

unicode(error))

573

killme(1)

574

633

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

634

unicode(error))

635

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

575

636

576

637

def if_nametoindex(interface):

577

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

638

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

639

global if_nametoindex

578

640

try:

579

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

580

return libc.if_nametoindex(interface)

641

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

642

import ctypes.util

643

if_nametoindex = ctypes.cdll.LoadLibrary\

644

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

581

645

except (OSError, AttributeError):

582

646

if "struct" not in sys.modules:

583

647

import struct

584

648

if "fcntl" not in sys.modules:

585

649

import fcntl

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

650

def if_nametoindex(interface):

651

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

652

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

653

s = socket.socket()

654

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

655

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

656

s.close()

657

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

658

return interface_index

659

return if_nametoindex(interface)

660

661

662

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

596

663

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

597

664

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

598

665

if os.fork():

600

667

os.setsid()

601

668

if not nochdir:

602

669

os.chdir("/")

670

if os.fork():

671

sys.exit()

603

672

if not noclose:

604

673

# Close all standard open file descriptors

605

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

674

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

606

675

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

607

676

raise OSError(errno.ENODEV,

608

677

"/dev/null not a character device")

613

682

os.close(null)

614

683

615

684

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

625

685

def main():

626

global exitstatus

627

exitstatus = 0

628

686

global main_loop_started

629

687

main_loop_started = False

630

688

631

parser = OptionParser()

689

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

632

690

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

633

default=None, metavar="IF",

634

help="Bind to interface IF")

635

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

691

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

692

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

636

693

help="Address to listen for requests on")

637

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

694

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

638

695

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

645

696

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

646

697

help="Run self-test")

647

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

648

help="Debug mode")

698

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

699

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

700

" terminal")

701

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

702

" priority string (see GnuTLS documentation)")

703

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

704

help="Zeroconf service name")

705

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

706

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

707

help="Directory to search for configuration"

708

" files")

649

709

(options, args) = parser.parse_args()

650

710

651

711

if options.check:

653

713

doctest.testmod()

654

714

sys.exit()

655

715

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

716

# Default values for config file for server-global settings

717

server_defaults = { "interface": "",

718

"address": "",

719

"port": "",

720

"debug": "False",

721

"priority":

722

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

723

"servicename": "Mandos",

724

}

725

726

# Parse config file for server-global settings

727

server_config = ConfigParser.SafeConfigParser(server_defaults)

728

del server_defaults

729

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

730

# Convert the SafeConfigParser object to a dict

731

server_settings = server_config.defaults()

732

# Use getboolean on the boolean config option

733

server_settings["debug"] = server_config.getboolean\

734

("DEFAULT", "debug")

735

del server_config

736

737

# Override the settings from the config file with command line

738

# options, if set.

739

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

740

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

741

value = getattr(options, option)

742

if value is not None:

743

server_settings[option] = value

744

del options

745

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

746

747

debug = server_settings["debug"]

748

749

if not debug:

750

syslogger.setLevel(logging.WARNING)

751

console.setLevel(logging.WARNING)

752

753

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

754

syslogger.setFormatter(logging.Formatter\

755

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

756

' %%(message)s'

757

% server_settings["servicename"]))

758

759

# Parse config file with clients

760

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

761

"interval": "5m",

762

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

763

"host": "",

764

}

765

client_config = ConfigParser.SafeConfigParser(client_defaults)

766

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

767

"clients.conf"))

768

769

clients = Set()

770

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

771

server_settings["port"]),

772

tcp_handler,

773

settings=server_settings,

774

clients=clients)

775

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

776

try:

777

pidfile = open(pidfilename, "w")

778

except IOError, error:

779

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

780

781

uid = 65534

782

gid = 65534

783

try:

784

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

785

except KeyError:

786

try:

787

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

788

except KeyError:

789

pass

790

try:

791

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

792

except KeyError:

793

try:

794

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

795

except KeyError:

796

pass

797

try:

798

os.setuid(uid)

799

os.setgid(gid)

800

except OSError, error:

801

if error[0] != errno.EPERM:

802

raise error

803

804

global service

805

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

806

type = "_mandos._tcp", );

807

if server_settings["interface"]:

808

service.interface = if_nametoindex\

809

(server_settings["interface"])

671

810

672

811

global main_loop

673

812

global bus

676

815

DBusGMainLoop(set_as_default=True )

677

816

main_loop = gobject.MainLoop()

678

817

bus = dbus.SystemBus()

679

server = dbus.Interface(

680

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

681

avahi.DBUS_INTERFACE_SERVER )

818

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

819

avahi.DBUS_PATH_SERVER),

820

avahi.DBUS_INTERFACE_SERVER)

682

821

# End of Avahi example code

683

822

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

695

823

def remove_from_clients(client):

696

824

clients.remove(client)

697

825

if not clients:

698

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

699

killme()

826

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

827

sys.exit()

700

828

701

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

829

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

702

830

stop_hook = remove_from_clients,

703

**(dict(client_config\

704

.items(section))))

831

config

832

= dict(client_config.items(section)))

705

833

for section in client_config.sections()))

706

707

if not debug:

708

daemon(False, False)

834

if not clients:

835

logger.critical(u"No clients defined")

836

sys.exit(1)

837

838

if debug:

839

# Redirect stdin so all checkers get /dev/null

840

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

841

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

842

if null > 2:

843

os.close(null)

844

else:

845

# No console logging

846

logger.removeHandler(console)

847

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

848

daemon()

849

850

try:

851

pid = os.getpid()

852

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

853

pidfile.close()

854

del pidfile

855

except IOError, err:

856

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

857

pidfilename, pid)

858

except NameError:

859

# "pidfile" was never created

860

pass

861

del pidfilename

709

862

710

863

def cleanup():

711

864

"Cleanup function; run on exit"

725

878

726

879

if not debug:

727

880

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

728

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

729

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

881

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

882

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

730

883

731

884

for client in clients:

732

885

client.start()

733

886

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

887

tcp_server.enable()

888

tcp_server.server_activate()

889

890

# Find out what port we got

891

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

892

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

893

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

894

895

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

896

897

try:

898

# From the Avahi example code

899

server.connect_to_signal("StateChanged", server_state_changed)

900

try:

901

server_state_changed(server.GetState())

902

except dbus.exceptions.DBusException, error:

903

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

904

sys.exit(1)

905

# End of Avahi example code

906

907

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

908

lambda *args, **kwargs:

909

tcp_server.handle_request\

910

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

911

912

logger.debug(u"Starting main loop")

762

913

main_loop_started = True

763

914

main_loop.run()

915

except AvahiError, error:

916

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

917

sys.exit(1)

764

918

except KeyboardInterrupt:

765

919

if debug:

766

920

print

767

768

sys.exit(exitstatus)

769

921

770

922

if __name__ == '__main__':

771

923

main()