/mandos/trunk : revision 19

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

65

# Brief description of the operation of this program:

66

#

67

# This server announces itself as a Zeroconf service. Connecting

68

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

69

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

70

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

71

# supply an OpenPGP certificate, and the fingerprint of this

72

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

73

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

74

# authentication or authorization is done by this server.

75

64

76

65

77

logger = logging.Logger('mandos')

66

78

syslogger = logging.handlers.SysLogHandler\

67

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

68

address = "/dev/log")

79

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

69

80

syslogger.setFormatter(logging.Formatter\

70

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

81

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

71

82

logger.addHandler(syslogger)

72

73

74

class AvahiError(Exception):

75

def __init__(self, value):

76

self.value = value

77

def __str__(self):

78

return repr(self.value)

79

80

class AvahiServiceError(AvahiError):

81

pass

82

83

class AvahiGroupError(AvahiError):

84

pass

85

86

87

class AvahiService(object):

88

"""An Avahi (Zeroconf) service.

89

Attributes:

90

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

91

Used to optionally bind to the specified interface.

92

name: string; Example: 'Mandos'

93

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

94

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

95

port: integer; what port to announce

96

TXT: list of strings; TXT record for the service

97

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

98

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

99

max_renames: integer; maximum number of renames

100

rename_count: integer; counter so we only rename after collisions

101

a sensible number of times

102

"""

103

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

104

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

105

host = "", max_renames = 32768):

106

self.interface = interface

107

self.name = name

108

self.type = type

109

self.port = port

110

if TXT is None:

111

self.TXT = []

112

else:

113

self.TXT = TXT

114

self.domain = domain

115

self.host = host

116

self.rename_count = 0

117

def rename(self):

118

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

119

if self.rename_count >= self.max_renames:

120

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

121

u" retries, exiting.", rename_count)

122

raise AvahiServiceError("Too many renames")

123

name = server.GetAlternativeServiceName(name)

124

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

125

syslogger.setFormatter(logging.Formatter\

126

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

127

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

128

self.remove()

129

self.add()

130

self.rename_count += 1

131

def remove(self):

132

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

133

if group is not None:

134

group.Reset()

135

def add(self):

136

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

137

global group

138

if group is None:

139

group = dbus.Interface\

140

(bus.get_object(avahi.DBUS_NAME,

141

server.EntryGroupNew()),

142

avahi.DBUS_INTERFACE_ENTRY_GROUP)

143

group.connect_to_signal('StateChanged',

144

entry_group_state_changed)

145

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

146

service.name, service.type)

147

group.AddService(

148

self.interface, # interface

149

avahi.PROTO_INET6, # protocol

150

dbus.UInt32(0), # flags

151

self.name, self.type,

152

self.domain, self.host,

153

dbus.UInt16(self.port),

154

avahi.string_array_to_txt_array(self.TXT))

155

group.Commit()

156

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

157

89

# From the Avahi example code:

158

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

159

99

# End of Avahi example code

160

100

161

101

166

106

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

167

107

uniquely identify the client

168

108

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

169

host: string; available for use by the checker command

170

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

171

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

172

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

173

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

174

114

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

175

115

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

176

116

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

177

117

to see if the client lives.

178

'None' if no process is running.

118

Is None if no process is running.

179

119

checker_initiator_tag: a gobject event source tag, or None

180

120

stop_initiator_tag: - '' -

181

121

checker_callback_tag: - '' -

182

122

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

183

client lives. %() expansions are done at

123

client lives. %()s expansions are done at

184

124

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

185

125

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

186

126

Private attibutes:

187

127

_timeout: Real variable for 'timeout'

188

128

_interval: Real variable for 'interval'

189

_timeout_milliseconds: Used when calling gobject.timeout_add()

129

_timeout_milliseconds: Used by gobject.timeout_add()

190

130

_interval_milliseconds: - '' -

191

131

"""

192

132

def _set_timeout(self, timeout):

212

152

interval = property(lambda self: self._interval,

213

153

_set_interval)

214

154

del _set_interval

215

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

216

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

217

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

218

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

219

160

self.name = name

220

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

221

# Uppercase and remove spaces from fingerprint for later

222

# comparison purposes with return value from the fingerprint()

223

# function

224

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

225

.replace(u" ", u"")

226

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

227

if "secret" in config:

228

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

229

elif "secfile" in config:

230

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)

231

169

self.secret = sf.read()

232

170

sf.close()

233

171

else:

234

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

235

% self.name)

236

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

172

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

173

% self.name)

174

self.fqdn = fqdn # string

237

175

self.created = datetime.datetime.now()

238

self.last_checked_ok = None

239

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

240

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)

241

185

self.stop_hook = stop_hook

242

186

self.checker = None

243

187

self.checker_initiator_tag = None

244

188

self.stop_initiator_tag = None

245

189

self.checker_callback_tag = None

246

self.check_command = config["checker"]

190

self.check_command = checker

247

191

def start(self):

248

192

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

249

193

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

259

203

self.stop)

260

204

def stop(self):

261

205

"""Stop this client.

262

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

263

but not currently used."""

206

The possibility that this client might be restarted is left

207

open, but not currently used."""

264

208

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

265

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

266

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

209

if self.secret:

210

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

267

211

self.secret = None

268

212

else:

269

213

return False

270

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

214

if hasattr(self, "stop_initiator_tag") \

215

and self.stop_initiator_tag:

271

216

gobject.source_remove(self.stop_initiator_tag)

272

217

self.stop_initiator_tag = None

273

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

218

if hasattr(self, "checker_initiator_tag") \

219

and self.checker_initiator_tag:

274

220

gobject.source_remove(self.checker_initiator_tag)

275

221

self.checker_initiator_tag = None

276

222

self.stop_checker()

288

234

self.checker = None

289

235

if os.WIFEXITED(condition) \

290

236

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

291

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

292

vars(self))

293

self.last_checked_ok = now

237

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

238

vars(self))

239

self.last_seen = now

294

240

gobject.source_remove(self.stop_initiator_tag)

295

241

self.stop_initiator_tag = gobject.timeout_add\

296

242

(self._timeout_milliseconds,

299

245

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

300

246

vars(self))

301

247

else:

302

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

303

vars(self))

248

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

249

vars(self))

304

250

def start_checker(self):

305

251

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

306

252

If a checker already exists, leave it running and do

315

261

# is as it should be.

316

262

if self.checker is None:

317

263

try:

318

# In case check_command has exactly one % operator

319

command = self.check_command % self.host

264

command = self.check_command % self.fqdn

320

265

except TypeError:

321

# Escape attributes for the shell

322

266

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

323

267

for key, val in

324

268

vars(self).iteritems())

325

269

try:

326

270

command = self.check_command % escaped_attrs

327

271

except TypeError, error:

328

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

329

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

272

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

273

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

330

274

return True # Try again later

331

275

try:

332

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

333

command, self.name)

334

self.checker = subprocess.Popen(command,

335

close_fds=True,

336

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

337

282

self.checker_callback_tag = gobject.child_watch_add\

338

283

(self.checker.pid,

339

284

self.checker_callback)

347

292

if self.checker_callback_tag:

348

293

gobject.source_remove(self.checker_callback_tag)

349

294

self.checker_callback_tag = None

350

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

295

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

351

296

return

352

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

297

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

353

298

try:

354

299

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

355

300

#os.sleep(0.5)

356

301

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

357

302

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

358

303

except OSError, error:

359

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

304

if error.errno != errno.ESRCH:

360

305

raise

361

306

self.checker = None

362

def still_valid(self):

307

def still_valid(self, now=None):

363

308

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

364

now = datetime.datetime.now()

365

if self.last_checked_ok is None:

309

if now is None:

310

now = datetime.datetime.now()

311

if self.last_seen is None:

366

312

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

367

313

else:

368

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

314

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

369

315

370

316

371

317

def peer_certificate(session):

387

333

388

334

def fingerprint(openpgp):

389

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

390

340

# New GnuTLS "datum" with the OpenPGP public key

391

341

datum = gnutls.library.types.gnutls_datum_t\

392

342

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

393

343

ctypes.POINTER(ctypes.c_ubyte)),

394

344

ctypes.c_uint(len(openpgp)))

395

# New empty GnuTLS certificate

396

crt = gnutls.library.types.gnutls_openpgp_crt_t()

397

gnutls.library.functions.gnutls_openpgp_crt_init\

398

(ctypes.byref(crt))

399

345

# Import the OpenPGP public key into the certificate

400

gnutls.library.functions.gnutls_openpgp_crt_import\

401

(crt, ctypes.byref(datum),

402

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)

403

350

# New buffer for the fingerprint

404

351

buffer = ctypes.create_string_buffer(20)

405

352

buffer_length = ctypes.c_size_t()

421

368

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

422

369

423

370

def handle(self):

424

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

371

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

425

372

unicode(self.client_address))

426

session = gnutls.connection.ClientSession\

427

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

428

429

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

430

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

431

try:

432

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

433

raise RuntimeError

434

except (ValueError, IndexError, RuntimeError), error:

435

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

436

return

437

438

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

439

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

440

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

441

# using OpenPGP certificates.

373

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

374

gnutls.connection.\

375

X509Credentials())

442

376

443

377

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

444

378

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

445

379

# "+DHE-DSS"))

446

priority = "NORMAL" # Fallback default, since this

447

# MUST be set.

448

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

449

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

380

priority = "SECURE256"

381

450

382

gnutls.library.functions.gnutls_priority_set_direct\

451

383

(session._c_object, priority, None);

452

384

453

385

try:

454

386

session.handshake()

455

387

except gnutls.errors.GNUTLSError, error:

456

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

388

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

457

389

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

458

390

# established. Just abandon the request.

459

391

return

460

392

try:

461

393

fpr = fingerprint(peer_certificate(session))

462

394

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

463

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

395

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

464

396

session.bye()

465

397

return

466

398

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

469

401

if c.fingerprint == fpr:

470

402

client = c

471

403

break

472

if not client:

473

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

474

fpr)

475

session.bye()

476

return

477

404

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

478

405

# that the client timed out while establishing the GnuTLS

479

406

# session.

480

if not client.still_valid():

481

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

482

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)

483

414

session.bye()

484

415

return

485

416

sent_size = 0

495

426

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

496

427

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

497

428

Attributes:

498

settings: Server settings

429

options: Command line options

499

430

clients: Set() of Client objects

500

431

"""

501

432

address_family = socket.AF_INET6

502

433

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

503

if "settings" in kwargs:

504

self.settings = kwargs["settings"]

505

del kwargs["settings"]

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

506

437

if "clients" in kwargs:

507

438

self.clients = kwargs["clients"]

508

439

del kwargs["clients"]

511

442

"""This overrides the normal server_bind() function

512

443

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

513

444

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

514

if self.settings["interface"]:

515

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

516

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

517

449

try:

518

450

self.socket.setsockopt(socket.SOL_SOCKET,

519

SO_BINDTODEVICE,

520

self.settings["interface"])

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

521

453

except socket.error, error:

522

454

if error[0] == errno.EPERM:

523

logger.error(u"No permission to"

524

u" bind to interface %s",

525

self.settings["interface"])

455

logger.warning(u"No permission to"

456

u" bind to interface %s",

457

self.options.interface)

526

458

else:

527

459

raise error

528

460

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

531

463

in6addr_any = "::"

532

464

self.server_address = (in6addr_any,

533

465

self.server_address[1])

534

elif not self.server_address[1]:

466

elif self.server_address[1] is None:

535

467

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

536

468

0)

537

# if self.settings["interface"]:

538

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

539

# 0, # port

540

# 0, # flowinfo

541

# if_nametoindex

542

# (self.settings

543

# ["interface"]))

544

469

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

545

470

546

471

578

503

return delta

579

504

580

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

581

539

def server_state_changed(state):

582

540

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

583

541

if state == avahi.SERVER_COLLISION:

584

logger.error(u"Server name collision")

585

service.remove()

542

logger.warning(u"Server name collision")

543

remove_service()

586

544

elif state == avahi.SERVER_RUNNING:

587

service.add()

545

add_service()

588

546

589

547

590

548

def entry_group_state_changed(state, error):

591

549

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

550

global serviceName, server, rename_count

551

592

552

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

593

553

594

554

if state == avahi.ENTRY_GROUP_ESTABLISHED:

595

555

logger.debug(u"Service established.")

596

556

elif state == avahi.ENTRY_GROUP_COLLISION:

597

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

598

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)

599

570

elif state == avahi.ENTRY_GROUP_FAILURE:

600

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

601

unicode(error))

602

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

571

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

572

unicode(error))

573

killme(1)

574

603

575

604

576

def if_nametoindex(interface):

605

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

606

global if_nametoindex

577

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

607

578

try:

608

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

609

import ctypes.util

610

if_nametoindex = ctypes.cdll.LoadLibrary\

611

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

579

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

580

return libc.if_nametoindex(interface)

612

581

except (OSError, AttributeError):

613

582

if "struct" not in sys.modules:

614

583

import struct

615

584

if "fcntl" not in sys.modules:

616

585

import fcntl

617

def if_nametoindex(interface):

618

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

619

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

620

s = socket.socket()

621

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

622

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

623

s.close()

624

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

625

return interface_index

626

return if_nametoindex(interface)

627

628

629

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

630

596

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

631

597

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

632

598

if os.fork():

634

600

os.setsid()

635

601

if not nochdir:

636

602

os.chdir("/")

637

if os.fork():

638

sys.exit()

639

603

if not noclose:

640

604

# Close all standard open file descriptors

641

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

605

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

642

606

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

643

607

raise OSError(errno.ENODEV,

644

608

"/dev/null not a character device")

649

613

os.close(null)

650

614

651

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

652

625

def main():

626

global exitstatus

627

exitstatus = 0

653

628

global main_loop_started

654

629

main_loop_started = False

655

630

656

631

parser = OptionParser()

657

632

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

658

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

659

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,

660

636

help="Address to listen for requests on")

661

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

637

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

662

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

663

645

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

664

646

help="Run self-test")

665

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

666

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

667

" terminal")

668

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

669

" priority string (see GnuTLS documentation)")

670

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

671

help="Zeroconf service name")

672

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

673

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

674

help="Directory to search for configuration"

675

" files")

647

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

648

help="Debug mode")

676

649

(options, args) = parser.parse_args()

677

650

678

651

if options.check:

680

653

doctest.testmod()

681

654

sys.exit()

682

655

683

# Default values for config file for server-global settings

684

server_defaults = { "interface": "",

685

"address": "",

686

"port": "",

687

"debug": "False",

688

"priority":

689

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

690

"servicename": "Mandos",

691

}

692

693

# Parse config file for server-global settings

694

server_config = ConfigParser.SafeConfigParser(server_defaults)

695

del server_defaults

696

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

697

server_section = "server"

698

# Convert the SafeConfigParser object to a dict

699

server_settings = dict(server_config.items(server_section))

700

# Use getboolean on the boolean config option

701

server_settings["debug"] = server_config.getboolean\

702

(server_section, "debug")

703

del server_config

704

705

# Override the settings from the config file with command line

706

# options, if set.

707

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

708

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

709

value = getattr(options, option)

710

if value is not None:

711

server_settings[option] = value

712

del options

713

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

714

715

debug = server_settings["debug"]

716

717

if not debug:

718

syslogger.setLevel(logging.WARNING)

719

720

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

721

syslogger.setFormatter(logging.Formatter\

722

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

723

' %%(message)s'

724

% server_settings["servicename"]))

725

726

# Parse config file with clients

727

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

728

"interval": "5m",

729

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

730

}

731

client_config = ConfigParser.SafeConfigParser(client_defaults)

732

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

733

"clients.conf"))

734

735

global service

736

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

737

type = "_mandos._tcp", );

738

if server_settings["interface"]:

739

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

740

671

741

672

global main_loop

742

673

global bus

750

681

avahi.DBUS_INTERFACE_SERVER )

751

682

# End of Avahi example code

752

683

684

debug = options.debug

685

753

686

if debug:

754

687

console = logging.StreamHandler()

755

688

# console.setLevel(logging.DEBUG)

762

695

def remove_from_clients(client):

763

696

clients.remove(client)

764

697

if not clients:

765

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

766

sys.exit()

698

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

699

killme()

767

700

768

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

701

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

769

702

stop_hook = remove_from_clients,

770

config

771

= dict(client_config.items(section)))

703

**(dict(client_config\

704

.items(section))))

772

705

for section in client_config.sections()))

773

if not clients:

774

logger.critical(u"No clients defined")

775

sys.exit(1)

776

706

777

707

if not debug:

778

daemon()

779

780

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

781

pid = os.getpid()

782

try:

783

pidfile = open(pidfilename, "w")

784

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

785

pidfile.close()

786

del pidfile

787

except IOError, err:

788

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

789

pidfilename, os.getpid())

708

daemon(False, False)

790

709

791

710

def cleanup():

792

711

"Cleanup function; run on exit"

806

725

807

726

if not debug:

808

727

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

809

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

810

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

811

730

812

731

for client in clients:

813

732

client.start()

814

733

815

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

816

server_settings["port"]),

734

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

817

735

tcp_handler,

818

settings=server_settings,

736

options=options,

819

737

clients=clients)

820

# Find out what port we got

821

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

822

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

823

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

824

825

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

826

827

try:

828

# From the Avahi example code

829

server.connect_to_signal("StateChanged", server_state_changed)

830

try:

831

server_state_changed(server.GetState())

832

except dbus.exceptions.DBusException, error:

833

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

834

sys.exit(1)

835

# End of Avahi example code

836

837

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

838

lambda *args, **kwargs:

839

tcp_server.handle_request\

840

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

841

842

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

843

762

main_loop_started = True

844

763

main_loop.run()

845

except AvahiError, error:

846

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

847

sys.exit(1)

848

764

except KeyboardInterrupt:

849

765

if debug:

850

766

print

767

768

sys.exit(exitstatus)

851

769

852

770

if __name__ == '__main__':

853

771

main()