/mandos/release : 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

uid = 65534

776

gid = 65534

777

try:

778

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

779

except KeyError:

780

try:

781

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

782

except KeyError:

783

pass

784

try:

785

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

786

except KeyError:

787

try:

788

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

789

except KeyError:

790

pass

791

try:

792

os.setuid(uid)

793

os.setgid(gid)

794

except OSError, error:

795

if error[0] != errno.EPERM:

796

raise error

797

798

global service

799

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

800

type = "_mandos._tcp", );

801

if server_settings["interface"]:

802

service.interface = if_nametoindex\

803

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

804

671

805

672

global main_loop

806

673

global bus

809

676

DBusGMainLoop(set_as_default=True )

810

677

main_loop = gobject.MainLoop()

811

678

bus = dbus.SystemBus()

812

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

813

avahi.DBUS_PATH_SERVER),

814

avahi.DBUS_INTERFACE_SERVER)

679

server = dbus.Interface(

680

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

681

avahi.DBUS_INTERFACE_SERVER )

815

682

# End of Avahi example code

816

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

817

695

def remove_from_clients(client):

818

696

clients.remove(client)

819

697

if not clients:

820

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

821

sys.exit()

698

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

699

killme()

822

700

823

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

701

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

824

702

stop_hook = remove_from_clients,

825

config

826

= dict(client_config.items(section)))

703

**(dict(client_config\

704

.items(section))))

827

705

for section in client_config.sections()))

828

if not clients:

829

logger.critical(u"No clients defined")

830

sys.exit(1)

831

832

if debug:

833

# Redirect stdin so all checkers get /dev/null

834

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

835

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

836

if null > 2:

837

os.close(null)

838

else:

839

# No console logging

840

logger.removeHandler(console)

841

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

842

daemon()

843

844

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

845

pid = os.getpid()

846

try:

847

pidfile = open(pidfilename, "w")

848

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

849

pidfile.close()

850

del pidfile

851

except IOError, err:

852

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

853

pidfilename, os.getpid())

706

707

if not debug:

708

daemon(False, False)

854

709

855

710

def cleanup():

856

711

"Cleanup function; run on exit"

870

725

871

726

if not debug:

872

727

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

873

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

874

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

875

730

876

731

for client in clients:

877

732

client.start()

878

733

879

tcp_server.enable()

880

tcp_server.server_activate()

881

882

# Find out what port we got

883

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

884

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

885

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

886

887

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

888

889

try:

890

# From the Avahi example code

891

server.connect_to_signal("StateChanged", server_state_changed)

892

try:

893

server_state_changed(server.GetState())

894

except dbus.exceptions.DBusException, error:

895

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

896

sys.exit(1)

897

# End of Avahi example code

898

899

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

900

lambda *args, **kwargs:

901

tcp_server.handle_request\

902

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

903

904

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

905

762

main_loop_started = True

906

763

main_loop.run()

907

except AvahiError, error:

908

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

909

sys.exit(1)

910

764

except KeyboardInterrupt:

911

765

if debug:

912

766

print

767

768

sys.exit(exitstatus)

913

769

914

770

if __name__ == '__main__':

915

771

main()