/mandos/trunk : revision 15.1.3

6

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

7

# service publisher, downloaded from

8

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

9

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

10

# "server_state_changed" and "entry_group_state_changed" functions,

11

# and some lines in "main".

9

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

10

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

11

# in "main".

12

#

13

# Everything else is

14

13

14

# Påhlsson.

15

#

16

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

17

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

26

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

27

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

28

#

29

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

29

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

30

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

30

31

#

31

32

33

from __future__ import division

61

62

from dbus.mainloop.glib import DBusGMainLoop

62

63

import ctypes

63

64

version = "1.0"

65

# Brief description of the operation of this program:

66

#

67

# This server announces itself as a Zeroconf service. Connecting

68

# clients use the TLS protocol, with the unusual quirk that this

69

# server program acts as a TLS "client" while the connecting clients

70

# acts as a TLS "server". The clients (acting as a TLS "server") must

71

# supply an OpenPGP certificate, and the fingerprint of this

72

# certificate is used by this server to look up (in a list read from a

73

# file at start time) which binary blob to give the client. No other

74

# authentication or authorization is done by this server.

75

65

76

66

77

logger = logging.Logger('mandos')

67

78

syslogger = logging.handlers.SysLogHandler\

68

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

69

address = "/dev/log")

79

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

70

80

syslogger.setFormatter(logging.Formatter\

71

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

81

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

72

82

logger.addHandler(syslogger)

73

74

console = logging.StreamHandler()

75

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

76

' %(message)s'))

77

logger.addHandler(console)

78

79

class AvahiError(Exception):

80

def __init__(self, value):

81

self.value = value

82

def __str__(self):

83

return repr(self.value)

84

85

class AvahiServiceError(AvahiError):

86

pass

87

88

class AvahiGroupError(AvahiError):

89

pass

90

91

92

class AvahiService(object):

93

"""An Avahi (Zeroconf) service.

94

Attributes:

95

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

96

Used to optionally bind to the specified interface.

97

name: string; Example: 'Mandos'

98

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

99

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

100

port: integer; what port to announce

101

TXT: list of strings; TXT record for the service

102

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

103

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

104

max_renames: integer; maximum number of renames

105

rename_count: integer; counter so we only rename after collisions

106

a sensible number of times

107

"""

108

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

109

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

110

host = "", max_renames = 32768):

111

self.interface = interface

112

self.name = name

113

self.type = type

114

self.port = port

115

if TXT is None:

116

self.TXT = []

117

else:

118

self.TXT = TXT

119

self.domain = domain

120

self.host = host

121

self.rename_count = 0

122

self.max_renames = max_renames

123

def rename(self):

124

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

125

if self.rename_count >= self.max_renames:

126

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

127

u" retries, exiting.", rename_count)

128

raise AvahiServiceError("Too many renames")

129

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

130

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

131

syslogger.setFormatter(logging.Formatter\

132

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

133

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

134

self.remove()

135

self.add()

136

self.rename_count += 1

137

def remove(self):

138

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

139

if group is not None:

140

group.Reset()

141

def add(self):

142

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

143

global group

144

if group is None:

145

group = dbus.Interface\

146

(bus.get_object(avahi.DBUS_NAME,

147

server.EntryGroupNew()),

148

avahi.DBUS_INTERFACE_ENTRY_GROUP)

149

group.connect_to_signal('StateChanged',

150

entry_group_state_changed)

151

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

152

service.name, service.type)

153

group.AddService(

154

self.interface, # interface

155

avahi.PROTO_INET6, # protocol

156

dbus.UInt32(0), # flags

157

self.name, self.type,

158

self.domain, self.host,

159

dbus.UInt16(self.port),

160

avahi.string_array_to_txt_array(self.TXT))

161

group.Commit()

162

83

del syslogger

84

85

# This variable is used to optionally bind to a specified interface.

86

# It is a global variable to fit in with the other variables from the

87

# Avahi example code.

88

serviceInterface = avahi.IF_UNSPEC

163

89

# From the Avahi example code:

164

group = None # our entry group

90

serviceName = "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

165

99

# End of Avahi example code

166

100

167

101

172

106

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

173

107

uniquely identify the client

174

108

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

175

host: string; available for use by the checker command

176

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

177

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

178

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

179

until this client is invalid

109

fqdn: string (FQDN); available for use by the checker command

110

created: datetime.datetime()

111

last_seen: datetime.datetime() or None if not yet seen

112

timeout: datetime.timedelta(); How long from last_seen until

113

this client is invalid

180

114

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

181

115

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

182

116

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

183

117

to see if the client lives.

184

'None' if no process is running.

118

Is None if no process is running.

185

119

checker_initiator_tag: a gobject event source tag, or None

186

120

stop_initiator_tag: - '' -

187

121

checker_callback_tag: - '' -

188

122

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

189

client lives. %() expansions are done at

123

client lives. %()s expansions are done at

190

124

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

191

125

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

192

126

Private attibutes:

193

127

_timeout: Real variable for 'timeout'

194

128

_interval: Real variable for 'interval'

195

_timeout_milliseconds: Used when calling gobject.timeout_add()

129

_timeout_milliseconds: Used by gobject.timeout_add()

196

130

_interval_milliseconds: - '' -

197

131

"""

198

132

def _set_timeout(self, timeout):

218

152

interval = property(lambda self: self._interval,

219

153

_set_interval)

220

154

del _set_interval

221

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

222

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

223

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

224

attribute."""

155

def __init__(self, name=None, 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.."""

225

160

self.name = name

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

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)

237

169

self.secret = sf.read()

238

170

sf.close()

239

171

else:

240

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

241

% self.name)

242

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

172

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

173

% self.name)

174

self.fqdn = fqdn # string

243

175

self.created = datetime.datetime.now()

244

self.last_checked_ok = None

245

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

246

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

176

self.last_seen = None

177

if timeout is None:

178

self.timeout = options.timeout

179

else:

180

self.timeout = string_to_delta(timeout)

181

if interval == -1:

182

self.interval = options.interval

183

else:

184

self.interval = string_to_delta(interval)

247

185

self.stop_hook = stop_hook

248

186

self.checker = None

249

187

self.checker_initiator_tag = None

250

188

self.stop_initiator_tag = None

251

189

self.checker_callback_tag = None

252

self.check_command = config["checker"]

190

self.check_command = checker

253

191

def start(self):

254

192

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

255

193

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

265

203

self.stop)

266

204

def stop(self):

267

205

"""Stop this client.

268

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

269

but not currently used."""

206

The possibility that this client might be restarted is left

207

open, but not currently used."""

270

208

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

271

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

272

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

209

if self.secret:

210

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

273

211

self.secret = None

274

212

else:

275

213

return False

276

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

214

if hasattr(self, "stop_initiator_tag") \

215

and self.stop_initiator_tag:

277

216

gobject.source_remove(self.stop_initiator_tag)

278

217

self.stop_initiator_tag = None

279

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

218

if hasattr(self, "checker_initiator_tag") \

219

and self.checker_initiator_tag:

280

220

gobject.source_remove(self.checker_initiator_tag)

281

221

self.checker_initiator_tag = None

282

222

self.stop_checker()

294

234

self.checker = None

295

235

if os.WIFEXITED(condition) \

296

236

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

297

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

298

vars(self))

299

self.last_checked_ok = now

237

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

238

vars(self))

239

self.last_seen = now

300

240

gobject.source_remove(self.stop_initiator_tag)

301

241

self.stop_initiator_tag = gobject.timeout_add\

302

242

(self._timeout_milliseconds,

305

245

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

306

246

vars(self))

307

247

else:

308

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

309

vars(self))

248

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

249

vars(self))

310

250

def start_checker(self):

311

251

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

312

252

If a checker already exists, leave it running and do

321

261

# is as it should be.

322

262

if self.checker is None:

323

263

try:

324

# In case check_command has exactly one % operator

325

command = self.check_command % self.host

264

command = self.check_command % self.fqdn

326

265

except TypeError:

327

# Escape attributes for the shell

328

266

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

329

267

for key, val in

330

268

vars(self).iteritems())

331

269

try:

332

270

command = self.check_command % escaped_attrs

333

271

except TypeError, error:

334

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

335

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

272

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

273

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

336

274

return True # Try again later

337

275

try:

338

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

339

command, self.name)

340

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

341

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

342

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

343

# always replaced by /dev/null.)

344

self.checker = subprocess.Popen(command,

345

close_fds=True,

346

shell=True, cwd="/")

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

347

282

self.checker_callback_tag = gobject.child_watch_add\

348

283

(self.checker.pid,

349

284

self.checker_callback)

350

except OSError, error:

285

except subprocess.OSError, error:

351

286

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

352

287

error)

353

288

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

357

292

if self.checker_callback_tag:

358

293

gobject.source_remove(self.checker_callback_tag)

359

294

self.checker_callback_tag = None

360

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

295

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

361

296

return

362

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

297

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

363

298

try:

364

299

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

365

300

#os.sleep(0.5)

366

301

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

367

302

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

368

303

except OSError, error:

369

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

304

if error.errno != errno.ESRCH:

370

305

raise

371

306

self.checker = None

372

def still_valid(self):

307

def still_valid(self, now=None):

373

308

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

374

now = datetime.datetime.now()

375

if self.last_checked_ok is None:

309

if now is None:

310

now = datetime.datetime.now()

311

if self.last_seen is None:

376

312

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

377

313

else:

378

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

314

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

379

315

380

316

381

317

def peer_certificate(session):

397

333

398

334

def fingerprint(openpgp):

399

335

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

400

340

# New GnuTLS "datum" with the OpenPGP public key

401

341

datum = gnutls.library.types.gnutls_datum_t\

402

342

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

403

343

ctypes.POINTER(ctypes.c_ubyte)),

404

344

ctypes.c_uint(len(openpgp)))

405

# New empty GnuTLS certificate

406

crt = gnutls.library.types.gnutls_openpgp_crt_t()

407

gnutls.library.functions.gnutls_openpgp_crt_init\

408

(ctypes.byref(crt))

409

345

# Import the OpenPGP public key into the certificate

410

gnutls.library.functions.gnutls_openpgp_crt_import\

411

(crt, ctypes.byref(datum),

412

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

413

# Verify the self signature in the key

414

crtverify = ctypes.c_uint();

415

gnutls.library.functions.gnutls_openpgp_crt_verify_self\

416

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

417

if crtverify.value != 0:

418

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

419

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

346

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

347

(crt,

348

ctypes.byref(datum),

349

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

420

350

# New buffer for the fingerprint

421

351

buffer = ctypes.create_string_buffer(20)

422

352

buffer_length = ctypes.c_size_t()

438

368

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

439

369

440

370

def handle(self):

441

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

371

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

442

372

unicode(self.client_address))

443

session = gnutls.connection.ClientSession\

444

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

445

446

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

447

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

448

try:

449

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

450

raise RuntimeError

451

except (ValueError, IndexError, RuntimeError), error:

452

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

453

return

454

455

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

456

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

457

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

458

# using OpenPGP certificates.

373

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

374

gnutls.connection.\

375

X509Credentials())

459

376

460

377

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

461

378

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

462

379

# "+DHE-DSS"))

463

priority = "NORMAL" # Fallback default, since this

464

# MUST be set.

465

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

466

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

380

priority = "SECURE256"

381

467

382

gnutls.library.functions.gnutls_priority_set_direct\

468

383

(session._c_object, priority, None);

469

384

470

385

try:

471

386

session.handshake()

472

387

except gnutls.errors.GNUTLSError, error:

473

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

388

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

474

389

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

475

390

# established. Just abandon the request.

476

391

return

477

392

try:

478

393

fpr = fingerprint(peer_certificate(session))

479

394

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

480

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

395

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

481

396

session.bye()

482

397

return

483

398

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

486

401

if c.fingerprint == fpr:

487

402

client = c

488

403

break

489

if not client:

490

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

491

fpr)

492

session.bye()

493

return

494

404

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

495

405

# that the client timed out while establishing the GnuTLS

496

406

# session.

497

if not client.still_valid():

498

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

499

vars(client))

407

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

408

if client:

409

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

410

vars(client))

411

else:

412

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

413

fpr)

500

414

session.bye()

501

415

return

502

416

sent_size = 0

512

426

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

513

427

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

514

428

Attributes:

515

settings: Server settings

429

options: Command line options

516

430

clients: Set() of Client objects

517

431

"""

518

432

address_family = socket.AF_INET6

519

433

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

520

if "settings" in kwargs:

521

self.settings = kwargs["settings"]

522

del kwargs["settings"]

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

523

437

if "clients" in kwargs:

524

438

self.clients = kwargs["clients"]

525

439

del kwargs["clients"]

528

442

"""This overrides the normal server_bind() function

529

443

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

530

444

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

531

if self.settings["interface"]:

532

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

533

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

445

if self.options.interface:

446

if not hasattr(socket, "SO_BINDTODEVICE"):

447

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

448

socket.SO_BINDTODEVICE = 25

534

449

try:

535

450

self.socket.setsockopt(socket.SOL_SOCKET,

536

SO_BINDTODEVICE,

537

self.settings["interface"])

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

538

453

except socket.error, error:

539

454

if error[0] == errno.EPERM:

540

logger.error(u"No permission to"

541

u" bind to interface %s",

542

self.settings["interface"])

455

logger.warning(u"No permission to"

456

u" bind to interface %s",

457

self.options.interface)

543

458

else:

544

459

raise error

545

460

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

548

463

in6addr_any = "::"

549

464

self.server_address = (in6addr_any,

550

465

self.server_address[1])

551

elif not self.server_address[1]:

466

elif self.server_address[1] is None:

552

467

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

553

468

0)

554

# if self.settings["interface"]:

555

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

556

# 0, # port

557

# 0, # flowinfo

558

# if_nametoindex

559

# (self.settings

560

# ["interface"]))

561

469

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

562

470

563

471

574

482

datetime.timedelta(1)

575

483

>>> string_to_delta(u'1w')

576

484

datetime.timedelta(7)

577

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

578

datetime.timedelta(0, 330)

579

485

"""

580

timevalue = datetime.timedelta(0)

581

for s in interval.split():

582

try:

583

suffix=unicode(s[-1])

584

value=int(s[:-1])

585

if suffix == u"d":

586

delta = datetime.timedelta(value)

587

elif suffix == u"s":

588

delta = datetime.timedelta(0, value)

589

elif suffix == u"m":

590

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

591

elif suffix == u"h":

592

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

593

elif suffix == u"w":

594

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

595

else:

596

raise ValueError

597

except (ValueError, IndexError):

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:

598

500

raise ValueError

599

timevalue += delta

600

return timevalue

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

601

537

602

538

603

539

def server_state_changed(state):

604

540

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

605

541

if state == avahi.SERVER_COLLISION:

606

logger.error(u"Server name collision")

607

service.remove()

542

logger.warning(u"Server name collision")

543

remove_service()

608

544

elif state == avahi.SERVER_RUNNING:

609

service.add()

545

add_service()

610

546

611

547

612

548

def entry_group_state_changed(state, error):

613

549

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

550

global serviceName, server, rename_count

551

614

552

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

615

553

616

554

if state == avahi.ENTRY_GROUP_ESTABLISHED:

617

555

logger.debug(u"Service established.")

618

556

elif state == avahi.ENTRY_GROUP_COLLISION:

619

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

620

service.rename()

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)

621

570

elif state == avahi.ENTRY_GROUP_FAILURE:

622

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

623

unicode(error))

624

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

571

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

572

unicode(error))

573

killme(1)

574

625

575

626

576

def if_nametoindex(interface):

627

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

628

global if_nametoindex

577

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

629

578

try:

630

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

631

import ctypes.util

632

if_nametoindex = ctypes.cdll.LoadLibrary\

633

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

579

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

580

return libc.if_nametoindex(interface)

634

581

except (OSError, AttributeError):

635

582

if "struct" not in sys.modules:

636

583

import struct

637

584

if "fcntl" not in sys.modules:

638

585

import fcntl

639

def if_nametoindex(interface):

640

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

641

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

642

s = socket.socket()

643

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

644

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

645

s.close()

646

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

647

return interface_index

648

return if_nametoindex(interface)

649

650

651

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

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

652

596

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

653

597

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

654

598

if os.fork():

656

600

os.setsid()

657

601

if not nochdir:

658

602

os.chdir("/")

659

if os.fork():

660

sys.exit()

661

603

if not noclose:

662

604

# Close all standard open file descriptors

663

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

605

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

664

606

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

665

607

raise OSError(errno.ENODEV,

666

608

"/dev/null not a character device")

671

613

os.close(null)

672

614

673

615

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

674

625

def main():

626

global exitstatus

627

exitstatus = 0

675

628

global main_loop_started

676

629

main_loop_started = False

677

630

678

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

631

parser = OptionParser()

679

632

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

680

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

681

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

633

default=None, metavar="IF",

634

help="Bind to interface IF")

635

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

682

636

help="Address to listen for requests on")

683

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

637

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

684

638

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

685

645

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

686

646

help="Run self-test")

687

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

688

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

689

" terminal")

690

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

691

" priority string (see GnuTLS documentation)")

692

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

693

help="Zeroconf service name")

694

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

695

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

696

help="Directory to search for configuration"

697

" files")

647

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

648

help="Debug mode")

698

649

(options, args) = parser.parse_args()

699

650

700

651

if options.check:

702

653

doctest.testmod()

703

654

sys.exit()

704

655

705

# Default values for config file for server-global settings

706

server_defaults = { "interface": "",

707

"address": "",

708

"port": "",

709

"debug": "False",

710

"priority":

711

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

712

"servicename": "Mandos",

713

}

714

715

# Parse config file for server-global settings

716

server_config = ConfigParser.SafeConfigParser(server_defaults)

717

del server_defaults

718

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

719

# Convert the SafeConfigParser object to a dict

720

server_settings = server_config.defaults()

721

# Use getboolean on the boolean config option

722

server_settings["debug"] = server_config.getboolean\

723

("DEFAULT", "debug")

724

del server_config

725

726

# Override the settings from the config file with command line

727

# options, if set.

728

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

729

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

730

value = getattr(options, option)

731

if value is not None:

732

server_settings[option] = value

733

del options

734

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

735

736

debug = server_settings["debug"]

737

738

if not debug:

739

syslogger.setLevel(logging.WARNING)

740

console.setLevel(logging.WARNING)

741

742

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

743

syslogger.setFormatter(logging.Formatter\

744

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

745

' %%(message)s'

746

% server_settings["servicename"]))

747

748

# Parse config file with clients

749

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

750

"interval": "5m",

751

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

752

"host": "",

753

}

754

client_config = ConfigParser.SafeConfigParser(client_defaults)

755

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

756

"clients.conf"))

757

758

global service

759

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

760

type = "_mandos._tcp", );

761

if server_settings["interface"]:

762

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

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

763

671

764

672

global main_loop

765

673

global bus

773

681

avahi.DBUS_INTERFACE_SERVER )

774

682

# End of Avahi example code

775

683

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

776

694

clients = Set()

777

695

def remove_from_clients(client):

778

696

clients.remove(client)

779

697

if not clients:

780

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

781

sys.exit()

698

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

699

killme()

782

700

783

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

701

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

784

702

stop_hook = remove_from_clients,

785

config

786

= dict(client_config.items(section)))

703

**(dict(client_config\

704

.items(section))))

787

705

for section in client_config.sections()))

788

if not clients:

789

logger.critical(u"No clients defined")

790

sys.exit(1)

791

792

if debug:

793

# Redirect stdin so all checkers get /dev/null

794

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

795

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

796

if null > 2:

797

os.close(null)

798

else:

799

# No console logging

800

logger.removeHandler(console)

801

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

802

daemon()

803

804

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

805

pid = os.getpid()

806

try:

807

pidfile = open(pidfilename, "w")

808

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

809

pidfile.close()

810

del pidfile

811

except IOError, err:

812

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

813

pidfilename, os.getpid())

706

707

if not debug:

708

daemon(False, False)

814

709

815

710

def cleanup():

816

711

"Cleanup function; run on exit"

830

725

831

726

if not debug:

832

727

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

833

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

834

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

728

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

729

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

835

730

836

731

for client in clients:

837

732

client.start()

838

733

839

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

840

server_settings["port"]),

734

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

841

735

tcp_handler,

842

settings=server_settings,

736

options=options,

843

737

clients=clients)

844

# Find out what port we got

845

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

846

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

847

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

848

849

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

850

851

try:

852

# From the Avahi example code

853

server.connect_to_signal("StateChanged", server_state_changed)

854

try:

855

server_state_changed(server.GetState())

856

except dbus.exceptions.DBusException, error:

857

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

858

sys.exit(1)

859

# End of Avahi example code

860

861

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

862

lambda *args, **kwargs:

863

tcp_server.handle_request\

864

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

865

866

logger.debug(u"Starting main loop")

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

867

762

main_loop_started = True

868

763

main_loop.run()

869

except AvahiError, error:

870

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

871

sys.exit(1)

872

764

except KeyboardInterrupt:

873

765

if debug:

874

766

print

767

768

sys.exit(exitstatus)

875

769

876

770

if __name__ == '__main__':

877

771

main()