/mandos/trunk : revision 126

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

62

from dbus.mainloop.glib import DBusGMainLoop

63

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

65

version = "1.0"

76

66

77

67

logger = logging.Logger('mandos')

78

68

syslogger = logging.handlers.SysLogHandler\

79

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

69

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

70

address = "/dev/log")

80

71

syslogger.setFormatter(logging.Formatter\

81

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

72

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

82

73

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

74

75

console = logging.StreamHandler()

76

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

77

' %(message)s'))

78

logger.addHandler(console)

79

80

class AvahiError(Exception):

81

def __init__(self, value):

82

self.value = value

83

def __str__(self):

84

return repr(self.value)

85

86

class AvahiServiceError(AvahiError):

87

pass

88

89

class AvahiGroupError(AvahiError):

90

pass

91

92

93

class AvahiService(object):

94

"""An Avahi (Zeroconf) service.

95

Attributes:

96

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

97

Used to optionally bind to the specified interface.

98

name: string; Example: 'Mandos'

99

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

100

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

101

port: integer; what port to announce

102

TXT: list of strings; TXT record for the service

103

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

104

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

105

max_renames: integer; maximum number of renames

106

rename_count: integer; counter so we only rename after collisions

107

a sensible number of times

108

"""

109

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

110

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

111

host = "", max_renames = 32768):

112

self.interface = interface

113

self.name = name

114

self.type = type

115

self.port = port

116

if TXT is None:

117

self.TXT = []

118

else:

119

self.TXT = TXT

120

self.domain = domain

121

self.host = host

122

self.rename_count = 0

123

self.max_renames = max_renames

124

def rename(self):

125

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

126

if self.rename_count >= self.max_renames:

127

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

128

u" after %i retries, exiting.",

129

rename_count)

130

raise AvahiServiceError("Too many renames")

131

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

132

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

133

str(self.name))

134

syslogger.setFormatter(logging.Formatter\

135

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

136

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

137

self.remove()

138

self.add()

139

self.rename_count += 1

140

def remove(self):

141

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

142

if group is not None:

143

group.Reset()

144

def add(self):

145

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

146

global group

147

if group is None:

148

group = dbus.Interface\

149

(bus.get_object(avahi.DBUS_NAME,

150

server.EntryGroupNew()),

151

avahi.DBUS_INTERFACE_ENTRY_GROUP)

152

group.connect_to_signal('StateChanged',

153

entry_group_state_changed)

154

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

155

service.name, service.type)

156

group.AddService(

157

self.interface, # interface

158

avahi.PROTO_INET6, # protocol

159

dbus.UInt32(0), # flags

160

self.name, self.type,

161

self.domain, self.host,

162

dbus.UInt16(self.port),

163

avahi.string_array_to_txt_array(self.TXT))

164

group.Commit()

165

89

166

# 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

167

group = None # our entry group

99

168

# End of Avahi example code

100

169

101

170

106

175

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

107

176

uniquely identify the client

108

177

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

178

host: string; available for use by the checker command

179

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

180

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

181

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

182

until this client is invalid

114

183

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

115

184

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

116

185

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

117

186

to see if the client lives.

118

Is None if no process is running.

187

'None' if no process is running.

119

188

checker_initiator_tag: a gobject event source tag, or None

120

189

stop_initiator_tag: - '' -

121

190

checker_callback_tag: - '' -

122

191

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

123

client lives. %()s expansions are done at

192

client lives. %() expansions are done at

124

193

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

125

194

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

126

195

Private attibutes:

127

196

_timeout: Real variable for 'timeout'

128

197

_interval: Real variable for 'interval'

129

_timeout_milliseconds: Used by gobject.timeout_add()

198

_timeout_milliseconds: Used when calling gobject.timeout_add()

130

199

_interval_milliseconds: - '' -

131

200

"""

132

201

def _set_timeout(self, timeout):

152

221

interval = property(lambda self: self._interval,

153

222

_set_interval)

154

223

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

224

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

225

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

226

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

227

attribute."""

160

228

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)

229

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

230

# Uppercase and remove spaces from fingerprint for later

231

# comparison purposes with return value from the fingerprint()

232

# function

233

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

234

.replace(u" ", u"")

235

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

236

if "secret" in config:

237

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

238

elif "secfile" in config:

239

sf = open(config["secfile"])

169

240

self.secret = sf.read()

170

241

sf.close()

171

242

else:

172

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

173

% self.name)

174

self.fqdn = fqdn # string

243

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

244

% self.name)

245

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

175

246

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)

247

self.last_checked_ok = None

248

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

249

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

185

250

self.stop_hook = stop_hook

186

251

self.checker = None

187

252

self.checker_initiator_tag = None

188

253

self.stop_initiator_tag = None

189

254

self.checker_callback_tag = None

190

self.check_command = checker

255

self.check_command = config["checker"]

191

256

def start(self):

192

257

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

193

258

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

203

268

self.stop)

204

269

def stop(self):

205

270

"""Stop this client.

206

The possibility that this client might be restarted is left

207

open, but not currently used."""

271

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

272

but not currently used."""

208

273

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

274

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

275

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

211

276

self.secret = None

212

277

else:

213

278

return False

214

if hasattr(self, "stop_initiator_tag") \

215

and self.stop_initiator_tag:

279

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

216

280

gobject.source_remove(self.stop_initiator_tag)

217

281

self.stop_initiator_tag = None

218

if hasattr(self, "checker_initiator_tag") \

219

and self.checker_initiator_tag:

282

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

220

283

gobject.source_remove(self.checker_initiator_tag)

221

284

self.checker_initiator_tag = None

222

285

self.stop_checker()

234

297

self.checker = None

235

298

if os.WIFEXITED(condition) \

236

299

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

237

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

238

vars(self))

239

self.last_seen = now

300

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

301

vars(self))

302

self.last_checked_ok = now

240

303

gobject.source_remove(self.stop_initiator_tag)

241

304

self.stop_initiator_tag = gobject.timeout_add\

242

305

(self._timeout_milliseconds,

245

308

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

246

309

vars(self))

247

310

else:

248

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

249

vars(self))

311

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

312

vars(self))

250

313

def start_checker(self):

251

314

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

252

315

If a checker already exists, leave it running and do

261

324

# is as it should be.

262

325

if self.checker is None:

263

326

try:

264

command = self.check_command % self.fqdn

327

# In case check_command has exactly one % operator

328

command = self.check_command % self.host

265

329

except TypeError:

330

# Escape attributes for the shell

266

331

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

267

332

for key, val in

268

333

vars(self).iteritems())

269

334

try:

270

335

command = self.check_command % escaped_attrs

271

336

except TypeError, error:

272

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

273

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

337

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

338

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

274

339

return True # Try again later

275

340

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

341

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

342

command, self.name)

343

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

344

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

345

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

346

# always replaced by /dev/null.)

347

self.checker = subprocess.Popen(command,

348

close_fds=True,

349

shell=True, cwd="/")

282

350

self.checker_callback_tag = gobject.child_watch_add\

283

351

(self.checker.pid,

284

352

self.checker_callback)

285

except subprocess.OSError, error:

353

except OSError, error:

286

354

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

287

355

error)

288

356

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

292

360

if self.checker_callback_tag:

293

361

gobject.source_remove(self.checker_callback_tag)

294

362

self.checker_callback_tag = None

295

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

363

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

296

364

return

297

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

365

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

298

366

try:

299

367

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

300

368

#os.sleep(0.5)

301

369

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

302

370

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

303

371

except OSError, error:

304

if error.errno != errno.ESRCH:

372

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

305

373

raise

306

374

self.checker = None

307

def still_valid(self, now=None):

375

def still_valid(self):

308

376

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

377

now = datetime.datetime.now()

378

if self.last_checked_ok is None:

312

379

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

313

380

else:

314

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

381

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

315

382

316

383

317

384

def peer_certificate(session):

333

400

334

401

def fingerprint(openpgp):

335

402

"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

403

# New GnuTLS "datum" with the OpenPGP public key

341

404

datum = gnutls.library.types.gnutls_datum_t\

342

405

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

343

406

ctypes.POINTER(ctypes.c_ubyte)),

344

407

ctypes.c_uint(len(openpgp)))

408

# New empty GnuTLS certificate

409

crt = gnutls.library.types.gnutls_openpgp_crt_t()

410

gnutls.library.functions.gnutls_openpgp_crt_init\

411

(ctypes.byref(crt))

345

412

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

413

gnutls.library.functions.gnutls_openpgp_crt_import\

414

(crt, ctypes.byref(datum),

415

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

416

# Verify the self signature in the key

417

crtverify = ctypes.c_uint();

418

gnutls.library.functions.gnutls_openpgp_crt_verify_self\

419

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

420

if crtverify.value != 0:

421

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

422

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

350

423

# New buffer for the fingerprint

351

424

buffer = ctypes.create_string_buffer(20)

352

425

buffer_length = ctypes.c_size_t()

368

441

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

369

442

370

443

def handle(self):

371

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

444

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

372

445

unicode(self.client_address))

373

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

374

gnutls.connection.\

375

X509Credentials())

446

session = gnutls.connection.ClientSession\

447

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

448

449

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

450

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

451

try:

452

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

453

raise RuntimeError

454

except (ValueError, IndexError, RuntimeError), error:

455

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

456

return

457

458

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

459

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

460

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

461

# using OpenPGP certificates.

376

462

377

463

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

378

464

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

379

465

# "+DHE-DSS"))

380

priority = "SECURE256"

381

466

priority = "NORMAL" # Fallback default, since this

467

# MUST be set.

468

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

469

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

382

470

gnutls.library.functions.gnutls_priority_set_direct\

383

471

(session._c_object, priority, None);

384

472

385

473

try:

386

474

session.handshake()

387

475

except gnutls.errors.GNUTLSError, error:

388

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

476

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

389

477

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

390

478

# established. Just abandon the request.

391

479

return

392

480

try:

393

481

fpr = fingerprint(peer_certificate(session))

394

482

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

395

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

483

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

396

484

session.bye()

397

485

return

398

486

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

401

489

if c.fingerprint == fpr:

402

490

client = c

403

491

break

492

if not client:

493

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

494

fpr)

495

session.bye()

496

return

404

497

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

405

498

# that the client timed out while establishing the GnuTLS

406

499

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

500

if not client.still_valid():

501

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

502

vars(client))

414

503

session.bye()

415

504

return

416

505

sent_size = 0

426

515

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

427

516

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

428

517

Attributes:

429

options: Command line options

518

settings: Server settings

430

519

clients: Set() of Client objects

431

520

"""

432

521

address_family = socket.AF_INET6

433

522

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

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

523

if "settings" in kwargs:

524

self.settings = kwargs["settings"]

525

del kwargs["settings"]

437

526

if "clients" in kwargs:

438

527

self.clients = kwargs["clients"]

439

528

del kwargs["clients"]

442

531

"""This overrides the normal server_bind() function

443

532

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

444

533

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

534

if self.settings["interface"]:

535

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

536

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

449

537

try:

450

538

self.socket.setsockopt(socket.SOL_SOCKET,

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

539

SO_BINDTODEVICE,

540

self.settings["interface"])

453

541

except socket.error, error:

454

542

if error[0] == errno.EPERM:

455

logger.warning(u"No permission to"

456

u" bind to interface %s",

457

self.options.interface)

543

logger.error(u"No permission to"

544

u" bind to interface %s",

545

self.settings["interface"])

458

546

else:

459

547

raise error

460

548

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

463

551

in6addr_any = "::"

464

552

self.server_address = (in6addr_any,

465

553

self.server_address[1])

466

elif self.server_address[1] is None:

554

elif not self.server_address[1]:

467

555

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

468

556

0)

557

# if self.settings["interface"]:

558

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

559

# 0, # port

560

# 0, # flowinfo

561

# if_nametoindex

562

# (self.settings

563

# ["interface"]))

469

564

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

470

565

471

566

482

577

datetime.timedelta(1)

483

578

>>> string_to_delta(u'1w')

484

579

datetime.timedelta(7)

580

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

581

datetime.timedelta(0, 330)

485

582

"""

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:

583

timevalue = datetime.timedelta(0)

584

for s in interval.split():

585

try:

586

suffix=unicode(s[-1])

587

value=int(s[:-1])

588

if suffix == u"d":

589

delta = datetime.timedelta(value)

590

elif suffix == u"s":

591

delta = datetime.timedelta(0, value)

592

elif suffix == u"m":

593

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

594

elif suffix == u"h":

595

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

596

elif suffix == u"w":

597

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

598

else:

599

raise ValueError

600

except (ValueError, IndexError):

500

601

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

602

timevalue += delta

603

return timevalue

537

604

538

605

539

606

def server_state_changed(state):

540

607

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

541

608

if state == avahi.SERVER_COLLISION:

542

logger.warning(u"Server name collision")

543

remove_service()

609

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

610

service.remove()

544

611

elif state == avahi.SERVER_RUNNING:

545

add_service()

612

service.add()

546

613

547

614

548

615

def entry_group_state_changed(state, error):

549

616

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

550

global serviceName, server, rename_count

551

552

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

617

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

553

618

554

619

if state == avahi.ENTRY_GROUP_ESTABLISHED:

555

logger.debug(u"Service established.")

620

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

556

621

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)

622

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

623

service.rename()

570

624

elif state == avahi.ENTRY_GROUP_FAILURE:

571

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

572

unicode(error))

573

killme(1)

574

625

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

626

unicode(error))

627

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

575

628

576

629

def if_nametoindex(interface):

577

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

630

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

631

global if_nametoindex

578

632

try:

579

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

580

return libc.if_nametoindex(interface)

633

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

634

import ctypes.util

635

if_nametoindex = ctypes.cdll.LoadLibrary\

636

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

581

637

except (OSError, AttributeError):

582

638

if "struct" not in sys.modules:

583

639

import struct

584

640

if "fcntl" not in sys.modules:

585

641

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

642

def if_nametoindex(interface):

643

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

644

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

645

s = socket.socket()

646

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

647

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

648

s.close()

649

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

650

return interface_index

651

return if_nametoindex(interface)

652

653

654

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

596

655

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

597

656

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

598

657

if os.fork():

600

659

os.setsid()

601

660

if not nochdir:

602

661

os.chdir("/")

662

if os.fork():

663

sys.exit()

603

664

if not noclose:

604

665

# Close all standard open file descriptors

605

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

666

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

606

667

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

607

668

raise OSError(errno.ENODEV,

608

669

"/dev/null not a character device")

613

674

os.close(null)

614

675

615

676

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

677

def main():

626

global exitstatus

627

exitstatus = 0

628

678

global main_loop_started

629

679

main_loop_started = False

630

680

631

parser = OptionParser()

681

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

632

682

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,

683

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

684

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

636

685

help="Address to listen for requests on")

637

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

686

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

638

687

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

688

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

646

689

help="Run self-test")

647

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

648

help="Debug mode")

690

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

691

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

692

" terminal")

693

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

694

" priority string (see GnuTLS documentation)")

695

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

696

help="Zeroconf service name")

697

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

698

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

699

help="Directory to search for configuration"

700

" files")

649

701

(options, args) = parser.parse_args()

650

702

651

703

if options.check:

653

705

doctest.testmod()

654

706

sys.exit()

655

707

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

708

# Default values for config file for server-global settings

709

server_defaults = { "interface": "",

710

"address": "",

711

"port": "",

712

"debug": "False",

713

"priority":

714

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

715

"servicename": "Mandos",

716

}

717

718

# Parse config file for server-global settings

719

server_config = ConfigParser.SafeConfigParser(server_defaults)

720

del server_defaults

721

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

722

# Convert the SafeConfigParser object to a dict

723

server_settings = server_config.defaults()

724

# Use getboolean on the boolean config option

725

server_settings["debug"] = server_config.getboolean\

726

("DEFAULT", "debug")

727

del server_config

728

729

# Override the settings from the config file with command line

730

# options, if set.

731

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

732

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

733

value = getattr(options, option)

734

if value is not None:

735

server_settings[option] = value

736

del options

737

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

738

739

debug = server_settings["debug"]

740

741

if not debug:

742

syslogger.setLevel(logging.WARNING)

743

console.setLevel(logging.WARNING)

744

745

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

746

syslogger.setFormatter(logging.Formatter\

747

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

748

' %%(message)s'

749

% server_settings["servicename"]))

750

751

# Parse config file with clients

752

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

753

"interval": "5m",

754

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

755

"host": "",

756

}

757

client_config = ConfigParser.SafeConfigParser(client_defaults)

758

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

759

"clients.conf"))

760

761

global service

762

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

763

type = "_mandos._tcp", );

764

if server_settings["interface"]:

765

service.interface = if_nametoindex\

766

(server_settings["interface"])

671

767

672

768

global main_loop

673

769

global bus

676

772

DBusGMainLoop(set_as_default=True )

677

773

main_loop = gobject.MainLoop()

678

774

bus = dbus.SystemBus()

679

server = dbus.Interface(

680

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

681

avahi.DBUS_INTERFACE_SERVER )

775

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

776

avahi.DBUS_PATH_SERVER),

777

avahi.DBUS_INTERFACE_SERVER)

682

778

# End of Avahi example code

683

779

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

780

clients = Set()

695

781

def remove_from_clients(client):

696

782

clients.remove(client)

697

783

if not clients:

698

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

699

killme()

784

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

785

sys.exit()

700

786

701

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

787

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

702

788

stop_hook = remove_from_clients,

703

**(dict(client_config\

704

.items(section))))

789

config

790

= dict(client_config.items(section)))

705

791

for section in client_config.sections()))

706

707

if not debug:

708

daemon(False, False)

792

if not clients:

793

logger.critical(u"No clients defined")

794

sys.exit(1)

795

796

if debug:

797

# Redirect stdin so all checkers get /dev/null

798

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

799

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

800

if null > 2:

801

os.close(null)

802

else:

803

# No console logging

804

logger.removeHandler(console)

805

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

806

daemon()

807

808

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

809

pid = os.getpid()

810

try:

811

pidfile = open(pidfilename, "w")

812

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

813

pidfile.close()

814

del pidfile

815

except IOError, err:

816

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

817

pidfilename, os.getpid())

709

818

710

819

def cleanup():

711

820

"Cleanup function; run on exit"

725

834

726

835

if not debug:

727

836

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

837

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

838

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

730

839

731

840

for client in clients:

732

841

client.start()

733

842

734

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

843

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

844

server_settings["port"]),

735

845

tcp_handler,

736

options=options,

846

settings=server_settings,

737

847

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

848

# Find out what port we got

849

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

850

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

851

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

852

853

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

854

855

try:

856

# From the Avahi example code

857

server.connect_to_signal("StateChanged", server_state_changed)

858

try:

859

server_state_changed(server.GetState())

860

except dbus.exceptions.DBusException, error:

861

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

862

sys.exit(1)

863

# End of Avahi example code

864

865

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

866

lambda *args, **kwargs:

867

tcp_server.handle_request\

868

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

869

870

logger.debug(u"Starting main loop")

762

871

main_loop_started = True

763

872

main_loop.run()

873

except AvahiError, error:

874

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

875

sys.exit(1)

764

876

except KeyboardInterrupt:

765

877

if debug:

766

878

print

767

768

sys.exit(exitstatus)

769

879

770

880

if __name__ == '__main__':

771

881

main()