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

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

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

226

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

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

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

166

232

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

167

if secret:

168

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

169

elif secfile:

170

sf = open(secfile)

233

if "secret" in config:

234

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

235

elif "secfile" in config:

236

sf = open(config["secfile"])

171

237

self.secret = sf.read()

172

238

sf.close()

173

239

else:

174

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

175

% self.name)

176

self.fqdn = fqdn # string

240

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

241

% self.name)

242

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

177

243

self.created = datetime.datetime.now()

178

self.last_seen = None

179

self.timeout = string_to_delta(timeout)

180

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

181

247

self.stop_hook = stop_hook

182

248

self.checker = None

183

249

self.checker_initiator_tag = None

184

250

self.stop_initiator_tag = None

185

251

self.checker_callback_tag = None

186

self.check_command = checker

252

self.check_command = config["checker"]

187

253

def start(self):

188

254

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

189

255

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

199

265

self.stop)

200

266

def stop(self):

201

267

"""Stop this client.

202

The possibility that this client might be restarted is left

203

open, but not currently used."""

268

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

269

but not currently used."""

204

270

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

205

if self.secret:

206

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)

207

273

self.secret = None

208

274

else:

209

275

return False

210

if hasattr(self, "stop_initiator_tag") \

211

and self.stop_initiator_tag:

276

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

212

277

gobject.source_remove(self.stop_initiator_tag)

213

278

self.stop_initiator_tag = None

214

if hasattr(self, "checker_initiator_tag") \

215

and self.checker_initiator_tag:

279

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

216

280

gobject.source_remove(self.checker_initiator_tag)

217

281

self.checker_initiator_tag = None

218

282

self.stop_checker()

230

294

self.checker = None

231

295

if os.WIFEXITED(condition) \

232

296

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

233

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

234

vars(self))

235

self.last_seen = now

297

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

298

vars(self))

299

self.last_checked_ok = now

236

300

gobject.source_remove(self.stop_initiator_tag)

237

301

self.stop_initiator_tag = gobject.timeout_add\

238

302

(self._timeout_milliseconds,

241

305

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

242

306

vars(self))

243

307

else:

244

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

245

vars(self))

308

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

309

vars(self))

246

310

def start_checker(self):

247

311

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

248

312

If a checker already exists, leave it running and do

257

321

# is as it should be.

258

322

if self.checker is None:

259

323

try:

260

command = self.check_command % self.fqdn

324

# In case check_command has exactly one % operator

325

command = self.check_command % self.host

261

326

except TypeError:

327

# Escape attributes for the shell

262

328

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

263

329

for key, val in

264

330

vars(self).iteritems())

265

331

try:

266

332

command = self.check_command % escaped_attrs

267

333

except TypeError, error:

268

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

269

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

334

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

335

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

270

336

return True # Try again later

271

337

try:

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

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

278

347

self.checker_callback_tag = gobject.child_watch_add\

279

348

(self.checker.pid,

280

349

self.checker_callback)

281

except subprocess.OSError, error:

350

except OSError, error:

282

351

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

283

352

error)

284

353

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

288

357

if self.checker_callback_tag:

289

358

gobject.source_remove(self.checker_callback_tag)

290

359

self.checker_callback_tag = None

291

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

360

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

292

361

return

293

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

362

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

294

363

try:

295

364

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

296

365

#os.sleep(0.5)

297

366

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

298

367

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

299

368

except OSError, error:

300

if error.errno != errno.ESRCH:

369

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

301

370

raise

302

371

self.checker = None

303

def still_valid(self, now=None):

372

def still_valid(self):

304

373

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

305

if now is None:

306

now = datetime.datetime.now()

307

if self.last_seen is None:

374

now = datetime.datetime.now()

375

if self.last_checked_ok is None:

308

376

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

309

377

else:

310

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

378

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

311

379

312

380

313

381

def peer_certificate(session):

329

397

330

398

def fingerprint(openpgp):

331

399

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

336

400

# New GnuTLS "datum" with the OpenPGP public key

337

401

datum = gnutls.library.types.gnutls_datum_t\

338

402

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

339

403

ctypes.POINTER(ctypes.c_ubyte)),

340

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

341

409

# Import the OpenPGP public key into the certificate

342

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

343

(crt,

344

ctypes.byref(datum),

345

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)

346

413

# New buffer for the fingerprint

347

414

buffer = ctypes.create_string_buffer(20)

348

415

buffer_length = ctypes.c_size_t()

364

431

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

365

432

366

433

def handle(self):

367

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

434

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

368

435

unicode(self.client_address))

369

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

370

gnutls.connection.\

371

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.

372

452

373

453

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

374

454

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

375

455

# "+DHE-DSS"))

376

priority = "NORMAL"

377

if self.server.options.priority:

378

priority = self.server.options.priority

456

priority = "NORMAL" # Fallback default, since this

457

# MUST be set.

458

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

459

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

379

460

gnutls.library.functions.gnutls_priority_set_direct\

380

461

(session._c_object, priority, None);

381

462

382

463

try:

383

464

session.handshake()

384

465

except gnutls.errors.GNUTLSError, error:

385

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

466

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

386

467

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

387

468

# established. Just abandon the request.

388

469

return

389

470

try:

390

471

fpr = fingerprint(peer_certificate(session))

391

472

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

392

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

473

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

393

474

session.bye()

394

475

return

395

476

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

398

479

if c.fingerprint == fpr:

399

480

client = c

400

481

break

482

if not client:

483

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

484

fpr)

485

session.bye()

486

return

401

487

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

402

488

# that the client timed out while establishing the GnuTLS

403

489

# session.

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)

490

if not client.still_valid():

491

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

492

vars(client))

411

493

session.bye()

412

494

return

413

495

sent_size = 0

423

505

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

424

506

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

425

507

Attributes:

426

options: Command line options

508

settings: Server settings

427

509

clients: Set() of Client objects

428

510

"""

429

511

address_family = socket.AF_INET6

430

512

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

431

if "options" in kwargs:

432

self.options = kwargs["options"]

433

del kwargs["options"]

513

if "settings" in kwargs:

514

self.settings = kwargs["settings"]

515

del kwargs["settings"]

434

516

if "clients" in kwargs:

435

517

self.clients = kwargs["clients"]

436

518

del kwargs["clients"]

439

521

"""This overrides the normal server_bind() function

440

522

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

441

523

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

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

524

if self.settings["interface"]:

525

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

526

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

446

527

try:

447

528

self.socket.setsockopt(socket.SOL_SOCKET,

448

socket.SO_BINDTODEVICE,

449

self.options.interface)

529

SO_BINDTODEVICE,

530

self.settings["interface"])

450

531

except socket.error, error:

451

532

if error[0] == errno.EPERM:

452

logger.warning(u"No permission to"

453

u" bind to interface %s",

454

self.options.interface)

533

logger.error(u"No permission to"

534

u" bind to interface %s",

535

self.settings["interface"])

455

536

else:

456

537

raise error

457

538

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

460

541

in6addr_any = "::"

461

542

self.server_address = (in6addr_any,

462

543

self.server_address[1])

463

elif self.server_address[1] is None:

544

elif not self.server_address[1]:

464

545

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

465

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

466

554

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

467

555

468

556

479

567

datetime.timedelta(1)

480

568

>>> string_to_delta(u'1w')

481

569

datetime.timedelta(7)

570

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

571

datetime.timedelta(0, 330)

482

572

"""

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:

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

497

591

raise ValueError

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

592

timevalue += delta

593

return timevalue

534

594

535

595

536

596

def server_state_changed(state):

537

597

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

538

598

if state == avahi.SERVER_COLLISION:

539

logger.warning(u"Server name collision")

540

remove_service()

599

logger.error(u"Server name collision")

600

service.remove()

541

601

elif state == avahi.SERVER_RUNNING:

542

add_service()

602

service.add()

543

603

544

604

545

605

def entry_group_state_changed(state, error):

546

606

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

547

global serviceName, server, rename_count

548

549

607

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

550

608

551

609

if state == avahi.ENTRY_GROUP_ESTABLISHED:

552

610

logger.debug(u"Service established.")

553

611

elif state == avahi.ENTRY_GROUP_COLLISION:

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)

612

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

613

service.rename()

567

614

elif state == avahi.ENTRY_GROUP_FAILURE:

568

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

569

unicode(error))

570

killme(1)

571

615

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

616

unicode(error))

617

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

572

618

573

619

def if_nametoindex(interface):

574

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

620

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

621

global if_nametoindex

575

622

try:

576

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

577

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

578

627

except (OSError, AttributeError):

579

628

if "struct" not in sys.modules:

580

629

import struct

581

630

if "fcntl" not in sys.modules:

582

631

import fcntl

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

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

593

645

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

594

646

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

595

647

if os.fork():

597

649

os.setsid()

598

650

if not nochdir:

599

651

os.chdir("/")

652

if os.fork():

653

sys.exit()

600

654

if not noclose:

601

655

# Close all standard open file descriptors

602

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

656

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

603

657

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

604

658

raise OSError(errno.ENODEV,

605

659

"/dev/null not a character device")

610

664

os.close(null)

611

665

612

666

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

622

667

def main():

623

global exitstatus

624

exitstatus = 0

625

668

global main_loop_started

626

669

main_loop_started = False

627

670

628

parser = OptionParser()

671

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

629

672

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

630

default=None, metavar="IF",

631

help="Bind to interface IF")

632

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

633

675

help="Address to listen for requests on")

634

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

676

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

635

677

help="Port number to receive requests on")

636

678

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

637

679

help="Run self-test")

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

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

646

691

(options, args) = parser.parse_args()

647

692

648

693

if options.check:

650

695

doctest.testmod()

651

696

sys.exit()

652

697

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;

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

664

756

665

757

global main_loop

666

758

global bus

674

766

avahi.DBUS_INTERFACE_SERVER )

675

767

# End of Avahi example code

676

768

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

687

769

clients = Set()

688

770

def remove_from_clients(client):

689

771

clients.remove(client)

690

772

if not clients:

691

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

692

killme()

773

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

774

sys.exit()

693

775

694

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

776

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

695

777

stop_hook = remove_from_clients,

696

**(dict(client_config\

697

.items(section))))

778

config

779

= dict(client_config.items(section)))

698

780

for section in client_config.sections()))

699

700

if not debug:

701

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

702

807

703

808

def cleanup():

704

809

"Cleanup function; run on exit"

718

823

719

824

if not debug:

720

825

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

721

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

722

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

723

828

724

829

for client in clients:

725

830

client.start()

726

831

727

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

832

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

833

server_settings["port"]),

728

834

tcp_handler,

729

options=options,

835

settings=server_settings,

730

836

clients=clients)

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

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

755

860

main_loop_started = True

756

861

main_loop.run()

862

except AvahiError, error:

863

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

864

sys.exit(1)

757

865

except KeyboardInterrupt:

758

866

if debug:

759

867

print

760

761

sys.exit(exitstatus)

762

868

763

869

if __name__ == '__main__':

764

870

main()