/mandos/trunk : revision 94

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

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 <https://www.fukt.bsnet.se/~belorn/> and

30

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

29

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

31

30

#

32

31

33

32

from __future__ import division

62

61

from dbus.mainloop.glib import DBusGMainLoop

63

62

import ctypes

64

63

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

64

version = "1.0"

76

65

77

66

logger = logging.Logger('mandos')

78

67

syslogger = logging.handlers.SysLogHandler\

79

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

68

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

69

address = "/dev/log")

80

70

syslogger.setFormatter(logging.Formatter\

81

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

71

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

82

72

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

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

89

163

# 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

164

group = None # our entry group

99

165

# End of Avahi example code

100

166

101

167

106

172

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

107

173

uniquely identify the client

108

174

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

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

114

180

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

115

181

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

116

182

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

117

183

to see if the client lives.

118

Is None if no process is running.

184

'None' if no process is running.

119

185

checker_initiator_tag: a gobject event source tag, or None

120

186

stop_initiator_tag: - '' -

121

187

checker_callback_tag: - '' -

122

188

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

123

client lives. %()s expansions are done at

189

client lives. %() expansions are done at

124

190

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

125

191

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

126

192

Private attibutes:

127

193

_timeout: Real variable for 'timeout'

128

194

_interval: Real variable for 'interval'

129

_timeout_milliseconds: Used by gobject.timeout_add()

195

_timeout_milliseconds: Used when calling gobject.timeout_add()

130

196

_interval_milliseconds: - '' -

131

197

"""

132

198

def _set_timeout(self, timeout):

152

218

interval = property(lambda self: self._interval,

153

219

_set_interval)

154

220

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

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

160

225

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)

226

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

232

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

169

237

self.secret = sf.read()

170

238

sf.close()

171

239

else:

172

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

173

% self.name)

174

self.fqdn = fqdn # string

240

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

241

% self.name)

242

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

175

243

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)

244

self.last_checked_ok = None

245

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

246

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

185

247

self.stop_hook = stop_hook

186

248

self.checker = None

187

249

self.checker_initiator_tag = None

188

250

self.stop_initiator_tag = None

189

251

self.checker_callback_tag = None

190

self.check_command = checker

252

self.check_command = config["checker"]

191

253

def start(self):

192

254

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

193

255

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

203

265

self.stop)

204

266

def stop(self):

205

267

"""Stop this client.

206

The possibility that this client might be restarted is left

207

open, but not currently used."""

268

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

269

but not currently used."""

208

270

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

271

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

272

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

211

273

self.secret = None

212

274

else:

213

275

return False

214

if hasattr(self, "stop_initiator_tag") \

215

and self.stop_initiator_tag:

276

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

216

277

gobject.source_remove(self.stop_initiator_tag)

217

278

self.stop_initiator_tag = None

218

if hasattr(self, "checker_initiator_tag") \

219

and self.checker_initiator_tag:

279

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

220

280

gobject.source_remove(self.checker_initiator_tag)

221

281

self.checker_initiator_tag = None

222

282

self.stop_checker()

234

294

self.checker = None

235

295

if os.WIFEXITED(condition) \

236

296

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

237

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

238

vars(self))

239

self.last_seen = now

297

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

298

vars(self))

299

self.last_checked_ok = now

240

300

gobject.source_remove(self.stop_initiator_tag)

241

301

self.stop_initiator_tag = gobject.timeout_add\

242

302

(self._timeout_milliseconds,

245

305

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

246

306

vars(self))

247

307

else:

248

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

249

vars(self))

308

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

309

vars(self))

250

310

def start_checker(self):

251

311

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

252

312

If a checker already exists, leave it running and do

261

321

# is as it should be.

262

322

if self.checker is None:

263

323

try:

264

command = self.check_command % self.fqdn

324

# In case check_command has exactly one % operator

325

command = self.check_command % self.host

265

326

except TypeError:

327

# Escape attributes for the shell

266

328

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

267

329

for key, val in

268

330

vars(self).iteritems())

269

331

try:

270

332

command = self.check_command % escaped_attrs

271

333

except TypeError, error:

272

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

273

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

334

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

335

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

274

336

return True # Try again later

275

337

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

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

282

347

self.checker_callback_tag = gobject.child_watch_add\

283

348

(self.checker.pid,

284

349

self.checker_callback)

285

except subprocess.OSError, error:

350

except OSError, error:

286

351

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

287

352

error)

288

353

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

292

357

if self.checker_callback_tag:

293

358

gobject.source_remove(self.checker_callback_tag)

294

359

self.checker_callback_tag = None

295

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

360

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

296

361

return

297

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

362

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

298

363

try:

299

364

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

300

365

#os.sleep(0.5)

301

366

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

302

367

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

303

368

except OSError, error:

304

if error.errno != errno.ESRCH:

369

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

305

370

raise

306

371

self.checker = None

307

def still_valid(self, now=None):

372

def still_valid(self):

308

373

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

374

now = datetime.datetime.now()

375

if self.last_checked_ok is None:

312

376

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

313

377

else:

314

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

378

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

315

379

316

380

317

381

def peer_certificate(session):

333

397

334

398

def fingerprint(openpgp):

335

399

"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

400

# New GnuTLS "datum" with the OpenPGP public key

341

401

datum = gnutls.library.types.gnutls_datum_t\

342

402

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

343

403

ctypes.POINTER(ctypes.c_ubyte)),

344

404

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

345

409

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

410

gnutls.library.functions.gnutls_openpgp_crt_import\

411

(crt, ctypes.byref(datum),

412

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

350

413

# New buffer for the fingerprint

351

414

buffer = ctypes.create_string_buffer(20)

352

415

buffer_length = ctypes.c_size_t()

368

431

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

369

432

370

433

def handle(self):

371

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

434

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

372

435

unicode(self.client_address))

373

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

374

gnutls.connection.\

375

X509Credentials())

436

session = gnutls.connection.ClientSession\

437

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

438

439

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

440

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

441

try:

442

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

443

raise RuntimeError

444

except (ValueError, IndexError, RuntimeError), error:

445

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

446

return

447

448

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

449

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

450

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

451

# using OpenPGP certificates.

376

452

377

453

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

378

454

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

379

455

# "+DHE-DSS"))

380

priority = "SECURE256"

381

456

priority = "NORMAL" # Fallback default, since this

457

# MUST be set.

458

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

459

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

382

460

gnutls.library.functions.gnutls_priority_set_direct\

383

461

(session._c_object, priority, None);

384

462

385

463

try:

386

464

session.handshake()

387

465

except gnutls.errors.GNUTLSError, error:

388

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

466

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

389

467

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

390

468

# established. Just abandon the request.

391

469

return

392

470

try:

393

471

fpr = fingerprint(peer_certificate(session))

394

472

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

395

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

473

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

396

474

session.bye()

397

475

return

398

476

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

401

479

if c.fingerprint == fpr:

402

480

client = c

403

481

break

482

if not client:

483

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

484

fpr)

485

session.bye()

486

return

404

487

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

405

488

# that the client timed out while establishing the GnuTLS

406

489

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

490

if not client.still_valid():

491

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

492

vars(client))

414

493

session.bye()

415

494

return

416

495

sent_size = 0

426

505

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

427

506

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

428

507

Attributes:

429

options: Command line options

508

settings: Server settings

430

509

clients: Set() of Client objects

431

510

"""

432

511

address_family = socket.AF_INET6

433

512

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

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

513

if "settings" in kwargs:

514

self.settings = kwargs["settings"]

515

del kwargs["settings"]

437

516

if "clients" in kwargs:

438

517

self.clients = kwargs["clients"]

439

518

del kwargs["clients"]

442

521

"""This overrides the normal server_bind() function

443

522

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

444

523

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

524

if self.settings["interface"]:

525

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

526

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

449

527

try:

450

528

self.socket.setsockopt(socket.SOL_SOCKET,

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

529

SO_BINDTODEVICE,

530

self.settings["interface"])

453

531

except socket.error, error:

454

532

if error[0] == errno.EPERM:

455

logger.warning(u"No permission to"

456

u" bind to interface %s",

457

self.options.interface)

533

logger.error(u"No permission to"

534

u" bind to interface %s",

535

self.settings["interface"])

458

536

else:

459

537

raise error

460

538

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

463

541

in6addr_any = "::"

464

542

self.server_address = (in6addr_any,

465

543

self.server_address[1])

466

elif self.server_address[1] is None:

544

elif not self.server_address[1]:

467

545

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

468

546

0)

547

# if self.settings["interface"]:

548

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

549

# 0, # port

550

# 0, # flowinfo

551

# if_nametoindex

552

# (self.settings

553

# ["interface"]))

469

554

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

470

555

471

556

482

567

datetime.timedelta(1)

483

568

>>> string_to_delta(u'1w')

484

569

datetime.timedelta(7)

570

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

571

datetime.timedelta(0, 330)

485

572

"""

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:

573

timevalue = datetime.timedelta(0)

574

for s in interval.split():

575

try:

576

suffix=unicode(s[-1])

577

value=int(s[:-1])

578

if suffix == u"d":

579

delta = datetime.timedelta(value)

580

elif suffix == u"s":

581

delta = datetime.timedelta(0, value)

582

elif suffix == u"m":

583

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

584

elif suffix == u"h":

585

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

586

elif suffix == u"w":

587

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

588

else:

589

raise ValueError

590

except (ValueError, IndexError):

500

591

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

592

timevalue += delta

593

return timevalue

537

594

538

595

539

596

def server_state_changed(state):

540

597

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

541

598

if state == avahi.SERVER_COLLISION:

542

logger.warning(u"Server name collision")

543

remove_service()

599

logger.error(u"Server name collision")

600

service.remove()

544

601

elif state == avahi.SERVER_RUNNING:

545

add_service()

602

service.add()

546

603

547

604

548

605

def entry_group_state_changed(state, error):

549

606

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

550

global serviceName, server, rename_count

551

552

607

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

553

608

554

609

if state == avahi.ENTRY_GROUP_ESTABLISHED:

555

610

logger.debug(u"Service established.")

556

611

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)

612

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

613

service.rename()

570

614

elif state == avahi.ENTRY_GROUP_FAILURE:

571

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

572

unicode(error))

573

killme(1)

574

615

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

616

unicode(error))

617

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

575

618

576

619

def if_nametoindex(interface):

577

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

620

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

621

global if_nametoindex

578

622

try:

579

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

580

return libc.if_nametoindex(interface)

623

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

624

import ctypes.util

625

if_nametoindex = ctypes.cdll.LoadLibrary\

626

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

581

627

except (OSError, AttributeError):

582

628

if "struct" not in sys.modules:

583

629

import struct

584

630

if "fcntl" not in sys.modules:

585

631

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

632

def if_nametoindex(interface):

633

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

634

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

635

s = socket.socket()

636

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

637

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

638

s.close()

639

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

640

return interface_index

641

return if_nametoindex(interface)

642

643

644

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

596

645

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

597

646

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

598

647

if os.fork():

600

649

os.setsid()

601

650

if not nochdir:

602

651

os.chdir("/")

652

if os.fork():

653

sys.exit()

603

654

if not noclose:

604

655

# Close all standard open file descriptors

605

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

656

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

606

657

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

607

658

raise OSError(errno.ENODEV,

608

659

"/dev/null not a character device")

613

664

os.close(null)

614

665

615

666

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

667

def main():

626

global exitstatus

627

exitstatus = 0

628

668

global main_loop_started

629

669

main_loop_started = False

630

670

631

parser = OptionParser()

671

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

632

672

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,

673

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

674

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

636

675

help="Address to listen for requests on")

637

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

676

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

638

677

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

678

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

646

679

help="Run self-test")

647

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

648

help="Debug mode")

680

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

681

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

682

" terminal")

683

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

684

" priority string (see GnuTLS documentation)")

685

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

686

help="Zeroconf service name")

687

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

688

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

689

help="Directory to search for configuration"

690

" files")

649

691

(options, args) = parser.parse_args()

650

692

651

693

if options.check:

653

695

doctest.testmod()

654

696

sys.exit()

655

697

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

698

# Default values for config file for server-global settings

699

server_defaults = { "interface": "",

700

"address": "",

701

"port": "",

702

"debug": "False",

703

"priority":

704

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

705

"servicename": "Mandos",

706

}

707

708

# Parse config file for server-global settings

709

server_config = ConfigParser.SafeConfigParser(server_defaults)

710

del server_defaults

711

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

712

# Convert the SafeConfigParser object to a dict

713

server_settings = server_config.defaults()

714

# Use getboolean on the boolean config option

715

server_settings["debug"] = server_config.getboolean\

716

("DEFAULT", "debug")

717

del server_config

718

719

# Override the settings from the config file with command line

720

# options, if set.

721

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

722

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

723

value = getattr(options, option)

724

if value is not None:

725

server_settings[option] = value

726

del options

727

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

728

729

debug = server_settings["debug"]

730

731

if not debug:

732

syslogger.setLevel(logging.WARNING)

733

console.setLevel(logging.WARNING)

734

735

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

736

syslogger.setFormatter(logging.Formatter\

737

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

738

' %%(message)s'

739

% server_settings["servicename"]))

740

741

# Parse config file with clients

742

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

743

"interval": "5m",

744

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

745

"host": "",

746

}

747

client_config = ConfigParser.SafeConfigParser(client_defaults)

748

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

749

"clients.conf"))

750

751

global service

752

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

753

type = "_mandos._tcp", );

754

if server_settings["interface"]:

755

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

671

756

672

757

global main_loop

673

758

global bus

681

766

avahi.DBUS_INTERFACE_SERVER )

682

767

# End of Avahi example code

683

768

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

769

clients = Set()

695

770

def remove_from_clients(client):

696

771

clients.remove(client)

697

772

if not clients:

698

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

699

killme()

773

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

774

sys.exit()

700

775

701

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

776

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

702

777

stop_hook = remove_from_clients,

703

**(dict(client_config\

704

.items(section))))

778

config

779

= dict(client_config.items(section)))

705

780

for section in client_config.sections()))

706

707

if not debug:

708

daemon(False, False)

781

if not clients:

782

logger.critical(u"No clients defined")

783

sys.exit(1)

784

785

if debug:

786

# Redirect stdin so all checkers get /dev/null

787

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

788

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

789

if null > 2:

790

os.close(null)

791

else:

792

# No console logging

793

logger.removeHandler(console)

794

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

795

daemon()

796

797

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

798

pid = os.getpid()

799

try:

800

pidfile = open(pidfilename, "w")

801

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

802

pidfile.close()

803

del pidfile

804

except IOError, err:

805

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

806

pidfilename, os.getpid())

709

807

710

808

def cleanup():

711

809

"Cleanup function; run on exit"

725

823

726

824

if not debug:

727

825

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

826

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

827

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

730

828

731

829

for client in clients:

732

830

client.start()

733

831

734

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

832

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

833

server_settings["port"]),

735

834

tcp_handler,

736

options=options,

835

settings=server_settings,

737

836

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

837

# Find out what port we got

838

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

839

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

840

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

841

842

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

843

844

try:

845

# From the Avahi example code

846

server.connect_to_signal("StateChanged", server_state_changed)

847

try:

848

server_state_changed(server.GetState())

849

except dbus.exceptions.DBusException, error:

850

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

851

sys.exit(1)

852

# End of Avahi example code

853

854

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

855

lambda *args, **kwargs:

856

tcp_server.handle_request\

857

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

858

859

logger.debug(u"Starting main loop")

762

860

main_loop_started = True

763

861

main_loop.run()

862

except AvahiError, error:

863

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

864

sys.exit(1)

764

865

except KeyboardInterrupt:

765

866

if debug:

766

867

print

767

768

sys.exit(exitstatus)

769

868

770

869

if __name__ == '__main__':

771

870

main()