/mandos/release : revision 22

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

def rename(self):

123

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

124

if self.rename_count >= self.max_renames:

125

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

126

u" retries, exiting.", rename_count)

127

raise AvahiServiceError("Too many renames")

128

name = server.GetAlternativeServiceName(name)

129

logger.error(u"Changing name to %r ...", name)

130

syslogger.setFormatter(logging.Formatter\

131

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

132

' %%(message)s' % name))

133

self.remove()

134

self.add()

135

self.rename_count += 1

136

def remove(self):

137

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

138

if group is not None:

139

group.Reset()

140

def add(self):

141

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

142

global group

143

if group is None:

144

group = dbus.Interface\

145

(bus.get_object(avahi.DBUS_NAME,

146

server.EntryGroupNew()),

147

avahi.DBUS_INTERFACE_ENTRY_GROUP)

148

group.connect_to_signal('StateChanged',

149

entry_group_state_changed)

150

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

151

service.name, service.type)

152

group.AddService(

153

self.interface, # interface

154

avahi.PROTO_INET6, # protocol

155

dbus.UInt32(0), # flags

156

self.name, self.type,

157

self.domain, self.host,

158

dbus.UInt16(self.port),

159

avahi.string_array_to_txt_array(self.TXT))

160

group.Commit()

161

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

162

89

# From the Avahi example code:

163

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

164

99

# End of Avahi example code

165

100

166

101

171

106

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

172

107

uniquely identify the client

173

108

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

174

host: string; available for use by the checker command

175

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

176

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

177

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

178

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

179

114

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

180

115

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

181

116

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

182

117

to see if the client lives.

183

'None' if no process is running.

118

Is None if no process is running.

184

119

checker_initiator_tag: a gobject event source tag, or None

185

120

stop_initiator_tag: - '' -

186

121

checker_callback_tag: - '' -

187

122

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

188

client lives. %() expansions are done at

123

client lives. %()s expansions are done at

189

124

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

190

125

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

191

126

Private attibutes:

192

127

_timeout: Real variable for 'timeout'

193

128

_interval: Real variable for 'interval'

194

_timeout_milliseconds: Used when calling gobject.timeout_add()

129

_timeout_milliseconds: Used by gobject.timeout_add()

195

130

_interval_milliseconds: - '' -

196

131

"""

197

132

def _set_timeout(self, timeout):

217

152

interval = property(lambda self: self._interval,

218

153

_set_interval)

219

154

del _set_interval

220

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

221

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

222

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

223

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

224

160

self.name = name

225

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

226

# Uppercase and remove spaces from fingerprint for later

227

# comparison purposes with return value from the fingerprint()

228

# function

229

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

230

.replace(u" ", u"")

231

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

232

if "secret" in config:

233

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

234

elif "secfile" in config:

235

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)

236

169

self.secret = sf.read()

237

170

sf.close()

238

171

else:

239

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

240

% self.name)

241

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

172

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

173

% self.name)

174

self.fqdn = fqdn # string

242

175

self.created = datetime.datetime.now()

243

self.last_checked_ok = None

244

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

245

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)

246

185

self.stop_hook = stop_hook

247

186

self.checker = None

248

187

self.checker_initiator_tag = None

249

188

self.stop_initiator_tag = None

250

189

self.checker_callback_tag = None

251

self.check_command = config["checker"]

190

self.check_command = checker

252

191

def start(self):

253

192

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

254

193

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

264

203

self.stop)

265

204

def stop(self):

266

205

"""Stop this client.

267

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

268

but not currently used."""

206

The possibility that this client might be restarted is left

207

open, but not currently used."""

269

208

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

270

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

271

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

209

if self.secret:

210

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

272

211

self.secret = None

273

212

else:

274

213

return False

275

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

214

if hasattr(self, "stop_initiator_tag") \

215

and self.stop_initiator_tag:

276

216

gobject.source_remove(self.stop_initiator_tag)

277

217

self.stop_initiator_tag = None

278

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

218

if hasattr(self, "checker_initiator_tag") \

219

and self.checker_initiator_tag:

279

220

gobject.source_remove(self.checker_initiator_tag)

280

221

self.checker_initiator_tag = None

281

222

self.stop_checker()

293

234

self.checker = None

294

235

if os.WIFEXITED(condition) \

295

236

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

296

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

297

vars(self))

298

self.last_checked_ok = now

237

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

238

vars(self))

239

self.last_seen = now

299

240

gobject.source_remove(self.stop_initiator_tag)

300

241

self.stop_initiator_tag = gobject.timeout_add\

301

242

(self._timeout_milliseconds,

304

245

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

305

246

vars(self))

306

247

else:

307

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

308

vars(self))

248

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

249

vars(self))

309

250

def start_checker(self):

310

251

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

311

252

If a checker already exists, leave it running and do

320

261

# is as it should be.

321

262

if self.checker is None:

322

263

try:

323

# In case check_command has exactly one % operator

324

command = self.check_command % self.host

264

command = self.check_command % self.fqdn

325

265

except TypeError:

326

# Escape attributes for the shell

327

266

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

328

267

for key, val in

329

268

vars(self).iteritems())

330

269

try:

331

270

command = self.check_command % escaped_attrs

332

271

except TypeError, error:

333

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

334

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

272

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

273

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

335

274

return True # Try again later

336

275

try:

337

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

338

command, self.name)

339

self.checker = subprocess.Popen(command,

340

close_fds=True,

341

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

342

282

self.checker_callback_tag = gobject.child_watch_add\

343

283

(self.checker.pid,

344

284

self.checker_callback)

352

292

if self.checker_callback_tag:

353

293

gobject.source_remove(self.checker_callback_tag)

354

294

self.checker_callback_tag = None

355

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

295

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

356

296

return

357

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

297

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

358

298

try:

359

299

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

360

300

#os.sleep(0.5)

361

301

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

362

302

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

363

303

except OSError, error:

364

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

304

if error.errno != errno.ESRCH:

365

305

raise

366

306

self.checker = None

367

def still_valid(self):

307

def still_valid(self, now=None):

368

308

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

369

now = datetime.datetime.now()

370

if self.last_checked_ok is None:

309

if now is None:

310

now = datetime.datetime.now()

311

if self.last_seen is None:

371

312

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

372

313

else:

373

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

314

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

374

315

375

316

376

317

def peer_certificate(session):

392

333

393

334

def fingerprint(openpgp):

394

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

395

340

# New GnuTLS "datum" with the OpenPGP public key

396

341

datum = gnutls.library.types.gnutls_datum_t\

397

342

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

398

343

ctypes.POINTER(ctypes.c_ubyte)),

399

344

ctypes.c_uint(len(openpgp)))

400

# New empty GnuTLS certificate

401

crt = gnutls.library.types.gnutls_openpgp_crt_t()

402

gnutls.library.functions.gnutls_openpgp_crt_init\

403

(ctypes.byref(crt))

404

345

# Import the OpenPGP public key into the certificate

405

gnutls.library.functions.gnutls_openpgp_crt_import\

406

(crt, ctypes.byref(datum),

407

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

346

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

347

(crt,

348

ctypes.byref(datum),

349

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

408

350

# New buffer for the fingerprint

409

351

buffer = ctypes.create_string_buffer(20)

410

352

buffer_length = ctypes.c_size_t()

426

368

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

427

369

428

370

def handle(self):

429

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

371

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

430

372

unicode(self.client_address))

431

session = gnutls.connection.ClientSession\

432

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

433

434

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

435

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

436

try:

437

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

438

raise RuntimeError

439

except (ValueError, IndexError, RuntimeError), error:

440

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

441

return

442

443

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

444

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

445

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

446

# using OpenPGP certificates.

373

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

374

gnutls.connection.\

375

X509Credentials())

447

376

448

377

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

449

378

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

450

379

# "+DHE-DSS"))

451

priority = "NORMAL" # Fallback default, since this

452

# MUST be set.

453

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

454

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

380

priority = "SECURE256"

381

455

382

gnutls.library.functions.gnutls_priority_set_direct\

456

383

(session._c_object, priority, None);

457

384

458

385

try:

459

386

session.handshake()

460

387

except gnutls.errors.GNUTLSError, error:

461

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

388

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

462

389

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

463

390

# established. Just abandon the request.

464

391

return

465

392

try:

466

393

fpr = fingerprint(peer_certificate(session))

467

394

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

468

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

395

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

469

396

session.bye()

470

397

return

471

398

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

474

401

if c.fingerprint == fpr:

475

402

client = c

476

403

break

477

if not client:

478

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

479

fpr)

480

session.bye()

481

return

482

404

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

483

405

# that the client timed out while establishing the GnuTLS

484

406

# session.

485

if not client.still_valid():

486

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

487

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)

488

414

session.bye()

489

415

return

490

416

sent_size = 0

500

426

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

501

427

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

502

428

Attributes:

503

settings: Server settings

429

options: Command line options

504

430

clients: Set() of Client objects

505

431

"""

506

432

address_family = socket.AF_INET6

507

433

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

508

if "settings" in kwargs:

509

self.settings = kwargs["settings"]

510

del kwargs["settings"]

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

511

437

if "clients" in kwargs:

512

438

self.clients = kwargs["clients"]

513

439

del kwargs["clients"]

516

442

"""This overrides the normal server_bind() function

517

443

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

518

444

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

519

if self.settings["interface"]:

520

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

521

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

522

449

try:

523

450

self.socket.setsockopt(socket.SOL_SOCKET,

524

SO_BINDTODEVICE,

525

self.settings["interface"])

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

526

453

except socket.error, error:

527

454

if error[0] == errno.EPERM:

528

logger.error(u"No permission to"

529

u" bind to interface %s",

530

self.settings["interface"])

455

logger.warning(u"No permission to"

456

u" bind to interface %s",

457

self.options.interface)

531

458

else:

532

459

raise error

533

460

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

536

463

in6addr_any = "::"

537

464

self.server_address = (in6addr_any,

538

465

self.server_address[1])

539

elif not self.server_address[1]:

466

elif self.server_address[1] is None:

540

467

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

541

468

0)

542

# if self.settings["interface"]:

543

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

544

# 0, # port

545

# 0, # flowinfo

546

# if_nametoindex

547

# (self.settings

548

# ["interface"]))

549

469

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

550

470

551

471

583

503

return delta

584

504

585

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

537

538

586

539

def server_state_changed(state):

587

540

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

588

541

if state == avahi.SERVER_COLLISION:

589

logger.error(u"Server name collision")

590

service.remove()

542

logger.warning(u"Server name collision")

543

remove_service()

591

544

elif state == avahi.SERVER_RUNNING:

592

service.add()

545

add_service()

593

546

594

547

595

548

def entry_group_state_changed(state, error):

596

549

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

550

global serviceName, server, rename_count

551

597

552

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

598

553

599

554

if state == avahi.ENTRY_GROUP_ESTABLISHED:

600

555

logger.debug(u"Service established.")

601

556

elif state == avahi.ENTRY_GROUP_COLLISION:

602

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

603

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)

604

570

elif state == avahi.ENTRY_GROUP_FAILURE:

605

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

606

unicode(error))

607

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

571

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

572

unicode(error))

573

killme(1)

574

608

575

609

576

def if_nametoindex(interface):

610

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

611

global if_nametoindex

577

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

612

578

try:

613

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

614

import ctypes.util

615

if_nametoindex = ctypes.cdll.LoadLibrary\

616

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

579

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

580

return libc.if_nametoindex(interface)

617

581

except (OSError, AttributeError):

618

582

if "struct" not in sys.modules:

619

583

import struct

620

584

if "fcntl" not in sys.modules:

621

585

import fcntl

622

def if_nametoindex(interface):

623

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

624

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

625

s = socket.socket()

626

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

627

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

628

s.close()

629

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

630

return interface_index

631

return if_nametoindex(interface)

632

633

634

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

635

596

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

636

597

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

637

598

if os.fork():

639

600

os.setsid()

640

601

if not nochdir:

641

602

os.chdir("/")

642

if os.fork():

643

sys.exit()

644

603

if not noclose:

645

604

# Close all standard open file descriptors

646

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

605

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

647

606

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

648

607

raise OSError(errno.ENODEV,

649

608

"/dev/null not a character device")

654

613

os.close(null)

655

614

656

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

657

625

def main():

626

global exitstatus

627

exitstatus = 0

658

628

global main_loop_started

659

629

main_loop_started = False

660

630

661

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

631

parser = OptionParser()

662

632

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

663

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

664

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,

665

636

help="Address to listen for requests on")

666

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

637

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

667

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

668

645

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

669

646

help="Run self-test")

670

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

671

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

672

" terminal")

673

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

674

" priority string (see GnuTLS documentation)")

675

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

676

help="Zeroconf service name")

677

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

678

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

679

help="Directory to search for configuration"

680

" files")

647

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

648

help="Debug mode")

681

649

(options, args) = parser.parse_args()

682

650

683

651

if options.check:

685

653

doctest.testmod()

686

654

sys.exit()

687

655

688

# Default values for config file for server-global settings

689

server_defaults = { "interface": "",

690

"address": "",

691

"port": "",

692

"debug": "False",

693

"priority":

694

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

695

"servicename": "Mandos",

696

}

697

698

# Parse config file for server-global settings

699

server_config = ConfigParser.SafeConfigParser(server_defaults)

700

del server_defaults

701

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

702

server_section = "server"

703

# Convert the SafeConfigParser object to a dict

704

server_settings = dict(server_config.items(server_section))

705

# Use getboolean on the boolean config option

706

server_settings["debug"] = server_config.getboolean\

707

(server_section, "debug")

708

del server_config

709

710

# Override the settings from the config file with command line

711

# options, if set.

712

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

713

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

714

value = getattr(options, option)

715

if value is not None:

716

server_settings[option] = value

717

del options

718

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

719

720

debug = server_settings["debug"]

721

722

if not debug:

723

syslogger.setLevel(logging.WARNING)

724

console.setLevel(logging.WARNING)

725

726

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

727

syslogger.setFormatter(logging.Formatter\

728

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

729

' %%(message)s'

730

% server_settings["servicename"]))

731

732

# Parse config file with clients

733

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

734

"interval": "5m",

735

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

736

}

737

client_config = ConfigParser.SafeConfigParser(client_defaults)

738

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

739

"clients.conf"))

740

741

global service

742

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

743

type = "_mandos._tcp", );

744

if server_settings["interface"]:

745

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

746

671

747

672

global main_loop

748

673

global bus

756

681

avahi.DBUS_INTERFACE_SERVER )

757

682

# End of Avahi example code

758

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

759

694

clients = Set()

760

695

def remove_from_clients(client):

761

696

clients.remove(client)

762

697

if not clients:

763

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

764

sys.exit()

698

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

699

killme()

765

700

766

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

701

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

767

702

stop_hook = remove_from_clients,

768

config

769

= dict(client_config.items(section)))

703

**(dict(client_config\

704

.items(section))))

770

705

for section in client_config.sections()))

771

if not clients:

772

logger.critical(u"No clients defined")

773

sys.exit(1)

774

706

775

707

if not debug:

776

logger.removeHandler(console)

777

daemon()

778

779

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

780

pid = os.getpid()

781

try:

782

pidfile = open(pidfilename, "w")

783

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

784

pidfile.close()

785

del pidfile

786

except IOError, err:

787

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

788

pidfilename, os.getpid())

708

daemon(False, False)

789

709

790

710

def cleanup():

791

711

"Cleanup function; run on exit"

805

725

806

726

if not debug:

807

727

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

808

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

809

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

810

730

811

731

for client in clients:

812

732

client.start()

813

733

814

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

815

server_settings["port"]),

734

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

816

735

tcp_handler,

817

settings=server_settings,

736

options=options,

818

737

clients=clients)

819

# Find out what port we got

820

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

821

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

822

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

823

824

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

825

826

try:

827

# From the Avahi example code

828

server.connect_to_signal("StateChanged", server_state_changed)

829

try:

830

server_state_changed(server.GetState())

831

except dbus.exceptions.DBusException, error:

832

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

833

sys.exit(1)

834

# End of Avahi example code

835

836

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

837

lambda *args, **kwargs:

838

tcp_server.handle_request\

839

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

840

841

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

842

762

main_loop_started = True

843

763

main_loop.run()

844

except AvahiError, error:

845

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

846

sys.exit(1)

847

764

except KeyboardInterrupt:

848

765

if debug:

849

766

print

767

768

sys.exit(exitstatus)

850

769

851

770

if __name__ == '__main__':

852

771

main()