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

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

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

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

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

169

236

self.secret = sf.read()

170

237

sf.close()

171

238

else:

172

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

173

% self.name)

174

self.fqdn = fqdn # string

239

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

240

% self.name)

241

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

175

242

self.created = datetime.datetime.now()

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)

243

self.last_checked_ok = None

244

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

245

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

185

246

self.stop_hook = stop_hook

186

247

self.checker = None

187

248

self.checker_initiator_tag = None

188

249

self.stop_initiator_tag = None

189

250

self.checker_callback_tag = None

190

self.check_command = checker

251

self.check_command = config["checker"]

191

252

def start(self):

192

253

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

193

254

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

203

264

self.stop)

204

265

def stop(self):

205

266

"""Stop this client.

206

The possibility that this client might be restarted is left

207

open, but not currently used."""

267

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

268

but not currently used."""

208

269

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

209

if self.secret:

210

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)

211

272

self.secret = None

212

273

else:

213

274

return False

214

if hasattr(self, "stop_initiator_tag") \

215

and self.stop_initiator_tag:

275

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

216

276

gobject.source_remove(self.stop_initiator_tag)

217

277

self.stop_initiator_tag = None

218

if hasattr(self, "checker_initiator_tag") \

219

and self.checker_initiator_tag:

278

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

220

279

gobject.source_remove(self.checker_initiator_tag)

221

280

self.checker_initiator_tag = None

222

281

self.stop_checker()

234

293

self.checker = None

235

294

if os.WIFEXITED(condition) \

236

295

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

237

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

238

vars(self))

239

self.last_seen = now

296

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

297

vars(self))

298

self.last_checked_ok = now

240

299

gobject.source_remove(self.stop_initiator_tag)

241

300

self.stop_initiator_tag = gobject.timeout_add\

242

301

(self._timeout_milliseconds,

245

304

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

246

305

vars(self))

247

306

else:

248

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

249

vars(self))

307

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

308

vars(self))

250

309

def start_checker(self):

251

310

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

252

311

If a checker already exists, leave it running and do

261

320

# is as it should be.

262

321

if self.checker is None:

263

322

try:

264

command = self.check_command % self.fqdn

323

# In case check_command has exactly one % operator

324

command = self.check_command % self.host

265

325

except TypeError:

326

# Escape attributes for the shell

266

327

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

267

328

for key, val in

268

329

vars(self).iteritems())

269

330

try:

270

331

command = self.check_command % escaped_attrs

271

332

except TypeError, error:

272

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

273

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

333

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

334

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

274

335

return True # Try again later

275

336

try:

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

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

282

342

self.checker_callback_tag = gobject.child_watch_add\

283

343

(self.checker.pid,

284

344

self.checker_callback)

292

352

if self.checker_callback_tag:

293

353

gobject.source_remove(self.checker_callback_tag)

294

354

self.checker_callback_tag = None

295

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

355

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

296

356

return

297

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

357

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

298

358

try:

299

359

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

300

360

#os.sleep(0.5)

301

361

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

302

362

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

303

363

except OSError, error:

304

if error.errno != errno.ESRCH:

364

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

305

365

raise

306

366

self.checker = None

307

def still_valid(self, now=None):

367

def still_valid(self):

308

368

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

309

if now is None:

310

now = datetime.datetime.now()

311

if self.last_seen is None:

369

now = datetime.datetime.now()

370

if self.last_checked_ok is None:

312

371

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

313

372

else:

314

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

373

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

315

374

316

375

317

376

def peer_certificate(session):

333

392

334

393

def fingerprint(openpgp):

335

394

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

340

395

# New GnuTLS "datum" with the OpenPGP public key

341

396

datum = gnutls.library.types.gnutls_datum_t\

342

397

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

343

398

ctypes.POINTER(ctypes.c_ubyte)),

344

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

345

404

# Import the OpenPGP public key into the certificate

346

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

347

(crt,

348

ctypes.byref(datum),

349

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)

350

408

# New buffer for the fingerprint

351

409

buffer = ctypes.create_string_buffer(20)

352

410

buffer_length = ctypes.c_size_t()

368

426

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

369

427

370

428

def handle(self):

371

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

429

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

372

430

unicode(self.client_address))

373

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

374

gnutls.connection.\

375

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.

376

447

377

448

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

378

449

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

379

450

# "+DHE-DSS"))

380

priority = "SECURE256"

381

451

priority = "NORMAL" # Fallback default, since this

452

# MUST be set.

453

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

454

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

382

455

gnutls.library.functions.gnutls_priority_set_direct\

383

456

(session._c_object, priority, None);

384

457

385

458

try:

386

459

session.handshake()

387

460

except gnutls.errors.GNUTLSError, error:

388

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

461

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

389

462

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

390

463

# established. Just abandon the request.

391

464

return

392

465

try:

393

466

fpr = fingerprint(peer_certificate(session))

394

467

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

395

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

468

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

396

469

session.bye()

397

470

return

398

471

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

401

474

if c.fingerprint == fpr:

402

475

client = c

403

476

break

477

if not client:

478

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

479

fpr)

480

session.bye()

481

return

404

482

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

405

483

# that the client timed out while establishing the GnuTLS

406

484

# session.

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)

485

if not client.still_valid():

486

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

487

vars(client))

414

488

session.bye()

415

489

return

416

490

sent_size = 0

426

500

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

427

501

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

428

502

Attributes:

429

options: Command line options

503

settings: Server settings

430

504

clients: Set() of Client objects

431

505

"""

432

506

address_family = socket.AF_INET6

433

507

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

434

if "options" in kwargs:

435

self.options = kwargs["options"]

436

del kwargs["options"]

508

if "settings" in kwargs:

509

self.settings = kwargs["settings"]

510

del kwargs["settings"]

437

511

if "clients" in kwargs:

438

512

self.clients = kwargs["clients"]

439

513

del kwargs["clients"]

442

516

"""This overrides the normal server_bind() function

443

517

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

444

518

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

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

519

if self.settings["interface"]:

520

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

521

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

449

522

try:

450

523

self.socket.setsockopt(socket.SOL_SOCKET,

451

socket.SO_BINDTODEVICE,

452

self.options.interface)

524

SO_BINDTODEVICE,

525

self.settings["interface"])

453

526

except socket.error, error:

454

527

if error[0] == errno.EPERM:

455

logger.warning(u"No permission to"

456

u" bind to interface %s",

457

self.options.interface)

528

logger.error(u"No permission to"

529

u" bind to interface %s",

530

self.settings["interface"])

458

531

else:

459

532

raise error

460

533

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

463

536

in6addr_any = "::"

464

537

self.server_address = (in6addr_any,

465

538

self.server_address[1])

466

elif self.server_address[1] is None:

539

elif not self.server_address[1]:

467

540

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

468

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

469

549

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

470

550

471

551

503

583

return delta

504

584

505

585

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

539

586

def server_state_changed(state):

540

587

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

541

588

if state == avahi.SERVER_COLLISION:

542

logger.warning(u"Server name collision")

543

remove_service()

589

logger.error(u"Server name collision")

590

service.remove()

544

591

elif state == avahi.SERVER_RUNNING:

545

add_service()

592

service.add()

546

593

547

594

548

595

def entry_group_state_changed(state, error):

549

596

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

550

global serviceName, server, rename_count

551

552

597

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

553

598

554

599

if state == avahi.ENTRY_GROUP_ESTABLISHED:

555

600

logger.debug(u"Service established.")

556

601

elif state == avahi.ENTRY_GROUP_COLLISION:

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)

602

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

603

service.rename()

570

604

elif state == avahi.ENTRY_GROUP_FAILURE:

571

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

572

unicode(error))

573

killme(1)

574

605

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

606

unicode(error))

607

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

575

608

576

609

def if_nametoindex(interface):

577

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

610

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

611

global if_nametoindex

578

612

try:

579

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

580

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

581

617

except (OSError, AttributeError):

582

618

if "struct" not in sys.modules:

583

619

import struct

584

620

if "fcntl" not in sys.modules:

585

621

import fcntl

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

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

596

635

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

597

636

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

598

637

if os.fork():

600

639

os.setsid()

601

640

if not nochdir:

602

641

os.chdir("/")

642

if os.fork():

643

sys.exit()

603

644

if not noclose:

604

645

# Close all standard open file descriptors

605

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

646

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

606

647

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

607

648

raise OSError(errno.ENODEV,

608

649

"/dev/null not a character device")

613

654

os.close(null)

614

655

615

656

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

625

657

def main():

626

global exitstatus

627

exitstatus = 0

628

658

global main_loop_started

629

659

main_loop_started = False

630

660

631

parser = OptionParser()

661

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

632

662

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

633

default=None, metavar="IF",

634

help="Bind to interface IF")

635

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

636

665

help="Address to listen for requests on")

637

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

666

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

638

667

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

645

668

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

646

669

help="Run self-test")

647

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

648

help="Debug mode")

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

649

681

(options, args) = parser.parse_args()

650

682

651

683

if options.check:

653

685

doctest.testmod()

654

686

sys.exit()

655

687

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

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

671

746

672

747

global main_loop

673

748

global bus

681

756

avahi.DBUS_INTERFACE_SERVER )

682

757

# End of Avahi example code

683

758

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

694

759

clients = Set()

695

760

def remove_from_clients(client):

696

761

clients.remove(client)

697

762

if not clients:

698

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

699

killme()

763

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

764

sys.exit()

700

765

701

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

766

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

702

767

stop_hook = remove_from_clients,

703

**(dict(client_config\

704

.items(section))))

768

config

769

= dict(client_config.items(section)))

705

770

for section in client_config.sections()))

771

if not clients:

772

logger.critical(u"No clients defined")

773

sys.exit(1)

706

774

707

775

if not debug:

708

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

709

789

710

790

def cleanup():

711

791

"Cleanup function; run on exit"

725

805

726

806

if not debug:

727

807

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

728

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

729

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

730

810

731

811

for client in clients:

732

812

client.start()

733

813

734

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

814

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

815

server_settings["port"]),

735

816

tcp_handler,

736

options=options,

817

settings=server_settings,

737

818

clients=clients)

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

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

762

842

main_loop_started = True

763

843

main_loop.run()

844

except AvahiError, error:

845

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

846

sys.exit(1)

764

847

except KeyboardInterrupt:

765

848

if debug:

766

849

print

767

768

sys.exit(exitstatus)

769

850

770

851

if __name__ == '__main__':

771

852

main()