/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

55

import stat

56

import logging

57

import logging.handlers

58

import pwd

59

58

60

59

import dbus

61

60

import gobject

63

62

from dbus.mainloop.glib import DBusGMainLoop

64

63

import ctypes

65

64

66

version = "1.0"

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

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

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

167

89

# From the Avahi example code:

168

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

169

99

# End of Avahi example code

170

100

171

101

176

106

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

177

107

uniquely identify the client

178

108

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

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

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

184

114

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

185

115

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

186

116

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

187

117

to see if the client lives.

188

'None' if no process is running.

118

Is None if no process is running.

189

119

checker_initiator_tag: a gobject event source tag, or None

190

120

stop_initiator_tag: - '' -

191

121

checker_callback_tag: - '' -

192

122

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

193

client lives. %() expansions are done at

123

client lives. %()s expansions are done at

194

124

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

195

125

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

196

126

Private attibutes:

197

127

_timeout: Real variable for 'timeout'

198

128

_interval: Real variable for 'interval'

199

_timeout_milliseconds: Used when calling gobject.timeout_add()

129

_timeout_milliseconds: Used by gobject.timeout_add()

200

130

_interval_milliseconds: - '' -

201

131

"""

202

132

def _set_timeout(self, timeout):

222

152

interval = property(lambda self: self._interval,

223

153

_set_interval)

224

154

del _set_interval

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

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

229

160

self.name = name

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

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)

241

169

self.secret = sf.read()

242

170

sf.close()

243

171

else:

244

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

245

% self.name)

246

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

172

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

173

% self.name)

174

self.fqdn = fqdn # string

247

175

self.created = datetime.datetime.now()

248

self.last_checked_ok = None

249

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

250

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)

251

185

self.stop_hook = stop_hook

252

186

self.checker = None

253

187

self.checker_initiator_tag = None

254

188

self.stop_initiator_tag = None

255

189

self.checker_callback_tag = None

256

self.check_command = config["checker"]

190

self.check_command = checker

257

191

def start(self):

258

192

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

259

193

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

269

203

self.stop)

270

204

def stop(self):

271

205

"""Stop this client.

272

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

273

but not currently used."""

206

The possibility that this client might be restarted is left

207

open, but not currently used."""

274

208

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

275

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

276

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

209

if self.secret:

210

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

277

211

self.secret = None

278

212

else:

279

213

return False

280

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

214

if hasattr(self, "stop_initiator_tag") \

215

and self.stop_initiator_tag:

281

216

gobject.source_remove(self.stop_initiator_tag)

282

217

self.stop_initiator_tag = None

283

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

218

if hasattr(self, "checker_initiator_tag") \

219

and self.checker_initiator_tag:

284

220

gobject.source_remove(self.checker_initiator_tag)

285

221

self.checker_initiator_tag = None

286

222

self.stop_checker()

298

234

self.checker = None

299

235

if os.WIFEXITED(condition) \

300

236

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

301

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

302

vars(self))

303

self.last_checked_ok = now

237

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

238

vars(self))

239

self.last_seen = now

304

240

gobject.source_remove(self.stop_initiator_tag)

305

241

self.stop_initiator_tag = gobject.timeout_add\

306

242

(self._timeout_milliseconds,

309

245

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

310

246

vars(self))

311

247

else:

312

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

313

vars(self))

248

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

249

vars(self))

314

250

def start_checker(self):

315

251

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

316

252

If a checker already exists, leave it running and do

325

261

# is as it should be.

326

262

if self.checker is None:

327

263

try:

328

# In case check_command has exactly one % operator

329

command = self.check_command % self.host

264

command = self.check_command % self.fqdn

330

265

except TypeError:

331

# Escape attributes for the shell

332

266

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

333

267

for key, val in

334

268

vars(self).iteritems())

335

269

try:

336

270

command = self.check_command % escaped_attrs

337

271

except TypeError, error:

338

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

339

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

272

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

273

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

340

274

return True # Try again later

341

275

try:

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

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

351

282

self.checker_callback_tag = gobject.child_watch_add\

352

283

(self.checker.pid,

353

284

self.checker_callback)

354

except OSError, error:

285

except subprocess.OSError, error:

355

286

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

356

287

error)

357

288

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

361

292

if self.checker_callback_tag:

362

293

gobject.source_remove(self.checker_callback_tag)

363

294

self.checker_callback_tag = None

364

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

295

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

365

296

return

366

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

297

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

367

298

try:

368

299

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

369

300

#os.sleep(0.5)

370

301

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

371

302

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

372

303

except OSError, error:

373

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

304

if error.errno != errno.ESRCH:

374

305

raise

375

306

self.checker = None

376

def still_valid(self):

307

def still_valid(self, now=None):

377

308

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

378

now = datetime.datetime.now()

379

if self.last_checked_ok is None:

309

if now is None:

310

now = datetime.datetime.now()

311

if self.last_seen is None:

380

312

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

381

313

else:

382

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

314

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

383

315

384

316

385

317

def peer_certificate(session):

401

333

402

334

def fingerprint(openpgp):

403

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

404

340

# New GnuTLS "datum" with the OpenPGP public key

405

341

datum = gnutls.library.types.gnutls_datum_t\

406

342

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

407

343

ctypes.POINTER(ctypes.c_ubyte)),

408

344

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

413

345

# Import the OpenPGP public key into the certificate

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

346

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

347

(crt,

348

ctypes.byref(datum),

349

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

424

350

# New buffer for the fingerprint

425

351

buffer = ctypes.create_string_buffer(20)

426

352

buffer_length = ctypes.c_size_t()

442

368

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

443

369

444

370

def handle(self):

445

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

371

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

446

372

unicode(self.client_address))

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.

373

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

374

gnutls.connection.\

375

X509Credentials())

463

376

464

377

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

465

378

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

466

379

# "+DHE-DSS"))

467

priority = "NORMAL" # Fallback default, since this

468

# MUST be set.

469

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

470

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

380

priority = "SECURE256"

381

471

382

gnutls.library.functions.gnutls_priority_set_direct\

472

383

(session._c_object, priority, None);

473

384

474

385

try:

475

386

session.handshake()

476

387

except gnutls.errors.GNUTLSError, error:

477

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

388

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

478

389

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

479

390

# established. Just abandon the request.

480

391

return

481

392

try:

482

393

fpr = fingerprint(peer_certificate(session))

483

394

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

484

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

395

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

485

396

session.bye()

486

397

return

487

398

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

490

401

if c.fingerprint == fpr:

491

402

client = c

492

403

break

493

if not client:

494

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

495

fpr)

496

session.bye()

497

return

498

404

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

499

405

# that the client timed out while establishing the GnuTLS

500

406

# session.

501

if not client.still_valid():

502

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

503

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)

504

414

session.bye()

505

415

return

506

416

sent_size = 0

516

426

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

517

427

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

518

428

Attributes:

519

settings: Server settings

429

options: Command line options

520

430

clients: Set() of Client objects

521

enabled: Boolean; whether this server is activated yet

522

431

"""

523

432

address_family = socket.AF_INET6

524

433

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

525

if "settings" in kwargs:

526

self.settings = kwargs["settings"]

527

del kwargs["settings"]

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

528

437

if "clients" in kwargs:

529

438

self.clients = kwargs["clients"]

530

439

del kwargs["clients"]

531

self.enabled = False

532

440

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

533

441

def server_bind(self):

534

442

"""This overrides the normal server_bind() function

535

443

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

536

444

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

537

if self.settings["interface"]:

538

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

539

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

540

449

try:

541

450

self.socket.setsockopt(socket.SOL_SOCKET,

542

SO_BINDTODEVICE,

543

self.settings["interface"])

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

544

453

except socket.error, error:

545

454

if error[0] == errno.EPERM:

546

logger.error(u"No permission to"

547

u" bind to interface %s",

548

self.settings["interface"])

455

logger.warning(u"No permission to"

456

u" bind to interface %s",

457

self.options.interface)

549

458

else:

550

459

raise error

551

460

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

554

463

in6addr_any = "::"

555

464

self.server_address = (in6addr_any,

556

465

self.server_address[1])

557

elif not self.server_address[1]:

466

elif self.server_address[1] is None:

558

467

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

559

468

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

567

469

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

573

470

574

471

575

472

def string_to_delta(interval):

585

482

datetime.timedelta(1)

586

483

>>> string_to_delta(u'1w')

587

484

datetime.timedelta(7)

588

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

589

datetime.timedelta(0, 330)

590

485

"""

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

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:

609

500

raise ValueError

610

timevalue += delta

611

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

612

537

613

538

614

539

def server_state_changed(state):

615

540

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

616

541

if state == avahi.SERVER_COLLISION:

617

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

618

service.remove()

542

logger.warning(u"Server name collision")

543

remove_service()

619

544

elif state == avahi.SERVER_RUNNING:

620

service.add()

545

add_service()

621

546

622

547

623

548

def entry_group_state_changed(state, error):

624

549

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

625

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

550

global serviceName, server, rename_count

551

552

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

626

553

627

554

if state == avahi.ENTRY_GROUP_ESTABLISHED:

628

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

555

logger.debug(u"Service established.")

629

556

elif state == avahi.ENTRY_GROUP_COLLISION:

630

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

631

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)

632

570

elif state == avahi.ENTRY_GROUP_FAILURE:

633

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

634

unicode(error))

635

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

571

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

572

unicode(error))

573

killme(1)

574

636

575

637

576

def if_nametoindex(interface):

638

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

639

global if_nametoindex

577

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

640

578

try:

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

579

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

580

return libc.if_nametoindex(interface)

645

581

except (OSError, AttributeError):

646

582

if "struct" not in sys.modules:

647

583

import struct

648

584

if "fcntl" not in sys.modules:

649

585

import fcntl

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

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

663

596

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

664

597

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

665

598

if os.fork():

667

600

os.setsid()

668

601

if not nochdir:

669

602

os.chdir("/")

670

if os.fork():

671

sys.exit()

672

603

if not noclose:

673

604

# Close all standard open file descriptors

674

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

605

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

675

606

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

676

607

raise OSError(errno.ENODEV,

677

608

"/dev/null not a character device")

682

613

os.close(null)

683

614

684

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

685

625

def main():

626

global exitstatus

627

exitstatus = 0

686

628

global main_loop_started

687

629

main_loop_started = False

688

630

689

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

631

parser = OptionParser()

690

632

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

691

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

692

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,

693

636

help="Address to listen for requests on")

694

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

637

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

695

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

696

645

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

697

646

help="Run self-test")

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

647

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

648

help="Debug mode")

709

649

(options, args) = parser.parse_args()

710

650

711

651

if options.check:

713

653

doctest.testmod()

714

654

sys.exit()

715

655

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

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

810

671

811

672

global main_loop

812

673

global bus

815

676

DBusGMainLoop(set_as_default=True )

816

677

main_loop = gobject.MainLoop()

817

678

bus = dbus.SystemBus()

818

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

819

avahi.DBUS_PATH_SERVER),

820

avahi.DBUS_INTERFACE_SERVER)

679

server = dbus.Interface(

680

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

681

avahi.DBUS_INTERFACE_SERVER )

821

682

# End of Avahi example code

822

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

823

695

def remove_from_clients(client):

824

696

clients.remove(client)

825

697

if not clients:

826

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

827

sys.exit()

698

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

699

killme()

828

700

829

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

701

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

830

702

stop_hook = remove_from_clients,

831

config

832

= dict(client_config.items(section)))

703

**(dict(client_config\

704

.items(section))))

833

705

for section in client_config.sections()))

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

706

707

if not debug:

708

daemon(False, False)

862

709

863

710

def cleanup():

864

711

"Cleanup function; run on exit"

878

725

879

726

if not debug:

880

727

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

881

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

882

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

883

730

884

731

for client in clients:

885

732

client.start()

886

733

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

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

913

762

main_loop_started = True

914

763

main_loop.run()

915

except AvahiError, error:

916

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

917

sys.exit(1)

918

764

except KeyboardInterrupt:

919

765

if debug:

920

766

print

767

768

sys.exit(exitstatus)

921

769

922

770

if __name__ == '__main__':

923

771

main()