/mandos/trunk : revision 25

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

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

28

#

29

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

30

31

#

31

32

33

from __future__ import division

61

62

from dbus.mainloop.glib import DBusGMainLoop

62

63

import ctypes

63

64

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

65

76

66

77

logger = logging.Logger('mandos')

67

78

syslogger = logging.handlers.SysLogHandler\

68

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

69

address = "/dev/log")

79

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

70

80

syslogger.setFormatter(logging.Formatter\

71

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

81

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

72

82

logger.addHandler(syslogger)

73

74

console = logging.StreamHandler()

75

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

76

' %(message)s'))

77

logger.addHandler(console)

78

79

class AvahiError(Exception):

80

def __init__(self, value):

81

self.value = value

82

def __str__(self):

83

return repr(self.value)

84

85

class AvahiServiceError(AvahiError):

86

pass

87

88

class AvahiGroupError(AvahiError):

89

pass

90

91

92

class AvahiService(object):

93

"""An Avahi (Zeroconf) service.

94

Attributes:

95

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

96

Used to optionally bind to the specified interface.

97

name: string; Example: 'Mandos'

98

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

99

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

100

port: integer; what port to announce

101

TXT: list of strings; TXT record for the service

102

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

103

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

104

max_renames: integer; maximum number of renames

105

rename_count: integer; counter so we only rename after collisions

106

a sensible number of times

107

"""

108

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

109

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

110

host = "", max_renames = 32768):

111

self.interface = interface

112

self.name = name

113

self.type = type

114

self.port = port

115

if TXT is None:

116

self.TXT = []

117

else:

118

self.TXT = TXT

119

self.domain = domain

120

self.host = host

121

self.rename_count = 0

122

self.max_renames = max_renames

123

def rename(self):

124

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

125

if self.rename_count >= self.max_renames:

126

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

127

u" retries, exiting.", rename_count)

128

raise AvahiServiceError("Too many renames")

129

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

130

logger.info(u"Changing name to %r ...", str(self.name))

131

syslogger.setFormatter(logging.Formatter\

132

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

133

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

134

self.remove()

135

self.add()

136

self.rename_count += 1

137

def remove(self):

138

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

139

if group is not None:

140

group.Reset()

141

def add(self):

142

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

143

global group

144

if group is None:

145

group = dbus.Interface\

146

(bus.get_object(avahi.DBUS_NAME,

147

server.EntryGroupNew()),

148

avahi.DBUS_INTERFACE_ENTRY_GROUP)

149

group.connect_to_signal('StateChanged',

150

entry_group_state_changed)

151

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

152

service.name, service.type)

153

group.AddService(

154

self.interface, # interface

155

avahi.PROTO_INET6, # protocol

156

dbus.UInt32(0), # flags

157

self.name, self.type,

158

self.domain, self.host,

159

dbus.UInt16(self.port),

160

avahi.string_array_to_txt_array(self.TXT))

161

group.Commit()

162

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

163

89

# From the Avahi example code:

164

group = None # our entry group

90

serviceName = None

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

165

99

# End of Avahi example code

166

100

167

101

172

106

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

173

107

uniquely identify the client

174

108

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

175

host: string; available for use by the checker command

176

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

177

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

178

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

179

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

180

114

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

181

115

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

182

116

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

183

117

to see if the client lives.

184

'None' if no process is running.

118

Is None if no process is running.

185

119

checker_initiator_tag: a gobject event source tag, or None

186

120

stop_initiator_tag: - '' -

187

121

checker_callback_tag: - '' -

188

122

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

189

client lives. %() expansions are done at

123

client lives. %()s expansions are done at

190

124

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

191

125

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

192

126

Private attibutes:

193

127

_timeout: Real variable for 'timeout'

194

128

_interval: Real variable for 'interval'

195

_timeout_milliseconds: Used when calling gobject.timeout_add()

129

_timeout_milliseconds: Used by gobject.timeout_add()

196

130

_interval_milliseconds: - '' -

197

131

"""

198

132

def _set_timeout(self, timeout):

218

152

interval = property(lambda self: self._interval,

219

153

_set_interval)

220

154

del _set_interval

221

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

222

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

223

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

224

attribute."""

155

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

156

secret=None, secfile=None, fqdn=None, timeout=None,

157

interval=-1, checker=None):

158

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

159

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

225

160

self.name = name

226

161

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

227

# Uppercase and remove spaces from fingerprint for later

228

# comparison purposes with return value from the fingerprint()

229

# function

230

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

231

.replace(u" ", u"")

162

# Uppercase and remove spaces from fingerprint

163

# for later comparison purposes with return value of

164

# the fingerprint() function

165

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

232

166

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

233

if "secret" in config:

234

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

235

elif "secfile" in config:

236

sf = open(config["secfile"])

167

if secret:

168

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

169

elif secfile:

170

sf = open(secfile)

237

171

self.secret = sf.read()

238

172

sf.close()

239

173

else:

240

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

241

% self.name)

242

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

174

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

175

% self.name)

176

self.fqdn = fqdn # string

243

177

self.created = datetime.datetime.now()

244

self.last_checked_ok = None

245

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

246

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

178

self.last_seen = None

179

self.timeout = string_to_delta(timeout)

180

self.interval = string_to_delta(interval)

247

181

self.stop_hook = stop_hook

248

182

self.checker = None

249

183

self.checker_initiator_tag = None

250

184

self.stop_initiator_tag = None

251

185

self.checker_callback_tag = None

252

self.check_command = config["checker"]

186

self.check_command = checker

253

187

def start(self):

254

188

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

255

189

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

265

199

self.stop)

266

200

def stop(self):

267

201

"""Stop this client.

268

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

269

but not currently used."""

202

The possibility that this client might be restarted is left

203

open, but not currently used."""

270

204

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

271

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

272

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

205

if self.secret:

206

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

273

207

self.secret = None

274

208

else:

275

209

return False

276

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

210

if hasattr(self, "stop_initiator_tag") \

211

and self.stop_initiator_tag:

277

212

gobject.source_remove(self.stop_initiator_tag)

278

213

self.stop_initiator_tag = None

279

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

214

if hasattr(self, "checker_initiator_tag") \

215

and self.checker_initiator_tag:

280

216

gobject.source_remove(self.checker_initiator_tag)

281

217

self.checker_initiator_tag = None

282

218

self.stop_checker()

294

230

self.checker = None

295

231

if os.WIFEXITED(condition) \

296

232

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

297

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

298

vars(self))

299

self.last_checked_ok = now

233

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

234

vars(self))

235

self.last_seen = now

300

236

gobject.source_remove(self.stop_initiator_tag)

301

237

self.stop_initiator_tag = gobject.timeout_add\

302

238

(self._timeout_milliseconds,

305

241

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

306

242

vars(self))

307

243

else:

308

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

309

vars(self))

244

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

245

vars(self))

310

246

def start_checker(self):

311

247

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

312

248

If a checker already exists, leave it running and do

321

257

# is as it should be.

322

258

if self.checker is None:

323

259

try:

324

# In case check_command has exactly one % operator

325

command = self.check_command % self.host

260

command = self.check_command % self.fqdn

326

261

except TypeError:

327

# Escape attributes for the shell

328

262

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

329

263

for key, val in

330

264

vars(self).iteritems())

331

265

try:

332

266

command = self.check_command % escaped_attrs

333

267

except TypeError, error:

334

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

335

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

268

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

269

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

336

270

return True # Try again later

337

271

try:

338

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

339

command, self.name)

340

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

341

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

342

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

343

# always replaced by /dev/null.)

344

self.checker = subprocess.Popen(command,

345

close_fds=True,

346

shell=True, cwd="/")

272

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

273

command, self.name)

274

self.checker = subprocess.\

275

Popen(command,

276

close_fds=True, shell=True,

277

cwd="/")

347

278

self.checker_callback_tag = gobject.child_watch_add\

348

279

(self.checker.pid,

349

280

self.checker_callback)

350

except OSError, error:

281

except subprocess.OSError, error:

351

282

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

352

283

error)

353

284

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

357

288

if self.checker_callback_tag:

358

289

gobject.source_remove(self.checker_callback_tag)

359

290

self.checker_callback_tag = None

360

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

291

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

361

292

return

362

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

293

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

363

294

try:

364

295

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

365

296

#os.sleep(0.5)

366

297

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

367

298

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

368

299

except OSError, error:

369

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

300

if error.errno != errno.ESRCH:

370

301

raise

371

302

self.checker = None

372

def still_valid(self):

303

def still_valid(self, now=None):

373

304

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

374

now = datetime.datetime.now()

375

if self.last_checked_ok is None:

305

if now is None:

306

now = datetime.datetime.now()

307

if self.last_seen is None:

376

308

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

377

309

else:

378

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

310

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

379

311

380

312

381

313

def peer_certificate(session):

397

329

398

330

def fingerprint(openpgp):

399

331

"Convert an OpenPGP bytestring to a hexdigit fingerprint string"

332

# New empty GnuTLS certificate

333

crt = gnutls.library.types.gnutls_openpgp_crt_t()

334

gnutls.library.functions.gnutls_openpgp_crt_init\

335

(ctypes.byref(crt))

400

336

# New GnuTLS "datum" with the OpenPGP public key

401

337

datum = gnutls.library.types.gnutls_datum_t\

402

338

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

403

339

ctypes.POINTER(ctypes.c_ubyte)),

404

340

ctypes.c_uint(len(openpgp)))

405

# New empty GnuTLS certificate

406

crt = gnutls.library.types.gnutls_openpgp_crt_t()

407

gnutls.library.functions.gnutls_openpgp_crt_init\

408

(ctypes.byref(crt))

409

341

# Import the OpenPGP public key into the certificate

410

gnutls.library.functions.gnutls_openpgp_crt_import\

411

(crt, ctypes.byref(datum),

412

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

413

# Verify the self signature in the key

414

crtverify = ctypes.c_uint();

415

gnutls.library.functions.gnutls_openpgp_crt_verify_self\

416

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

417

if crtverify.value != 0:

418

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

419

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

342

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

343

(crt,

344

ctypes.byref(datum),

345

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

420

346

# New buffer for the fingerprint

421

347

buffer = ctypes.create_string_buffer(20)

422

348

buffer_length = ctypes.c_size_t()

438

364

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

439

365

440

366

def handle(self):

441

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

367

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

442

368

unicode(self.client_address))

443

session = gnutls.connection.ClientSession\

444

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

445

446

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

447

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

448

try:

449

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

450

raise RuntimeError

451

except (ValueError, IndexError, RuntimeError), error:

452

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

453

return

454

455

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

456

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

457

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

458

# using OpenPGP certificates.

369

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

370

gnutls.connection.\

371

X509Credentials())

459

372

460

373

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

461

374

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

462

375

# "+DHE-DSS"))

463

priority = "NORMAL" # Fallback default, since this

464

# MUST be set.

465

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

466

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

376

priority = "NORMAL"

377

if self.server.options.priority:

378

priority = self.server.options.priority

467

379

gnutls.library.functions.gnutls_priority_set_direct\

468

380

(session._c_object, priority, None);

469

381

470

382

try:

471

383

session.handshake()

472

384

except gnutls.errors.GNUTLSError, error:

473

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

385

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

474

386

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

475

387

# established. Just abandon the request.

476

388

return

477

389

try:

478

390

fpr = fingerprint(peer_certificate(session))

479

391

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

480

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

392

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

481

393

session.bye()

482

394

return

483

395

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

486

398

if c.fingerprint == fpr:

487

399

client = c

488

400

break

489

if not client:

490

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

491

fpr)

492

session.bye()

493

return

494

401

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

495

402

# that the client timed out while establishing the GnuTLS

496

403

# session.

497

if not client.still_valid():

498

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

499

vars(client))

404

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

405

if client:

406

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

407

vars(client))

408

else:

409

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

410

fpr)

500

411

session.bye()

501

412

return

502

413

sent_size = 0

512

423

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

513

424

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

514

425

Attributes:

515

settings: Server settings

426

options: Command line options

516

427

clients: Set() of Client objects

517

428

"""

518

429

address_family = socket.AF_INET6

519

430

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

520

if "settings" in kwargs:

521

self.settings = kwargs["settings"]

522

del kwargs["settings"]

431

if "options" in kwargs:

432

self.options = kwargs["options"]

433

del kwargs["options"]

523

434

if "clients" in kwargs:

524

435

self.clients = kwargs["clients"]

525

436

del kwargs["clients"]

528

439

"""This overrides the normal server_bind() function

529

440

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

530

441

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

531

if self.settings["interface"]:

532

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

533

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

442

if self.options.interface:

443

if not hasattr(socket, "SO_BINDTODEVICE"):

444

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

445

socket.SO_BINDTODEVICE = 25

534

446

try:

535

447

self.socket.setsockopt(socket.SOL_SOCKET,

536

SO_BINDTODEVICE,

537

self.settings["interface"])

448

socket.SO_BINDTODEVICE,

449

self.options.interface)

538

450

except socket.error, error:

539

451

if error[0] == errno.EPERM:

540

logger.error(u"No permission to"

541

u" bind to interface %s",

542

self.settings["interface"])

452

logger.warning(u"No permission to"

453

u" bind to interface %s",

454

self.options.interface)

543

455

else:

544

456

raise error

545

457

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

548

460

in6addr_any = "::"

549

461

self.server_address = (in6addr_any,

550

462

self.server_address[1])

551

elif not self.server_address[1]:

463

elif self.server_address[1] is None:

552

464

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

553

465

0)

554

# if self.settings["interface"]:

555

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

556

# 0, # port

557

# 0, # flowinfo

558

# if_nametoindex

559

# (self.settings

560

# ["interface"]))

561

466

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

562

467

563

468

574

479

datetime.timedelta(1)

575

480

>>> string_to_delta(u'1w')

576

481

datetime.timedelta(7)

577

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

578

datetime.timedelta(0, 330)

579

482

"""

580

timevalue = datetime.timedelta(0)

581

for s in interval.split():

582

try:

583

suffix=unicode(s[-1])

584

value=int(s[:-1])

585

if suffix == u"d":

586

delta = datetime.timedelta(value)

587

elif suffix == u"s":

588

delta = datetime.timedelta(0, value)

589

elif suffix == u"m":

590

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

591

elif suffix == u"h":

592

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

593

elif suffix == u"w":

594

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

595

else:

596

raise ValueError

597

except (ValueError, IndexError):

483

try:

484

suffix=unicode(interval[-1])

485

value=int(interval[:-1])

486

if suffix == u"d":

487

delta = datetime.timedelta(value)

488

elif suffix == u"s":

489

delta = datetime.timedelta(0, value)

490

elif suffix == u"m":

491

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

492

elif suffix == u"h":

493

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

494

elif suffix == u"w":

495

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

496

else:

598

497

raise ValueError

599

timevalue += delta

600

return timevalue

498

except (ValueError, IndexError):

499

raise ValueError

500

return delta

501

502

503

def add_service():

504

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

505

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

506

domain, host

507

if group is None:

508

group = dbus.Interface(

509

bus.get_object( avahi.DBUS_NAME,

510

server.EntryGroupNew()),

511

avahi.DBUS_INTERFACE_ENTRY_GROUP)

512

group.connect_to_signal('StateChanged',

513

entry_group_state_changed)

514

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

515

serviceName, serviceType)

516

517

group.AddService(

518

serviceInterface, # interface

519

avahi.PROTO_INET6, # protocol

520

dbus.UInt32(0), # flags

521

serviceName, serviceType,

522

domain, host,

523

dbus.UInt16(servicePort),

524

avahi.string_array_to_txt_array(serviceTXT))

525

group.Commit()

526

527

528

def remove_service():

529

"""From the Avahi example code"""

530

global group

531

532

if not group is None:

533

group.Reset()

601

534

602

535

603

536

def server_state_changed(state):

604

537

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

605

538

if state == avahi.SERVER_COLLISION:

606

logger.error(u"Server name collision")

607

service.remove()

539

logger.warning(u"Server name collision")

540

remove_service()

608

541

elif state == avahi.SERVER_RUNNING:

609

service.add()

542

add_service()

610

543

611

544

612

545

def entry_group_state_changed(state, error):

613

546

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

547

global serviceName, server, rename_count

548

614

549

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

615

550

616

551

if state == avahi.ENTRY_GROUP_ESTABLISHED:

617

552

logger.debug(u"Service established.")

618

553

elif state == avahi.ENTRY_GROUP_COLLISION:

619

logger.warning(u"Service name collision.")

620

service.rename()

554

555

rename_count = rename_count - 1

556

if rename_count > 0:

557

name = server.GetAlternativeServiceName(name)

558

logger.warning(u"Service name collision, "

559

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

560

remove_service()

561

add_service()

562

563

else:

564

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

565

u" retries, exiting.", n_rename)

566

killme(1)

621

567

elif state == avahi.ENTRY_GROUP_FAILURE:

622

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

623

unicode(error))

624

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

568

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

569

unicode(error))

570

killme(1)

571

625

572

626

573

def if_nametoindex(interface):

627

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

628

global if_nametoindex

574

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

629

575

try:

630

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

631

import ctypes.util

632

if_nametoindex = ctypes.cdll.LoadLibrary\

633

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

576

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

577

return libc.if_nametoindex(interface)

634

578

except (OSError, AttributeError):

635

579

if "struct" not in sys.modules:

636

580

import struct

637

581

if "fcntl" not in sys.modules:

638

582

import fcntl

639

def if_nametoindex(interface):

640

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

641

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

642

s = socket.socket()

643

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

644

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

645

s.close()

646

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

647

return interface_index

648

return if_nametoindex(interface)

649

650

651

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

583

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

584

s = socket.socket()

585

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

586

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

587

s.close()

588

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

589

return interface_index

590

591

592

def daemon(nochdir, noclose):

652

593

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

653

594

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

654

595

if os.fork():

656

597

os.setsid()

657

598

if not nochdir:

658

599

os.chdir("/")

659

if os.fork():

660

sys.exit()

661

600

if not noclose:

662

601

# Close all standard open file descriptors

663

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

602

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

664

603

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

665

604

raise OSError(errno.ENODEV,

666

605

"/dev/null not a character device")

671

610

os.close(null)

672

611

673

612

613

def killme(status = 0):

614

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

615

exitstatus = status

616

if main_loop_started:

617

main_loop.quit()

618

else:

619

sys.exit(status)

620

621

674

622

def main():

623

global exitstatus

624

exitstatus = 0

675

625

global main_loop_started

676

626

main_loop_started = False

677

627

678

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

628

parser = OptionParser()

679

629

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

680

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

681

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

630

default=None, metavar="IF",

631

help="Bind to interface IF")

632

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

682

633

help="Address to listen for requests on")

683

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

634

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

684

635

help="Port number to receive requests on")

685

636

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

686

637

help="Run self-test")

687

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

688

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

689

" terminal")

690

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

691

" priority string (see GnuTLS documentation)")

692

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

693

help="Zeroconf service name")

694

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

695

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

696

help="Directory to search for configuration"

697

" files")

638

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

639

help="Debug mode")

640

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

641

default="SECURE256",

642

help="GnuTLS priority string"

643

" (see GnuTLS documentation)")

644

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

645

default="Mandos", help="Zeroconf service name")

698

646

(options, args) = parser.parse_args()

699

647

700

648

if options.check:

702

650

doctest.testmod()

703

651

sys.exit()

704

652

705

# Default values for config file for server-global settings

706

server_defaults = { "interface": "",

707

"address": "",

708

"port": "",

709

"debug": "False",

710

"priority":

711

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

712

"servicename": "Mandos",

713

}

714

715

# Parse config file for server-global settings

716

server_config = ConfigParser.SafeConfigParser(server_defaults)

717

del server_defaults

718

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

719

# Convert the SafeConfigParser object to a dict

720

server_settings = server_config.defaults()

721

# Use getboolean on the boolean config option

722

server_settings["debug"] = server_config.getboolean\

723

("DEFAULT", "debug")

724

del server_config

725

726

# Override the settings from the config file with command line

727

# options, if set.

728

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

729

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

730

value = getattr(options, option)

731

if value is not None:

732

server_settings[option] = value

733

del options

734

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

735

736

debug = server_settings["debug"]

737

738

if not debug:

739

syslogger.setLevel(logging.WARNING)

740

console.setLevel(logging.WARNING)

741

742

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

743

syslogger.setFormatter(logging.Formatter\

744

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

745

' %%(message)s'

746

% server_settings["servicename"]))

747

748

# Parse config file with clients

749

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

750

"interval": "5m",

751

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

752

"host": "",

753

}

754

client_config = ConfigParser.SafeConfigParser(client_defaults)

755

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

756

"clients.conf"))

757

758

global service

759

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

760

type = "_mandos._tcp", );

761

if server_settings["interface"]:

762

service.interface = if_nametoindex(server_settings["interface"])

653

# Parse config file

654

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

655

"interval": "5m",

656

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

657

}

658

client_config = ConfigParser.SafeConfigParser(defaults)

659

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

660

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

661

662

global serviceName

663

serviceName = options.servicename;

763

664

764

665

global main_loop

765

666

global bus

773

674

avahi.DBUS_INTERFACE_SERVER )

774

675

# End of Avahi example code

775

676

677

debug = options.debug

678

679

if debug:

680

console = logging.StreamHandler()

681

# console.setLevel(logging.DEBUG)

682

console.setFormatter(logging.Formatter\

683

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

684

logger.addHandler(console)

685

del console

686

776

687

clients = Set()

777

688

def remove_from_clients(client):

778

689

clients.remove(client)

779

690

if not clients:

780

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

781

sys.exit()

691

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

692

killme()

782

693

783

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

694

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

784

695

stop_hook = remove_from_clients,

785

config

786

= dict(client_config.items(section)))

696

**(dict(client_config\

697

.items(section))))

787

698

for section in client_config.sections()))

788

if not clients:

789

logger.critical(u"No clients defined")

790

sys.exit(1)

791

792

if debug:

793

# Redirect stdin so all checkers get /dev/null

794

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

795

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

796

if null > 2:

797

os.close(null)

798

else:

799

# No console logging

800

logger.removeHandler(console)

801

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

802

daemon()

803

804

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

805

pid = os.getpid()

806

try:

807

pidfile = open(pidfilename, "w")

808

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

809

pidfile.close()

810

del pidfile

811

except IOError, err:

812

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

813

pidfilename, os.getpid())

699

700

if not debug:

701

daemon(False, False)

814

702

815

703

def cleanup():

816

704

"Cleanup function; run on exit"

830

718

831

719

if not debug:

832

720

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

833

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

834

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

721

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

722

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

835

723

836

724

for client in clients:

837

725

client.start()

838

726

839

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

840

server_settings["port"]),

727

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

841

728

tcp_handler,

842

settings=server_settings,

729

options=options,

843

730

clients=clients)

844

# Find out what port we got

845

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

846

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

847

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

848

849

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

850

851

try:

852

# From the Avahi example code

853

server.connect_to_signal("StateChanged", server_state_changed)

854

try:

855

server_state_changed(server.GetState())

856

except dbus.exceptions.DBusException, error:

857

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

858

sys.exit(1)

859

# End of Avahi example code

860

861

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

862

lambda *args, **kwargs:

863

tcp_server.handle_request\

864

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

865

866

logger.debug(u"Starting main loop")

731

# Find out what random port we got

732

global servicePort

733

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

734

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

735

736

if options.interface is not None:

737

global serviceInterface

738

serviceInterface = if_nametoindex(options.interface)

739

740

# From the Avahi example code

741

server.connect_to_signal("StateChanged", server_state_changed)

742

try:

743

server_state_changed(server.GetState())

744

except dbus.exceptions.DBusException, error:

745

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

746

killme(1)

747

# End of Avahi example code

748

749

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

750

lambda *args, **kwargs:

751

tcp_server.handle_request(*args[2:],

752

**kwargs) or True)

753

try:

754

logger.debug("Starting main loop")

867

755

main_loop_started = True

868

756

main_loop.run()

869

except AvahiError, error:

870

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

871

sys.exit(1)

872

757

except KeyboardInterrupt:

873

758

if debug:

874

759

print

760

761

sys.exit(exitstatus)

875

762

876

763

if __name__ == '__main__':

877

764

main()