/mandos/trunk : revision 109

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

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 <http://www.gnu.org/licenses/>.

27

# along with this program. If not, see

28

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

28

29

#

29

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

30

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

30

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

31

#

32

33

from __future__ import division

62

from dbus.mainloop.glib import DBusGMainLoop

63

import ctypes

64

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

version = "1.0"

76

66

77

67

logger = logging.Logger('mandos')

78

68

syslogger = logging.handlers.SysLogHandler\

79

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

69

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

70

address = "/dev/log")

80

71

syslogger.setFormatter(logging.Formatter\

81

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

72

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

82

73

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

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

89

166

# 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

167

group = None # our entry group

99

168

# End of Avahi example code

100

169

101

170

106

175

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

107

176

uniquely identify the client

108

177

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

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

114

183

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

115

184

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

116

185

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

117

186

to see if the client lives.

118

Is None if no process is running.

187

'None' if no process is running.

119

188

checker_initiator_tag: a gobject event source tag, or None

120

189

stop_initiator_tag: - '' -

121

190

checker_callback_tag: - '' -

122

191

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

123

client lives. %()s expansions are done at

192

client lives. %() expansions are done at

124

193

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

125

194

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

126

195

Private attibutes:

127

196

_timeout: Real variable for 'timeout'

128

197

_interval: Real variable for 'interval'

129

_timeout_milliseconds: Used by gobject.timeout_add()

198

_timeout_milliseconds: Used when calling gobject.timeout_add()

130

199

_interval_milliseconds: - '' -

131

200

"""

132

201

def _set_timeout(self, timeout):

152

221

interval = property(lambda self: self._interval,

153

222

_set_interval)

154

223

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

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

160

228

self.name = name

161

229

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

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

166

235

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

167

if secret:

168

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

169

elif secfile:

170

sf = open(secfile)

236

if "secret" in config:

237

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

238

elif "secfile" in config:

239

sf = open(config["secfile"])

171

240

self.secret = sf.read()

172

241

sf.close()

173

242

else:

174

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

175

% self.name)

176

self.fqdn = fqdn # string

243

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

244

% self.name)

245

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

177

246

self.created = datetime.datetime.now()

178

self.last_seen = None

179

self.timeout = string_to_delta(timeout)

180

self.interval = string_to_delta(interval)

247

self.last_checked_ok = None

248

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

249

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

181

250

self.stop_hook = stop_hook

182

251

self.checker = None

183

252

self.checker_initiator_tag = None

184

253

self.stop_initiator_tag = None

185

254

self.checker_callback_tag = None

186

self.check_command = checker

255

self.check_command = config["checker"]

187

256

def start(self):

188

257

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

189

258

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

199

268

self.stop)

200

269

def stop(self):

201

270

"""Stop this client.

202

The possibility that this client might be restarted is left

203

open, but not currently used."""

271

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

272

but not currently used."""

204

273

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

274

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

275

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

207

276

self.secret = None

208

277

else:

209

278

return False

210

if hasattr(self, "stop_initiator_tag") \

211

and self.stop_initiator_tag:

279

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

212

280

gobject.source_remove(self.stop_initiator_tag)

213

281

self.stop_initiator_tag = None

214

if hasattr(self, "checker_initiator_tag") \

215

and self.checker_initiator_tag:

282

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

216

283

gobject.source_remove(self.checker_initiator_tag)

217

284

self.checker_initiator_tag = None

218

285

self.stop_checker()

230

297

self.checker = None

231

298

if os.WIFEXITED(condition) \

232

299

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

233

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

234

vars(self))

235

self.last_seen = now

300

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

301

vars(self))

302

self.last_checked_ok = now

236

303

gobject.source_remove(self.stop_initiator_tag)

237

304

self.stop_initiator_tag = gobject.timeout_add\

238

305

(self._timeout_milliseconds,

241

308

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

242

309

vars(self))

243

310

else:

244

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

245

vars(self))

311

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

312

vars(self))

246

313

def start_checker(self):

247

314

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

248

315

If a checker already exists, leave it running and do

257

324

# is as it should be.

258

325

if self.checker is None:

259

326

try:

260

command = self.check_command % self.fqdn

327

# In case check_command has exactly one % operator

328

command = self.check_command % self.host

261

329

except TypeError:

330

# Escape attributes for the shell

262

331

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

263

332

for key, val in

264

333

vars(self).iteritems())

265

334

try:

266

335

command = self.check_command % escaped_attrs

267

336

except TypeError, error:

268

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

269

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

337

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

338

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

270

339

return True # Try again later

271

340

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

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

278

350

self.checker_callback_tag = gobject.child_watch_add\

279

351

(self.checker.pid,

280

352

self.checker_callback)

281

except subprocess.OSError, error:

353

except OSError, error:

282

354

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

283

355

error)

284

356

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

288

360

if self.checker_callback_tag:

289

361

gobject.source_remove(self.checker_callback_tag)

290

362

self.checker_callback_tag = None

291

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

363

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

292

364

return

293

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

365

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

294

366

try:

295

367

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

296

368

#os.sleep(0.5)

297

369

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

298

370

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

299

371

except OSError, error:

300

if error.errno != errno.ESRCH:

372

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

301

373

raise

302

374

self.checker = None

303

def still_valid(self, now=None):

375

def still_valid(self):

304

376

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

377

now = datetime.datetime.now()

378

if self.last_checked_ok is None:

308

379

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

309

380

else:

310

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

381

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

311

382

312

383

313

384

def peer_certificate(session):

329

400

330

401

def fingerprint(openpgp):

331

402

"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

403

# New GnuTLS "datum" with the OpenPGP public key

337

404

datum = gnutls.library.types.gnutls_datum_t\

338

405

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

339

406

ctypes.POINTER(ctypes.c_ubyte)),

340

407

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

341

412

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

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

346

423

# New buffer for the fingerprint

347

424

buffer = ctypes.create_string_buffer(20)

348

425

buffer_length = ctypes.c_size_t()

364

441

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

365

442

366

443

def handle(self):

367

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

444

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

368

445

unicode(self.client_address))

369

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

370

gnutls.connection.\

371

X509Credentials())

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.

372

462

373

463

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

374

464

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

375

465

# "+DHE-DSS"))

376

priority = "NORMAL"

377

if self.server.options.priority:

378

priority = self.server.options.priority

466

priority = "NORMAL" # Fallback default, since this

467

# MUST be set.

468

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

469

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

379

470

gnutls.library.functions.gnutls_priority_set_direct\

380

471

(session._c_object, priority, None);

381

472

382

473

try:

383

474

session.handshake()

384

475

except gnutls.errors.GNUTLSError, error:

385

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

476

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

386

477

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

387

478

# established. Just abandon the request.

388

479

return

389

480

try:

390

481

fpr = fingerprint(peer_certificate(session))

391

482

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

392

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

483

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

393

484

session.bye()

394

485

return

395

486

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

398

489

if c.fingerprint == fpr:

399

490

client = c

400

491

break

492

if not client:

493

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

494

fpr)

495

session.bye()

496

return

401

497

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

402

498

# that the client timed out while establishing the GnuTLS

403

499

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

500

if not client.still_valid():

501

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

502

vars(client))

411

503

session.bye()

412

504

return

413

505

sent_size = 0

423

515

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

424

516

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

425

517

Attributes:

426

options: Command line options

518

settings: Server settings

427

519

clients: Set() of Client objects

428

520

"""

429

521

address_family = socket.AF_INET6

430

522

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

431

if "options" in kwargs:

432

self.options = kwargs["options"]

433

del kwargs["options"]

523

if "settings" in kwargs:

524

self.settings = kwargs["settings"]

525

del kwargs["settings"]

434

526

if "clients" in kwargs:

435

527

self.clients = kwargs["clients"]

436

528

del kwargs["clients"]

439

531

"""This overrides the normal server_bind() function

440

532

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

441

533

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

534

if self.settings["interface"]:

535

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

536

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

446

537

try:

447

538

self.socket.setsockopt(socket.SOL_SOCKET,

448

socket.SO_BINDTODEVICE,

449

self.options.interface)

539

SO_BINDTODEVICE,

540

self.settings["interface"])

450

541

except socket.error, error:

451

542

if error[0] == errno.EPERM:

452

logger.warning(u"No permission to"

453

u" bind to interface %s",

454

self.options.interface)

543

logger.error(u"No permission to"

544

u" bind to interface %s",

545

self.settings["interface"])

455

546

else:

456

547

raise error

457

548

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

460

551

in6addr_any = "::"

461

552

self.server_address = (in6addr_any,

462

553

self.server_address[1])

463

elif self.server_address[1] is None:

554

elif not self.server_address[1]:

464

555

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

465

556

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

466

564

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

467

565

468

566

479

577

datetime.timedelta(1)

480

578

>>> string_to_delta(u'1w')

481

579

datetime.timedelta(7)

580

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

581

datetime.timedelta(0, 330)

482

582

"""

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:

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

497

601

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

602

timevalue += delta

603

return timevalue

534

604

535

605

536

606

def server_state_changed(state):

537

607

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

538

608

if state == avahi.SERVER_COLLISION:

539

logger.warning(u"Server name collision")

540

remove_service()

609

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

610

service.remove()

541

611

elif state == avahi.SERVER_RUNNING:

542

add_service()

612

service.add()

543

613

544

614

545

615

def entry_group_state_changed(state, error):

546

616

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

547

global serviceName, server, rename_count

548

549

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

617

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

550

618

551

619

if state == avahi.ENTRY_GROUP_ESTABLISHED:

552

logger.debug(u"Service established.")

620

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

553

621

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)

622

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

623

service.rename()

567

624

elif state == avahi.ENTRY_GROUP_FAILURE:

568

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

569

unicode(error))

570

killme(1)

571

625

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

626

unicode(error))

627

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

572

628

573

629

def if_nametoindex(interface):

574

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

630

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

631

global if_nametoindex

575

632

try:

576

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

577

return libc.if_nametoindex(interface)

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

578

637

except (OSError, AttributeError):

579

638

if "struct" not in sys.modules:

580

639

import struct

581

640

if "fcntl" not in sys.modules:

582

641

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

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

593

655

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

594

656

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

595

657

if os.fork():

597

659

os.setsid()

598

660

if not nochdir:

599

661

os.chdir("/")

662

if os.fork():

663

sys.exit()

600

664

if not noclose:

601

665

# Close all standard open file descriptors

602

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

666

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

603

667

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

604

668

raise OSError(errno.ENODEV,

605

669

"/dev/null not a character device")

610

674

os.close(null)

611

675

612

676

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

677

def main():

623

global exitstatus

624

exitstatus = 0

625

678

global main_loop_started

626

679

main_loop_started = False

627

680

628

parser = OptionParser()

681

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

629

682

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,

683

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

684

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

633

685

help="Address to listen for requests on")

634

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

686

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

635

687

help="Port number to receive requests on")

636

688

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

637

689

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

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

646

701

(options, args) = parser.parse_args()

647

702

648

703

if options.check:

650

705

doctest.testmod()

651

706

sys.exit()

652

707

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;

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

664

767

665

768

global main_loop

666

769

global bus

669

772

DBusGMainLoop(set_as_default=True )

670

773

main_loop = gobject.MainLoop()

671

774

bus = dbus.SystemBus()

672

server = dbus.Interface(

673

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

674

avahi.DBUS_INTERFACE_SERVER )

775

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

776

avahi.DBUS_PATH_SERVER),

777

avahi.DBUS_INTERFACE_SERVER)

675

778

# End of Avahi example code

676

779

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

780

clients = Set()

688

781

def remove_from_clients(client):

689

782

clients.remove(client)

690

783

if not clients:

691

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

692

killme()

784

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

785

sys.exit()

693

786

694

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

787

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

695

788

stop_hook = remove_from_clients,

696

**(dict(client_config\

697

.items(section))))

789

config

790

= dict(client_config.items(section)))

698

791

for section in client_config.sections()))

699

700

if not debug:

701

daemon(False, False)

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

702

818

703

819

def cleanup():

704

820

"Cleanup function; run on exit"

718

834

719

835

if not debug:

720

836

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

837

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

838

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

723

839

724

840

for client in clients:

725

841

client.start()

726

842

727

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

843

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

844

server_settings["port"]),

728

845

tcp_handler,

729

options=options,

846

settings=server_settings,

730

847

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

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

755

871

main_loop_started = True

756

872

main_loop.run()

873

except AvahiError, error:

874

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

875

sys.exit(1)

757

876

except KeyboardInterrupt:

758

877

if debug:

759

878

print

760

761

sys.exit(exitstatus)

762

879

763

880

if __name__ == '__main__':

764

881

main()