/mandos/release : revision 70

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

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 <https://www.fukt.bsnet.se/~belorn/> and

30

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

29

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

31

30

#

32

31

33

32

from __future__ import division

62

61

from dbus.mainloop.glib import DBusGMainLoop

63

62

import ctypes

64

63

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

version = "1.0"

76

65

77

66

logger = logging.Logger('mandos')

78

67

syslogger = logging.handlers.SysLogHandler\

79

(facility = logging.handlers.SysLogHandler.LOG_DAEMON)

68

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

69

address = "/dev/log")

80

70

syslogger.setFormatter(logging.Formatter\

81

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

71

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

82

72

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

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

89

162

# 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

163

group = None # our entry group

99

164

# End of Avahi example code

100

165

101

166

106

171

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

107

172

uniquely identify the client

108

173

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

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

114

179

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

115

180

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

116

181

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

117

182

to see if the client lives.

118

Is None if no process is running.

183

'None' if no process is running.

119

184

checker_initiator_tag: a gobject event source tag, or None

120

185

stop_initiator_tag: - '' -

121

186

checker_callback_tag: - '' -

122

187

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

123

client lives. %()s expansions are done at

188

client lives. %() expansions are done at

124

189

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

125

190

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

126

191

Private attibutes:

127

192

_timeout: Real variable for 'timeout'

128

193

_interval: Real variable for 'interval'

129

_timeout_milliseconds: Used by gobject.timeout_add()

194

_timeout_milliseconds: Used when calling gobject.timeout_add()

130

195

_interval_milliseconds: - '' -

131

196

"""

132

197

def _set_timeout(self, timeout):

152

217

interval = property(lambda self: self._interval,

153

218

_set_interval)

154

219

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

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

160

224

self.name = name

161

225

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

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

166

231

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

167

if secret:

168

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

169

elif secfile:

170

sf = open(secfile)

232

if "secret" in config:

233

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

234

elif "secfile" in config:

235

sf = open(config["secfile"])

171

236

self.secret = sf.read()

172

237

sf.close()

173

238

else:

174

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

175

% self.name)

176

self.fqdn = fqdn # string

239

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

240

% self.name)

241

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

177

242

self.created = datetime.datetime.now()

178

self.last_seen = None

179

self.timeout = string_to_delta(timeout)

180

self.interval = string_to_delta(interval)

243

self.last_checked_ok = None

244

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

245

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

181

246

self.stop_hook = stop_hook

182

247

self.checker = None

183

248

self.checker_initiator_tag = None

184

249

self.stop_initiator_tag = None

185

250

self.checker_callback_tag = None

186

self.check_command = checker

251

self.check_command = config["checker"]

187

252

def start(self):

188

253

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

189

254

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

199

264

self.stop)

200

265

def stop(self):

201

266

"""Stop this client.

202

The possibility that this client might be restarted is left

203

open, but not currently used."""

267

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

268

but not currently used."""

204

269

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

270

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

271

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

207

272

self.secret = None

208

273

else:

209

274

return False

210

if hasattr(self, "stop_initiator_tag") \

211

and self.stop_initiator_tag:

275

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

212

276

gobject.source_remove(self.stop_initiator_tag)

213

277

self.stop_initiator_tag = None

214

if hasattr(self, "checker_initiator_tag") \

215

and self.checker_initiator_tag:

278

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

216

279

gobject.source_remove(self.checker_initiator_tag)

217

280

self.checker_initiator_tag = None

218

281

self.stop_checker()

230

293

self.checker = None

231

294

if os.WIFEXITED(condition) \

232

295

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

233

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

234

vars(self))

235

self.last_seen = now

296

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

297

vars(self))

298

self.last_checked_ok = now

236

299

gobject.source_remove(self.stop_initiator_tag)

237

300

self.stop_initiator_tag = gobject.timeout_add\

238

301

(self._timeout_milliseconds,

241

304

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

242

305

vars(self))

243

306

else:

244

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

245

vars(self))

307

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

308

vars(self))

246

309

def start_checker(self):

247

310

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

248

311

If a checker already exists, leave it running and do

257

320

# is as it should be.

258

321

if self.checker is None:

259

322

try:

260

command = self.check_command % self.fqdn

323

# In case check_command has exactly one % operator

324

command = self.check_command % self.host

261

325

except TypeError:

326

# Escape attributes for the shell

262

327

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

263

328

for key, val in

264

329

vars(self).iteritems())

265

330

try:

266

331

command = self.check_command % escaped_attrs

267

332

except TypeError, error:

268

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

269

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

333

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

334

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

270

335

return True # Try again later

271

336

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

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

278

342

self.checker_callback_tag = gobject.child_watch_add\

279

343

(self.checker.pid,

280

344

self.checker_callback)

288

352

if self.checker_callback_tag:

289

353

gobject.source_remove(self.checker_callback_tag)

290

354

self.checker_callback_tag = None

291

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

355

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

292

356

return

293

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

357

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

294

358

try:

295

359

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

296

360

#os.sleep(0.5)

297

361

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

298

362

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

299

363

except OSError, error:

300

if error.errno != errno.ESRCH:

364

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

301

365

raise

302

366

self.checker = None

303

def still_valid(self, now=None):

367

def still_valid(self):

304

368

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

369

now = datetime.datetime.now()

370

if self.last_checked_ok is None:

308

371

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

309

372

else:

310

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

373

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

311

374

312

375

313

376

def peer_certificate(session):

329

392

330

393

def fingerprint(openpgp):

331

394

"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

395

# New GnuTLS "datum" with the OpenPGP public key

337

396

datum = gnutls.library.types.gnutls_datum_t\

338

397

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

339

398

ctypes.POINTER(ctypes.c_ubyte)),

340

399

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

341

404

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

405

gnutls.library.functions.gnutls_openpgp_crt_import\

406

(crt, ctypes.byref(datum),

407

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

346

408

# New buffer for the fingerprint

347

409

buffer = ctypes.create_string_buffer(20)

348

410

buffer_length = ctypes.c_size_t()

364

426

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

365

427

366

428

def handle(self):

367

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

429

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

368

430

unicode(self.client_address))

369

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

370

gnutls.connection.\

371

X509Credentials())

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.

372

447

373

448

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

374

449

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

375

450

# "+DHE-DSS"))

376

priority = "NORMAL"

377

if self.server.options.priority:

378

priority = self.server.options.priority

451

priority = "NORMAL" # Fallback default, since this

452

# MUST be set.

453

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

454

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

379

455

gnutls.library.functions.gnutls_priority_set_direct\

380

456

(session._c_object, priority, None);

381

457

382

458

try:

383

459

session.handshake()

384

460

except gnutls.errors.GNUTLSError, error:

385

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

461

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

386

462

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

387

463

# established. Just abandon the request.

388

464

return

389

465

try:

390

466

fpr = fingerprint(peer_certificate(session))

391

467

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

392

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

468

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

393

469

session.bye()

394

470

return

395

471

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

398

474

if c.fingerprint == fpr:

399

475

client = c

400

476

break

477

if not client:

478

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

479

fpr)

480

session.bye()

481

return

401

482

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

402

483

# that the client timed out while establishing the GnuTLS

403

484

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

485

if not client.still_valid():

486

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

487

vars(client))

411

488

session.bye()

412

489

return

413

490

sent_size = 0

423

500

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

424

501

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

425

502

Attributes:

426

options: Command line options

503

settings: Server settings

427

504

clients: Set() of Client objects

428

505

"""

429

506

address_family = socket.AF_INET6

430

507

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

431

if "options" in kwargs:

432

self.options = kwargs["options"]

433

del kwargs["options"]

508

if "settings" in kwargs:

509

self.settings = kwargs["settings"]

510

del kwargs["settings"]

434

511

if "clients" in kwargs:

435

512

self.clients = kwargs["clients"]

436

513

del kwargs["clients"]

439

516

"""This overrides the normal server_bind() function

440

517

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

441

518

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

519

if self.settings["interface"]:

520

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

521

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

446

522

try:

447

523

self.socket.setsockopt(socket.SOL_SOCKET,

448

socket.SO_BINDTODEVICE,

449

self.options.interface)

524

SO_BINDTODEVICE,

525

self.settings["interface"])

450

526

except socket.error, error:

451

527

if error[0] == errno.EPERM:

452

logger.warning(u"No permission to"

453

u" bind to interface %s",

454

self.options.interface)

528

logger.error(u"No permission to"

529

u" bind to interface %s",

530

self.settings["interface"])

455

531

else:

456

532

raise error

457

533

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

460

536

in6addr_any = "::"

461

537

self.server_address = (in6addr_any,

462

538

self.server_address[1])

463

elif self.server_address[1] is None:

539

elif not self.server_address[1]:

464

540

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

465

541

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

466

549

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

467

550

468

551

500

583

return delta

501

584

502

585

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

534

535

536

586

def server_state_changed(state):

537

587

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

538

588

if state == avahi.SERVER_COLLISION:

539

logger.warning(u"Server name collision")

540

remove_service()

589

logger.error(u"Server name collision")

590

service.remove()

541

591

elif state == avahi.SERVER_RUNNING:

542

add_service()

592

service.add()

543

593

544

594

545

595

def entry_group_state_changed(state, error):

546

596

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

547

global serviceName, server, rename_count

548

549

597

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

550

598

551

599

if state == avahi.ENTRY_GROUP_ESTABLISHED:

552

600

logger.debug(u"Service established.")

553

601

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)

602

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

603

service.rename()

567

604

elif state == avahi.ENTRY_GROUP_FAILURE:

568

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

569

unicode(error))

570

killme(1)

571

605

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

606

unicode(error))

607

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

572

608

573

609

def if_nametoindex(interface):

574

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

610

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

611

global if_nametoindex

575

612

try:

576

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

577

return libc.if_nametoindex(interface)

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

578

617

except (OSError, AttributeError):

579

618

if "struct" not in sys.modules:

580

619

import struct

581

620

if "fcntl" not in sys.modules:

582

621

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

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

593

635

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

594

636

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

595

637

if os.fork():

597

639

os.setsid()

598

640

if not nochdir:

599

641

os.chdir("/")

642

if os.fork():

643

sys.exit()

600

644

if not noclose:

601

645

# Close all standard open file descriptors

602

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

646

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

603

647

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

604

648

raise OSError(errno.ENODEV,

605

649

"/dev/null not a character device")

610

654

os.close(null)

611

655

612

656

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

657

def main():

623

global exitstatus

624

exitstatus = 0

625

658

global main_loop_started

626

659

main_loop_started = False

627

660

628

parser = OptionParser()

661

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

629

662

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,

663

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

664

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

633

665

help="Address to listen for requests on")

634

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

666

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

635

667

help="Port number to receive requests on")

636

668

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

637

669

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

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

646

681

(options, args) = parser.parse_args()

647

682

648

683

if options.check:

650

685

doctest.testmod()

651

686

sys.exit()

652

687

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;

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

664

746

665

747

global main_loop

666

748

global bus

674

756

avahi.DBUS_INTERFACE_SERVER )

675

757

# End of Avahi example code

676

758

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

759

clients = Set()

688

760

def remove_from_clients(client):

689

761

clients.remove(client)

690

762

if not clients:

691

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

692

killme()

763

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

764

sys.exit()

693

765

694

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

766

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

695

767

stop_hook = remove_from_clients,

696

**(dict(client_config\

697

.items(section))))

768

config

769

= dict(client_config.items(section)))

698

770

for section in client_config.sections()))

771

if not clients:

772

logger.critical(u"No clients defined")

773

sys.exit(1)

699

774

700

775

if not debug:

701

daemon(False, False)

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

702

789

703

790

def cleanup():

704

791

"Cleanup function; run on exit"

718

805

719

806

if not debug:

720

807

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

808

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

809

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

723

810

724

811

for client in clients:

725

812

client.start()

726

813

727

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

814

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

815

server_settings["port"]),

728

816

tcp_handler,

729

options=options,

817

settings=server_settings,

730

818

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

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

755

842

main_loop_started = True

756

843

main_loop.run()

844

except AvahiError, error:

845

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

846

sys.exit(1)

757

847

except KeyboardInterrupt:

758

848

if debug:

759

849

print

760

761

sys.exit(exitstatus)

762

850

763

851

if __name__ == '__main__':

764

852

main()