/mandos/trunk : revision 24.1.5

6

# This program is partly derived from an example program for an Avahi

7

# service publisher, downloaded from

8

# <http://avahi.org/wiki/PythonPublishExample>. This includes the

9

# methods "add" and "remove" in the "AvahiService" class, the

10

# "server_state_changed" and "entry_group_state_changed" functions,

11

# and some lines in "main".

9

# following functions: "add_service", "remove_service",

10

# "server_state_changed", "entry_group_state_changed", and some lines

11

# in "main".

12

#

13

# Everything else is

14

13

14

# Påhlsson.

15

#

16

# This program is free software: you can redistribute it and/or modify

17

# it under the terms of the GNU General Public License as published by

24

# GNU General Public License for more details.

25

#

26

# You should have received a copy of the GNU General Public License

27

# along with this program. If not, see

28

# <http://www.gnu.org/licenses/>.

27

# along with this program. If not, see <http://www.gnu.org/licenses/>.

29

28

#

30

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

29

# Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and

30

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

31

#

32

33

from __future__ import division

62

from dbus.mainloop.glib import DBusGMainLoop

63

import ctypes

64

65

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

66

76

67

77

logger = logging.Logger('mandos')

68

78

syslogger = logging.handlers.SysLogHandler\

69

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

70

address = "/dev/log")

79

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

71

80

syslogger.setFormatter(logging.Formatter\

72

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

81

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

73

82

logger.addHandler(syslogger)

74

75

console = logging.StreamHandler()

76

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

77

' %(message)s'))

78

logger.addHandler(console)

79

80

class AvahiError(Exception):

81

def __init__(self, value):

82

self.value = value

83

def __str__(self):

84

return repr(self.value)

85

86

class AvahiServiceError(AvahiError):

87

pass

88

89

class AvahiGroupError(AvahiError):

90

pass

91

92

93

class AvahiService(object):

94

"""An Avahi (Zeroconf) service.

95

Attributes:

96

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

97

Used to optionally bind to the specified interface.

98

name: string; Example: 'Mandos'

99

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

100

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

101

port: integer; what port to announce

102

TXT: list of strings; TXT record for the service

103

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

104

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

105

max_renames: integer; maximum number of renames

106

rename_count: integer; counter so we only rename after collisions

107

a sensible number of times

108

"""

109

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

110

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

111

host = "", max_renames = 32768):

112

self.interface = interface

113

self.name = name

114

self.type = type

115

self.port = port

116

if TXT is None:

117

self.TXT = []

118

else:

119

self.TXT = TXT

120

self.domain = domain

121

self.host = host

122

self.rename_count = 0

123

self.max_renames = max_renames

124

def rename(self):

125

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

126

if self.rename_count >= self.max_renames:

127

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

128

u" after %i retries, exiting.",

129

rename_count)

130

raise AvahiServiceError("Too many renames")

131

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

132

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

133

str(self.name))

134

syslogger.setFormatter(logging.Formatter\

135

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

136

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

137

self.remove()

138

self.add()

139

self.rename_count += 1

140

def remove(self):

141

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

142

if group is not None:

143

group.Reset()

144

def add(self):

145

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

146

global group

147

if group is None:

148

group = dbus.Interface\

149

(bus.get_object(avahi.DBUS_NAME,

150

server.EntryGroupNew()),

151

avahi.DBUS_INTERFACE_ENTRY_GROUP)

152

group.connect_to_signal('StateChanged',

153

entry_group_state_changed)

154

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

155

service.name, service.type)

156

group.AddService(

157

self.interface, # interface

158

avahi.PROTO_INET6, # protocol

159

dbus.UInt32(0), # flags

160

self.name, self.type,

161

self.domain, self.host,

162

dbus.UInt16(self.port),

163

avahi.string_array_to_txt_array(self.TXT))

164

group.Commit()

165

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

166

89

# From the Avahi example code:

167

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

168

99

# End of Avahi example code

169

100

170

101

175

106

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

176

107

uniquely identify the client

177

108

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

178

host: string; available for use by the checker command

179

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

180

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

181

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

182

until this client is invalid

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

183

114

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

184

115

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

185

116

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

186

117

to see if the client lives.

187

'None' if no process is running.

118

Is None if no process is running.

188

119

checker_initiator_tag: a gobject event source tag, or None

189

120

stop_initiator_tag: - '' -

190

121

checker_callback_tag: - '' -

191

122

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

192

client lives. %() expansions are done at

123

client lives. %()s expansions are done at

193

124

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

194

125

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

195

126

Private attibutes:

196

127

_timeout: Real variable for 'timeout'

197

128

_interval: Real variable for 'interval'

198

_timeout_milliseconds: Used when calling gobject.timeout_add()

129

_timeout_milliseconds: Used by gobject.timeout_add()

199

130

_interval_milliseconds: - '' -

200

131

"""

201

132

def _set_timeout(self, timeout):

221

152

interval = property(lambda self: self._interval,

222

153

_set_interval)

223

154

del _set_interval

224

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

225

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

226

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

227

attribute."""

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

228

160

self.name = name

229

161

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

230

# Uppercase and remove spaces from fingerprint for later

231

# comparison purposes with return value from the fingerprint()

232

# function

233

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

234

.replace(u" ", u"")

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

235

166

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

236

if "secret" in config:

237

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

238

elif "secfile" in config:

239

sf = open(config["secfile"])

167

if secret:

168

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

169

elif secfile:

170

sf = open(secfile)

240

171

self.secret = sf.read()

241

172

sf.close()

242

173

else:

243

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

244

% self.name)

245

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

174

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

175

% self.name)

176

self.fqdn = fqdn # string

246

177

self.created = datetime.datetime.now()

247

self.last_checked_ok = None

248

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

249

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)

250

181

self.stop_hook = stop_hook

251

182

self.checker = None

252

183

self.checker_initiator_tag = None

253

184

self.stop_initiator_tag = None

254

185

self.checker_callback_tag = None

255

self.check_command = config["checker"]

186

self.check_command = checker

256

187

def start(self):

257

188

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

258

189

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

268

199

self.stop)

269

200

def stop(self):

270

201

"""Stop this client.

271

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

272

but not currently used."""

202

The possibility that this client might be restarted is left

203

open, but not currently used."""

273

204

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

274

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

275

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

205

if self.secret:

206

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

276

207

self.secret = None

277

208

else:

278

209

return False

279

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

210

if hasattr(self, "stop_initiator_tag") \

211

and self.stop_initiator_tag:

280

212

gobject.source_remove(self.stop_initiator_tag)

281

213

self.stop_initiator_tag = None

282

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

214

if hasattr(self, "checker_initiator_tag") \

215

and self.checker_initiator_tag:

283

216

gobject.source_remove(self.checker_initiator_tag)

284

217

self.checker_initiator_tag = None

285

218

self.stop_checker()

297

230

self.checker = None

298

231

if os.WIFEXITED(condition) \

299

232

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

300

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

301

vars(self))

302

self.last_checked_ok = now

233

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

234

vars(self))

235

self.last_seen = now

303

236

gobject.source_remove(self.stop_initiator_tag)

304

237

self.stop_initiator_tag = gobject.timeout_add\

305

238

(self._timeout_milliseconds,

308

241

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

309

242

vars(self))

310

243

else:

311

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

312

vars(self))

244

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

245

vars(self))

313

246

def start_checker(self):

314

247

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

315

248

If a checker already exists, leave it running and do

324

257

# is as it should be.

325

258

if self.checker is None:

326

259

try:

327

# In case check_command has exactly one % operator

328

command = self.check_command % self.host

260

command = self.check_command % self.fqdn

329

261

except TypeError:

330

# Escape attributes for the shell

331

262

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

332

263

for key, val in

333

264

vars(self).iteritems())

334

265

try:

335

266

command = self.check_command % escaped_attrs

336

267

except TypeError, error:

337

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

338

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

268

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

269

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

339

270

return True # Try again later

340

271

try:

341

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

342

command, self.name)

343

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

344

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

345

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

346

# always replaced by /dev/null.)

347

self.checker = subprocess.Popen(command,

348

close_fds=True,

349

shell=True, cwd="/")

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

350

278

self.checker_callback_tag = gobject.child_watch_add\

351

279

(self.checker.pid,

352

280

self.checker_callback)

353

except OSError, error:

281

except subprocess.OSError, error:

354

282

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

355

283

error)

356

284

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

360

288

if self.checker_callback_tag:

361

289

gobject.source_remove(self.checker_callback_tag)

362

290

self.checker_callback_tag = None

363

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

291

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

364

292

return

365

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

293

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

366

294

try:

367

295

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

368

296

#os.sleep(0.5)

369

297

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

370

298

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

371

299

except OSError, error:

372

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

300

if error.errno != errno.ESRCH:

373

301

raise

374

302

self.checker = None

375

def still_valid(self):

303

def still_valid(self, now=None):

376

304

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

377

now = datetime.datetime.now()

378

if self.last_checked_ok is None:

305

if now is None:

306

now = datetime.datetime.now()

307

if self.last_seen is None:

379

308

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

380

309

else:

381

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

310

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

382

311

383

312

384

313

def peer_certificate(session):

400

329

401

330

def fingerprint(openpgp):

402

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

403

336

# New GnuTLS "datum" with the OpenPGP public key

404

337

datum = gnutls.library.types.gnutls_datum_t\

405

338

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

406

339

ctypes.POINTER(ctypes.c_ubyte)),

407

340

ctypes.c_uint(len(openpgp)))

408

# New empty GnuTLS certificate

409

crt = gnutls.library.types.gnutls_openpgp_crt_t()

410

gnutls.library.functions.gnutls_openpgp_crt_init\

411

(ctypes.byref(crt))

412

341

# Import the OpenPGP public key into the certificate

413

gnutls.library.functions.gnutls_openpgp_crt_import\

414

(crt, ctypes.byref(datum),

415

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

416

# Verify the self signature in the key

417

crtverify = ctypes.c_uint();

418

gnutls.library.functions.gnutls_openpgp_crt_verify_self\

419

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

420

if crtverify.value != 0:

421

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

422

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

342

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

343

(crt,

344

ctypes.byref(datum),

345

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

423

346

# New buffer for the fingerprint

424

347

buffer = ctypes.create_string_buffer(20)

425

348

buffer_length = ctypes.c_size_t()

441

364

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

442

365

443

366

def handle(self):

444

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

367

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

445

368

unicode(self.client_address))

446

session = gnutls.connection.ClientSession\

447

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

448

449

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

450

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

451

try:

452

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

453

raise RuntimeError

454

except (ValueError, IndexError, RuntimeError), error:

455

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

456

return

457

458

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

459

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

460

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

461

# using OpenPGP certificates.

369

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

370

gnutls.connection.\

371

X509Credentials())

462

372

463

373

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

464

374

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

465

375

# "+DHE-DSS"))

466

priority = "NORMAL" # Fallback default, since this

467

# MUST be set.

468

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

469

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

376

priority = "NORMAL"

377

if self.server.options.priority:

378

priority = self.server.options.priority

470

379

gnutls.library.functions.gnutls_priority_set_direct\

471

380

(session._c_object, priority, None);

472

381

473

382

try:

474

383

session.handshake()

475

384

except gnutls.errors.GNUTLSError, error:

476

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

385

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

477

386

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

478

387

# established. Just abandon the request.

479

388

return

480

389

try:

481

390

fpr = fingerprint(peer_certificate(session))

482

391

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

483

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

392

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

484

393

session.bye()

485

394

return

486

395

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

489

398

if c.fingerprint == fpr:

490

399

client = c

491

400

break

492

if not client:

493

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

494

fpr)

495

session.bye()

496

return

497

401

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

498

402

# that the client timed out while establishing the GnuTLS

499

403

# session.

500

if not client.still_valid():

501

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

502

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)

503

411

session.bye()

504

412

return

505

413

sent_size = 0

515

423

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

516

424

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

517

425

Attributes:

518

settings: Server settings

426

options: Command line options

519

427

clients: Set() of Client objects

520

428

"""

521

429

address_family = socket.AF_INET6

522

430

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

523

if "settings" in kwargs:

524

self.settings = kwargs["settings"]

525

del kwargs["settings"]

431

if "options" in kwargs:

432

self.options = kwargs["options"]

433

del kwargs["options"]

526

434

if "clients" in kwargs:

527

435

self.clients = kwargs["clients"]

528

436

del kwargs["clients"]

531

439

"""This overrides the normal server_bind() function

532

440

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

533

441

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

534

if self.settings["interface"]:

535

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

536

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

537

446

try:

538

447

self.socket.setsockopt(socket.SOL_SOCKET,

539

SO_BINDTODEVICE,

540

self.settings["interface"])

448

socket.SO_BINDTODEVICE,

449

self.options.interface)

541

450

except socket.error, error:

542

451

if error[0] == errno.EPERM:

543

logger.error(u"No permission to"

544

u" bind to interface %s",

545

self.settings["interface"])

452

logger.warning(u"No permission to"

453

u" bind to interface %s",

454

self.options.interface)

546

455

else:

547

456

raise error

548

457

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

551

460

in6addr_any = "::"

552

461

self.server_address = (in6addr_any,

553

462

self.server_address[1])

554

elif not self.server_address[1]:

463

elif self.server_address[1] is None:

555

464

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

556

465

0)

557

# if self.settings["interface"]:

558

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

559

# 0, # port

560

# 0, # flowinfo

561

# if_nametoindex

562

# (self.settings

563

# ["interface"]))

564

466

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

565

467

566

468

577

479

datetime.timedelta(1)

578

480

>>> string_to_delta(u'1w')

579

481

datetime.timedelta(7)

580

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

581

datetime.timedelta(0, 330)

582

482

"""

583

timevalue = datetime.timedelta(0)

584

for s in interval.split():

585

try:

586

suffix=unicode(s[-1])

587

value=int(s[:-1])

588

if suffix == u"d":

589

delta = datetime.timedelta(value)

590

elif suffix == u"s":

591

delta = datetime.timedelta(0, value)

592

elif suffix == u"m":

593

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

594

elif suffix == u"h":

595

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

596

elif suffix == u"w":

597

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

598

else:

599

raise ValueError

600

except (ValueError, IndexError):

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:

601

497

raise ValueError

602

timevalue += delta

603

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

604

534

605

535

606

536

def server_state_changed(state):

607

537

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

608

538

if state == avahi.SERVER_COLLISION:

609

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

610

service.remove()

539

logger.warning(u"Server name collision")

540

remove_service()

611

541

elif state == avahi.SERVER_RUNNING:

612

service.add()

542

add_service()

613

543

614

544

615

545

def entry_group_state_changed(state, error):

616

546

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

617

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

547

global serviceName, server, rename_count

548

549

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

618

550

619

551

if state == avahi.ENTRY_GROUP_ESTABLISHED:

620

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

552

logger.debug(u"Service established.")

621

553

elif state == avahi.ENTRY_GROUP_COLLISION:

622

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

623

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)

624

567

elif state == avahi.ENTRY_GROUP_FAILURE:

625

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

626

unicode(error))

627

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

568

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

569

unicode(error))

570

killme(1)

571

628

572

629

573

def if_nametoindex(interface):

630

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

631

global if_nametoindex

574

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

632

575

try:

633

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

634

import ctypes.util

635

if_nametoindex = ctypes.cdll.LoadLibrary\

636

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

576

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

577

return libc.if_nametoindex(interface)

637

578

except (OSError, AttributeError):

638

579

if "struct" not in sys.modules:

639

580

import struct

640

581

if "fcntl" not in sys.modules:

641

582

import fcntl

642

def if_nametoindex(interface):

643

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

644

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

645

s = socket.socket()

646

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

647

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

648

s.close()

649

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

650

return interface_index

651

return if_nametoindex(interface)

652

653

654

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

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

655

593

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

656

594

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

657

595

if os.fork():

659

597

os.setsid()

660

598

if not nochdir:

661

599

os.chdir("/")

662

if os.fork():

663

sys.exit()

664

600

if not noclose:

665

601

# Close all standard open file descriptors

666

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

602

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

667

603

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

668

604

raise OSError(errno.ENODEV,

669

605

"/dev/null not a character device")

674

610

os.close(null)

675

611

676

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

677

622

def main():

623

global exitstatus

624

exitstatus = 0

678

625

global main_loop_started

679

626

main_loop_started = False

680

627

681

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

628

parser = OptionParser()

682

629

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

683

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

684

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,

685

633

help="Address to listen for requests on")

686

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

634

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

687

635

help="Port number to receive requests on")

688

636

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

689

637

help="Run self-test")

690

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

691

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

692

" terminal")

693

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

694

" priority string (see GnuTLS documentation)")

695

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

696

help="Zeroconf service name")

697

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

698

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

699

help="Directory to search for configuration"

700

" files")

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

701

646

(options, args) = parser.parse_args()

702

647

703

648

if options.check:

705

650

doctest.testmod()

706

651

sys.exit()

707

652

708

# Default values for config file for server-global settings

709

server_defaults = { "interface": "",

710

"address": "",

711

"port": "",

712

"debug": "False",

713

"priority":

714

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

715

"servicename": "Mandos",

716

}

717

718

# Parse config file for server-global settings

719

server_config = ConfigParser.SafeConfigParser(server_defaults)

720

del server_defaults

721

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

722

# Convert the SafeConfigParser object to a dict

723

server_settings = server_config.defaults()

724

# Use getboolean on the boolean config option

725

server_settings["debug"] = server_config.getboolean\

726

("DEFAULT", "debug")

727

del server_config

728

729

# Override the settings from the config file with command line

730

# options, if set.

731

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

732

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

733

value = getattr(options, option)

734

if value is not None:

735

server_settings[option] = value

736

del options

737

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

738

739

debug = server_settings["debug"]

740

741

if not debug:

742

syslogger.setLevel(logging.WARNING)

743

console.setLevel(logging.WARNING)

744

745

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

746

syslogger.setFormatter(logging.Formatter\

747

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

748

' %%(message)s'

749

% server_settings["servicename"]))

750

751

# Parse config file with clients

752

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

753

"interval": "5m",

754

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

755

"host": "",

756

}

757

client_config = ConfigParser.SafeConfigParser(client_defaults)

758

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

759

"clients.conf"))

760

761

global service

762

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

763

type = "_mandos._tcp", );

764

if server_settings["interface"]:

765

service.interface = if_nametoindex\

766

(server_settings["interface"])

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;

767

664

768

665

global main_loop

769

666

global bus

772

669

DBusGMainLoop(set_as_default=True )

773

670

main_loop = gobject.MainLoop()

774

671

bus = dbus.SystemBus()

775

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

776

avahi.DBUS_PATH_SERVER),

777

avahi.DBUS_INTERFACE_SERVER)

672

server = dbus.Interface(

673

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

674

avahi.DBUS_INTERFACE_SERVER )

778

675

# End of Avahi example code

779

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

780

687

clients = Set()

781

688

def remove_from_clients(client):

782

689

clients.remove(client)

783

690

if not clients:

784

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

785

sys.exit()

691

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

692

killme()

786

693

787

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

694

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

788

695

stop_hook = remove_from_clients,

789

config

790

= dict(client_config.items(section)))

696

**(dict(client_config\

697

.items(section))))

791

698

for section in client_config.sections()))

792

if not clients:

793

logger.critical(u"No clients defined")

794

sys.exit(1)

795

796

if debug:

797

# Redirect stdin so all checkers get /dev/null

798

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

799

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

800

if null > 2:

801

os.close(null)

802

else:

803

# No console logging

804

logger.removeHandler(console)

805

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

806

daemon()

807

808

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

809

pid = os.getpid()

810

try:

811

pidfile = open(pidfilename, "w")

812

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

813

pidfile.close()

814

del pidfile

815

except IOError, err:

816

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

817

pidfilename, os.getpid())

699

700

if not debug:

701

daemon(False, False)

818

702

819

703

def cleanup():

820

704

"Cleanup function; run on exit"

834

718

835

719

if not debug:

836

720

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

837

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

838

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

839

723

840

724

for client in clients:

841

725

client.start()

842

726

843

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

844

server_settings["port"]),

727

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

845

728

tcp_handler,

846

settings=server_settings,

729

options=options,

847

730

clients=clients)

848

# Find out what port we got

849

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

850

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

851

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

852

853

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

854

855

try:

856

# From the Avahi example code

857

server.connect_to_signal("StateChanged", server_state_changed)

858

try:

859

server_state_changed(server.GetState())

860

except dbus.exceptions.DBusException, error:

861

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

862

sys.exit(1)

863

# End of Avahi example code

864

865

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

866

lambda *args, **kwargs:

867

tcp_server.handle_request\

868

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

869

870

logger.debug(u"Starting main loop")

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

871

755

main_loop_started = True

872

756

main_loop.run()

873

except AvahiError, error:

874

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

875

sys.exit(1)

876

757

except KeyboardInterrupt:

877

758

if debug:

878

759

print

760

761

sys.exit(exitstatus)

879

762

880

763

if __name__ == '__main__':

881

764

main()