/mandos/trunk : revision 13

51

21

import signal

52

22

from sets import Set

53

23

import subprocess

54

import atexit

55

import stat

56

import logging

57

import logging.handlers

58

import pwd

59

from contextlib import closing

60

import struct

61

import fcntl

62

24

63

25

import dbus

64

import dbus.service

65

26

import gobject

66

27

import avahi

67

28

from dbus.mainloop.glib import DBusGMainLoop

68

29

import ctypes

69

import ctypes.util

70

71

try:

72

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

73

except AttributeError:

74

try:

75

from IN import SO_BINDTODEVICE

76

except ImportError:

77

# From /usr/include/asm/socket.h

78

SO_BINDTODEVICE = 25

79

80

81

version = "1.0.8"

82

83

logger = logging.Logger(u'mandos')

84

syslogger = (logging.handlers.SysLogHandler

85

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

86

address = "/dev/log"))

87

syslogger.setFormatter(logging.Formatter

88

(u'Mandos [%(process)d]: %(levelname)s:'

89

u' %(message)s'))

90

logger.addHandler(syslogger)

91

92

console = logging.StreamHandler()

93

console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'

94

u' %(levelname)s:'

95

u' %(message)s'))

96

logger.addHandler(console)

97

98

class AvahiError(Exception):

99

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

100

self.value = value

101

super(AvahiError, self).__init__(value, *args, **kwargs)

102

def __unicode__(self):

103

return unicode(repr(self.value))

104

105

class AvahiServiceError(AvahiError):

106

pass

107

108

class AvahiGroupError(AvahiError):

109

pass

110

111

112

class AvahiService(object):

113

"""An Avahi (Zeroconf) service.

114

115

Attributes:

116

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

117

Used to optionally bind to the specified interface.

118

119

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

120

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

121

port: integer; what port to announce

122

TXT: list of strings; TXT record for the service

123

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

124

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

125

max_renames: integer; maximum number of renames

126

rename_count: integer; counter so we only rename after collisions

127

a sensible number of times

128

"""

129

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

130

servicetype = None, port = None, TXT = None,

131

domain = u"", host = u"", max_renames = 32768,

132

protocol = avahi.PROTO_UNSPEC):

133

self.interface = interface

134

self.name = name

135

self.type = servicetype

136

self.port = port

137

self.TXT = TXT if TXT is not None else []

138

self.domain = domain

139

self.host = host

140

self.rename_count = 0

141

self.max_renames = max_renames

142

self.protocol = protocol

143

def rename(self):

144

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

145

if self.rename_count >= self.max_renames:

146

logger.critical(u"No suitable Zeroconf service name found"

147

u" after %i retries, exiting.",

148

self.rename_count)

149

raise AvahiServiceError(u"Too many renames")

150

self.name = server.GetAlternativeServiceName(self.name)

151

logger.info(u"Changing Zeroconf service name to %r ...",

152

self.name)

153

syslogger.setFormatter(logging.Formatter

154

(u'Mandos (%s) [%%(process)d]:'

155

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

156

% self.name))

157

self.remove()

158

self.add()

159

self.rename_count += 1

160

def remove(self):

161

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

162

if group is not None:

163

group.Reset()

164

def add(self):

165

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

166

global group

167

if group is None:

168

group = dbus.Interface(bus.get_object

169

(avahi.DBUS_NAME,

170

server.EntryGroupNew()),

171

avahi.DBUS_INTERFACE_ENTRY_GROUP)

172

group.connect_to_signal('StateChanged',

173

entry_group_state_changed)

174

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

175

service.name, service.type)

176

group.AddService(

177

self.interface, # interface

178

self.protocol, # protocol

179

dbus.UInt32(0), # flags

180

self.name, self.type,

181

self.domain, self.host,

182

dbus.UInt16(self.port),

183

avahi.string_array_to_txt_array(self.TXT))

184

group.Commit()

185

186

# From the Avahi example code:

187

group = None # our entry group

30

31

import logging

32

import logging.handlers

33

34

# logghandler.setFormatter(logging.Formatter('%(levelname)s %(message)s')

35

36

logger = logging.Logger('mandos')

37

logger.addHandler(logging.handlers.SysLogHandler(facility = logging.handlers.SysLogHandler.LOG_DAEMON))

38

39

# This variable is used to optionally bind to a specified interface.

40

# It is a global variable to fit in with the other variables from the

41

# Avahi server example code.

42

serviceInterface = avahi.IF_UNSPEC

43

# From the Avahi server example code:

44

serviceName = "Mandos"

45

serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html

46

servicePort = None # Not known at startup

47

serviceTXT = [] # TXT record for the service

48

domain = "" # Domain to publish on, default to .local

49

host = "" # Host to publish records for, default to localhost

50

group = None #our entry group

51

rename_count = 12 # Counter so we only rename after collisions a

52

# sensible number of times

188

53

# End of Avahi example code

189

54

190

55

191

def _datetime_to_dbus(dt, variant_level=0):

192

"""Convert a UTC datetime.datetime() to a D-Bus type."""

193

return dbus.String(dt.isoformat(), variant_level=variant_level)

194

195

196

56

class Client(object):

197

57

"""A representation of a client host served by this server.

198

199

58

Attributes:

200

201

D-Bus identifiers

59

202

60

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

203

61

uniquely identify the client

204

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

205

host: string; available for use by the checker command

206

created: datetime.datetime(); (UTC) object creation

207

last_enabled: datetime.datetime(); (UTC)

208

enabled: bool()

209

last_checked_ok: datetime.datetime(); (UTC) or None

210

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

211

until this client is invalid

212

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

213

disable_hook: If set, called by disable() as disable_hook(self)

214

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

215

to see if the client lives.

216

'None' if no process is running.

62

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

63

fqdn: string (FQDN); available for use by the checker command

64

created: datetime.datetime()

65

last_seen: datetime.datetime() or None if not yet seen

66

timeout: datetime.timedelta(); How long from last_seen until

67

this client is invalid

68

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

69

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

70

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

71

to see if the client lives.

72

Is None if no process is running.

217

73

checker_initiator_tag: a gobject event source tag, or None

218

disable_initiator_tag: - '' -

74

stop_initiator_tag: - '' -

219

75

checker_callback_tag: - '' -

220

76

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

221

client lives. %() expansions are done at

77

client lives. %()s expansions are done at

222

78

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

223

79

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

224

current_checker_command: string; current running checker_command

80

Private attibutes:

81

_timeout: Real variable for 'timeout'

82

_interval: Real variable for 'interval'

83

_timeout_milliseconds: Used by gobject.timeout_add()

84

_interval_milliseconds: - '' -

225

85

"""

226

227

@staticmethod

228

def _datetime_to_milliseconds(dt):

229

"Convert a datetime.datetime() to milliseconds"

230

return ((dt.days * 24 * 60 * 60 * 1000)

231

+ (dt.seconds * 1000)

232

+ (dt.microseconds // 1000))

233

234

def timeout_milliseconds(self):

235

"Return the 'timeout' attribute in milliseconds"

236

return self._datetime_to_milliseconds(self.timeout)

237

238

def interval_milliseconds(self):

239

"Return the 'interval' attribute in milliseconds"

240

return self._datetime_to_milliseconds(self.interval)

241

242

def __init__(self, name = None, disable_hook=None, config=None):

243

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

244

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

245

attribute."""

86

def _set_timeout(self, timeout):

87

"Setter function for 'timeout' attribute"

88

self._timeout = timeout

89

self._timeout_milliseconds = ((self.timeout.days

90

* 24 * 60 * 60 * 1000)

91

+ (self.timeout.seconds * 1000)

92

+ (self.timeout.microseconds

93

// 1000))

94

timeout = property(lambda self: self._timeout,

95

_set_timeout)

96

del _set_timeout

97

def _set_interval(self, interval):

98

"Setter function for 'interval' attribute"

99

self._interval = interval

100

self._interval_milliseconds = ((self.interval.days

101

* 24 * 60 * 60 * 1000)

102

+ (self.interval.seconds

103

* 1000)

104

+ (self.interval.microseconds

105

// 1000))

106

interval = property(lambda self: self._interval,

107

_set_interval)

108

del _set_interval

109

def __init__(self, name=None, options=None, stop_hook=None,

110

fingerprint=None, secret=None, secfile=None, fqdn=None,

111

timeout=None, interval=-1, checker=None):

246

112

self.name = name

247

if config is None:

248

config = {}

249

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

250

# Uppercase and remove spaces from fingerprint for later

251

# comparison purposes with return value from the fingerprint()

252

# function

253

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

254

.replace(u" ", u""))

255

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

256

if u"secret" in config:

257

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

258

elif u"secfile" in config:

259

with closing(open(os.path.expanduser

260

(os.path.expandvars

261

(config[u"secfile"])))) as secfile:

262

self.secret = secfile.read()

263

else:

264

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

265

% self.name)

266

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

267

self.created = datetime.datetime.utcnow()

268

self.enabled = False

269

self.last_enabled = None

270

self.last_checked_ok = None

271

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

272

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

273

self.disable_hook = disable_hook

113

# Uppercase and remove spaces from fingerprint

114

# for later comparison purposes with return value of

115

# the fingerprint() function

116

self.fingerprint = fingerprint.upper().replace(u" ", u"")

117

if secret:

118

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

119

elif secfile:

120

sf = open(secfile)

121

self.secret = sf.read()

122

sf.close()

123

else:

124

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

125

% self.name)

126

self.fqdn = fqdn # string

127

self.created = datetime.datetime.now()

128

self.last_seen = None

129

if timeout is None:

130

timeout = options.timeout

131

self.timeout = timeout

132

if interval == -1:

133

interval = options.interval

134

else:

135

interval = string_to_delta(interval)

136

self.interval = interval

137

self.stop_hook = stop_hook

274

138

self.checker = None

275

139

self.checker_initiator_tag = None

276

self.disable_initiator_tag = None

140

self.stop_initiator_tag = None

277

141

self.checker_callback_tag = None

278

self.checker_command = config[u"checker"]

279

self.current_checker_command = None

280

self.last_connect = None

281

282

def enable(self):

283

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

284

self.last_enabled = datetime.datetime.utcnow()

142

self.check_command = checker

143

def start(self):

144

"""Start this clients checker and timeout hooks"""

285

145

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

286

146

# and every interval from then on.

287

self.checker_initiator_tag = (gobject.timeout_add

288

(self.interval_milliseconds(),

289

self.start_checker))

147

self.checker_initiator_tag = gobject.timeout_add\

148

(self._interval_milliseconds,

149

self.start_checker)

290

150

# Also start a new checker *right now*.

291

151

self.start_checker()

292

# Schedule a disable() when 'timeout' has passed

293

self.disable_initiator_tag = (gobject.timeout_add

294

(self.timeout_milliseconds(),

295

self.disable))

296

self.enabled = True

297

298

def disable(self):

299

"""Disable this client."""

300

if not getattr(self, "enabled", False):

301

return False

302

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

303

if getattr(self, u"disable_initiator_tag", False):

304

gobject.source_remove(self.disable_initiator_tag)

305

self.disable_initiator_tag = None

306

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

152

# Schedule a stop() when 'timeout' has passed

153

self.stop_initiator_tag = gobject.timeout_add\

154

(self._timeout_milliseconds,

155

self.stop)

156

def stop(self):

157

"""Stop this client.

158

The possibility that this client might be restarted is left

159

open, but not currently used."""

160

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

161

self.secret = None

162

if self.stop_initiator_tag:

163

gobject.source_remove(self.stop_initiator_tag)

164

self.stop_initiator_tag = None

165

if self.checker_initiator_tag:

307

166

gobject.source_remove(self.checker_initiator_tag)

308

167

self.checker_initiator_tag = None

309

168

self.stop_checker()

310

if self.disable_hook:

311

self.disable_hook(self)

312

self.enabled = False

169

if self.stop_hook:

170

self.stop_hook(self)

313

171

# Do not run this again if called by a gobject.timeout_add

314

172

return False

315

316

173

def __del__(self):

317

self.disable_hook = None

318

self.disable()

319

320

def checker_callback(self, pid, condition, command):

174

# Some code duplication here and in stop()

175

if hasattr(self, "stop_initiator_tag") \

176

and self.stop_initiator_tag:

177

gobject.source_remove(self.stop_initiator_tag)

178

self.stop_initiator_tag = None

179

if hasattr(self, "checker_initiator_tag") \

180

and self.checker_initiator_tag:

181

gobject.source_remove(self.checker_initiator_tag)

182

self.checker_initiator_tag = None

183

self.stop_checker()

184

def checker_callback(self, pid, condition):

321

185

"""The checker has completed, so take appropriate actions."""

322

self.checker_callback_tag = None

323

self.checker = None

324

if os.WIFEXITED(condition):

325

exitstatus = os.WEXITSTATUS(condition)

326

if exitstatus == 0:

327

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

328

vars(self))

329

self.checked_ok()

330

else:

331

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

332

vars(self))

333

else:

186

now = datetime.datetime.now()

187

if os.WIFEXITED(condition) \

188

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

189

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

190

vars(self))

191

self.last_seen = now

192

gobject.source_remove(self.stop_initiator_tag)

193

self.stop_initiator_tag = gobject.timeout_add\

194

(self._timeout_milliseconds,

195

self.stop)

196

if not os.WIFEXITED(condition):

334

197

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

335

198

vars(self))

336

337

def checked_ok(self):

338

"""Bump up the timeout for this client.

339

340

This should only be called when the client has been seen,

341

alive and well.

342

"""

343

self.last_checked_ok = datetime.datetime.utcnow()

344

gobject.source_remove(self.disable_initiator_tag)

345

self.disable_initiator_tag = (gobject.timeout_add

346

(self.timeout_milliseconds(),

347

self.disable))

348

199

else:

200

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

201

vars(self))

202

self.checker = None

203

self.checker_callback_tag = None

349

204

def start_checker(self):

350

205

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

351

352

206

If a checker already exists, leave it running and do

353

207

nothing."""

354

# The reason for not killing a running checker is that if we

355

# did that, then if a checker (for some reason) started

356

# running slowly and taking more than 'interval' time, the

357

# client would inevitably timeout, since no checker would get

358

# a chance to run to completion. If we instead leave running

359

# checkers alone, the checker would have to take more time

360

# than 'timeout' for the client to be declared invalid, which

361

# is as it should be.

362

363

# If a checker exists, make sure it is not a zombie

364

if self.checker is not None:

365

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

366

if pid:

367

logger.warning(u"Checker was a zombie")

368

gobject.source_remove(self.checker_callback_tag)

369

self.checker_callback(pid, status,

370

self.current_checker_command)

371

# Start a new checker if needed

372

208

if self.checker is None:

209

logger.debug(u"Starting checker for %s",

210

self.name)

373

211

try:

374

# In case checker_command has exactly one % operator

375

command = self.checker_command % self.host

212

command = self.check_command % self.fqdn

376

213

except TypeError:

377

# Escape attributes for the shell

378

escaped_attrs = dict((key,

379

re.escape(unicode(str(val),

380

errors=

381

u'replace')))

214

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

382

215

for key, val in

383

216

vars(self).iteritems())

384

217

try:

385

command = self.checker_command % escaped_attrs

218

command = self.check_command % escaped_attrs

386

219

except TypeError, error:

387

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

388

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

220

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

221

self.check_command, error)

389

222

return True # Try again later

390

self.current_checker_command = command

391

223

try:

392

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

393

command, self.name)

394

# We don't need to redirect stdout and stderr, since

395

# in normal mode, that is already done by daemon(),

396

# and in debug mode we don't want to. (Stdin is

397

# always replaced by /dev/null.)

398

self.checker = subprocess.Popen(command,

399

close_fds=True,

400

shell=True, cwd=u"/")

401

self.checker_callback_tag = (gobject.child_watch_add

402

(self.checker.pid,

403

self.checker_callback,

404

data=command))

405

# The checker may have completed before the gobject

406

# watch was added. Check for this.

407

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

408

if pid:

409

gobject.source_remove(self.checker_callback_tag)

410

self.checker_callback(pid, status, command)

411

except OSError, error:

224

self.checker = subprocess.\

225

Popen(command,

226

stdout=subprocess.PIPE,

227

close_fds=True, shell=True,

228

cwd="/")

229

self.checker_callback_tag = gobject.\

230

child_watch_add(self.checker.pid,

231

self.\

232

checker_callback)

233

except subprocess.OSError, error:

412

234

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

413

235

error)

414

236

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

415

237

return True

416

417

238

def stop_checker(self):

418

239

"""Force the checker process, if any, to stop."""

419

if self.checker_callback_tag:

420

gobject.source_remove(self.checker_callback_tag)

421

self.checker_callback_tag = None

422

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

240

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

423

241

return

424

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

425

try:

426

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

427

#os.sleep(0.5)

428

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

429

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

430

except OSError, error:

431

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

432

raise

242

gobject.source_remove(self.checker_callback_tag)

243

self.checker_callback_tag = None

244

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

245

if self.checker.poll() is None:

246

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

433

247

self.checker = None

434

435

def still_valid(self):

248

def still_valid(self, now=None):

436

249

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

437

if not getattr(self, u"enabled", False):

438

return False

439

now = datetime.datetime.utcnow()

440

if self.last_checked_ok is None:

250

if now is None:

251

now = datetime.datetime.now()

252

if self.last_seen is None:

441

253

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

442

254

else:

443

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

444

445

446

class ClientDBus(Client, dbus.service.Object):

447

"""A Client class using D-Bus

448

449

Attributes:

450

dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus

451

"""

452

# dbus.service.Object doesn't use super(), so we can't either.

453

454

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

455

Client.__init__(self, *args, **kwargs)

456

# Only now, when this client is initialized, can it show up on

457

# the D-Bus

458

self.dbus_object_path = (dbus.ObjectPath

459

(u"/clients/"

460

+ self.name.replace(u".", u"_")))

461

dbus.service.Object.__init__(self, bus,

462

self.dbus_object_path)

463

def enable(self):

464

oldstate = getattr(self, u"enabled", False)

465

r = Client.enable(self)

466

if oldstate != self.enabled:

467

# Emit D-Bus signals

468

self.PropertyChanged(dbus.String(u"enabled"),

469

dbus.Boolean(True, variant_level=1))

470

self.PropertyChanged(dbus.String(u"last_enabled"),

471

(_datetime_to_dbus(self.last_enabled,

472

variant_level=1)))

473

return r

474

475

def disable(self, signal = True):

476

oldstate = getattr(self, u"enabled", False)

477

r = Client.disable(self)

478

if signal and oldstate != self.enabled:

479

# Emit D-Bus signal

480

self.PropertyChanged(dbus.String(u"enabled"),

481

dbus.Boolean(False, variant_level=1))

482

return r

483

484

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

485

try:

486

self.remove_from_connection()

487

except LookupError:

488

pass

489

if hasattr(dbus.service.Object, u"__del__"):

490

dbus.service.Object.__del__(self, *args, **kwargs)

491

Client.__del__(self, *args, **kwargs)

492

493

def checker_callback(self, pid, condition, command,

494

*args, **kwargs):

495

self.checker_callback_tag = None

496

self.checker = None

497

# Emit D-Bus signal

498

self.PropertyChanged(dbus.String(u"checker_running"),

499

dbus.Boolean(False, variant_level=1))

500

if os.WIFEXITED(condition):

501

exitstatus = os.WEXITSTATUS(condition)

502

# Emit D-Bus signal

503

self.CheckerCompleted(dbus.Int16(exitstatus),

504

dbus.Int64(condition),

505

dbus.String(command))

506

else:

507

# Emit D-Bus signal

508

self.CheckerCompleted(dbus.Int16(-1),

509

dbus.Int64(condition),

510

dbus.String(command))

511

512

return Client.checker_callback(self, pid, condition, command,

513

*args, **kwargs)

514

515

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

516

r = Client.checked_ok(self, *args, **kwargs)

517

# Emit D-Bus signal

518

self.PropertyChanged(

519

dbus.String(u"last_checked_ok"),

520

(_datetime_to_dbus(self.last_checked_ok,

521

variant_level=1)))

522

return r

523

524

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

525

old_checker = self.checker

526

if self.checker is not None:

527

old_checker_pid = self.checker.pid

528

else:

529

old_checker_pid = None

530

r = Client.start_checker(self, *args, **kwargs)

531

# Only if new checker process was started

532

if (self.checker is not None

533

and old_checker_pid != self.checker.pid):

534

# Emit D-Bus signal

535

self.CheckerStarted(self.current_checker_command)

536

self.PropertyChanged(

537

dbus.String(u"checker_running"),

538

dbus.Boolean(True, variant_level=1))

539

return r

540

541

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

542

old_checker = getattr(self, u"checker", None)

543

r = Client.stop_checker(self, *args, **kwargs)

544

if (old_checker is not None

545

and getattr(self, u"checker", None) is None):

546

self.PropertyChanged(dbus.String(u"checker_running"),

547

dbus.Boolean(False, variant_level=1))

548

return r

549

550

## D-Bus methods & signals

551

_interface = u"se.bsnet.fukt.Mandos.Client"

552

553

# CheckedOK - method

554

@dbus.service.method(_interface)

555

def CheckedOK(self):

556

return self.checked_ok()

557

558

# CheckerCompleted - signal

559

@dbus.service.signal(_interface, signature=u"nxs")

560

def CheckerCompleted(self, exitcode, waitstatus, command):

561

"D-Bus signal"

562

pass

563

564

# CheckerStarted - signal

565

@dbus.service.signal(_interface, signature=u"s")

566

def CheckerStarted(self, command):

567

"D-Bus signal"

568

pass

569

570

# GetAllProperties - method

571

@dbus.service.method(_interface, out_signature=u"a{sv}")

572

def GetAllProperties(self):

573

"D-Bus method"

574

return dbus.Dictionary({

575

dbus.String(u"name"):

576

dbus.String(self.name, variant_level=1),

577

dbus.String(u"fingerprint"):

578

dbus.String(self.fingerprint, variant_level=1),

579

dbus.String(u"host"):

580

dbus.String(self.host, variant_level=1),

581

dbus.String(u"created"):

582

_datetime_to_dbus(self.created, variant_level=1),

583

dbus.String(u"last_enabled"):

584

(_datetime_to_dbus(self.last_enabled,

585

variant_level=1)

586

if self.last_enabled is not None

587

else dbus.Boolean(False, variant_level=1)),

588

dbus.String(u"enabled"):

589

dbus.Boolean(self.enabled, variant_level=1),

590

dbus.String(u"last_checked_ok"):

591

(_datetime_to_dbus(self.last_checked_ok,

592

variant_level=1)

593

if self.last_checked_ok is not None

594

else dbus.Boolean (False, variant_level=1)),

595

dbus.String(u"timeout"):

596

dbus.UInt64(self.timeout_milliseconds(),

597

variant_level=1),

598

dbus.String(u"interval"):

599

dbus.UInt64(self.interval_milliseconds(),

600

variant_level=1),

601

dbus.String(u"checker"):

602

dbus.String(self.checker_command,

603

variant_level=1),

604

dbus.String(u"checker_running"):

605

dbus.Boolean(self.checker is not None,

606

variant_level=1),

607

dbus.String(u"object_path"):

608

dbus.ObjectPath(self.dbus_object_path,

609

variant_level=1)

610

}, signature=u"sv")

611

612

# IsStillValid - method

613

@dbus.service.method(_interface, out_signature=u"b")

614

def IsStillValid(self):

615

return self.still_valid()

616

617

# PropertyChanged - signal

618

@dbus.service.signal(_interface, signature=u"sv")

619

def PropertyChanged(self, property, value):

620

"D-Bus signal"

621

pass

622

623

# ReceivedSecret - signal

624

@dbus.service.signal(_interface)

625

def ReceivedSecret(self):

626

"D-Bus signal"

627

pass

628

629

# Rejected - signal

630

@dbus.service.signal(_interface)

631

def Rejected(self):

632

"D-Bus signal"

633

pass

634

635

# SetChecker - method

636

@dbus.service.method(_interface, in_signature=u"s")

637

def SetChecker(self, checker):

638

"D-Bus setter method"

639

self.checker_command = checker

640

# Emit D-Bus signal

641

self.PropertyChanged(dbus.String(u"checker"),

642

dbus.String(self.checker_command,

643

variant_level=1))

644

645

# SetHost - method

646

@dbus.service.method(_interface, in_signature=u"s")

647

def SetHost(self, host):

648

"D-Bus setter method"

649

self.host = host

650

# Emit D-Bus signal

651

self.PropertyChanged(dbus.String(u"host"),

652

dbus.String(self.host, variant_level=1))

653

654

# SetInterval - method

655

@dbus.service.method(_interface, in_signature=u"t")

656

def SetInterval(self, milliseconds):

657

self.interval = datetime.timedelta(0, 0, 0, milliseconds)

658

# Emit D-Bus signal

659

self.PropertyChanged(dbus.String(u"interval"),

660

(dbus.UInt64(self.interval_milliseconds(),

661

variant_level=1)))

662

663

# SetSecret - method

664

@dbus.service.method(_interface, in_signature=u"ay",

665

byte_arrays=True)

666

def SetSecret(self, secret):

667

"D-Bus setter method"

668

self.secret = str(secret)

669

670

# SetTimeout - method

671

@dbus.service.method(_interface, in_signature=u"t")

672

def SetTimeout(self, milliseconds):

673

self.timeout = datetime.timedelta(0, 0, 0, milliseconds)

674

# Emit D-Bus signal

675

self.PropertyChanged(dbus.String(u"timeout"),

676

(dbus.UInt64(self.timeout_milliseconds(),

677

variant_level=1)))

678

679

# Enable - method

680

@dbus.service.method(_interface)

681

def Enable(self):

682

"D-Bus method"

683

self.enable()

684

685

# StartChecker - method

686

@dbus.service.method(_interface)

687

def StartChecker(self):

688

"D-Bus method"

689

self.start_checker()

690

691

# Disable - method

692

@dbus.service.method(_interface)

693

def Disable(self):

694

"D-Bus method"

695

self.disable()

696

697

# StopChecker - method

698

@dbus.service.method(_interface)

699

def StopChecker(self):

700

self.stop_checker()

701

702

del _interface

703

704

705

class ClientHandler(SocketServer.BaseRequestHandler, object):

706

"""A class to handle client connections.

707

708

Instantiated once for each connection to handle it.

255

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

256

257

258

def peer_certificate(session):

259

# If not an OpenPGP certificate...

260

if gnutls.library.functions.gnutls_certificate_type_get\

261

(session._c_object) \

262

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:

263

# ...do the normal thing

264

return session.peer_certificate

265

list_size = ctypes.c_uint()

266

cert_list = gnutls.library.functions.gnutls_certificate_get_peers\

267

(session._c_object, ctypes.byref(list_size))

268

if list_size.value == 0:

269

return None

270

cert = cert_list[0]

271

return ctypes.string_at(cert.data, cert.size)

272

273

274

def fingerprint(openpgp):

275

# New empty GnuTLS certificate

276

crt = gnutls.library.types.gnutls_openpgp_crt_t()

277

gnutls.library.functions.gnutls_openpgp_crt_init\

278

(ctypes.byref(crt))

279

# New GnuTLS "datum" with the OpenPGP public key

280

datum = gnutls.library.types.gnutls_datum_t\

281

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

282

ctypes.POINTER(ctypes.c_ubyte)),

283

ctypes.c_uint(len(openpgp)))

284

# Import the OpenPGP public key into the certificate

285

ret = gnutls.library.functions.gnutls_openpgp_crt_import\

286

(crt,

287

ctypes.byref(datum),

288

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

289

# New buffer for the fingerprint

290

buffer = ctypes.create_string_buffer(20)

291

buffer_length = ctypes.c_size_t()

292

# Get the fingerprint from the certificate into the buffer

293

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\

294

(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))

295

# Deinit the certificate

296

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

297

# Convert the buffer to a Python bytestring

298

fpr = ctypes.string_at(buffer, buffer_length.value)

299

# Convert the bytestring to hexadecimal notation

300

hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)

301

return hex_fpr

302

303

304

class tcp_handler(SocketServer.BaseRequestHandler, object):

305

"""A TCP request handler class.

306

Instantiated by IPv6_TCPServer for each request to handle it.

709

307

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

710

308

711

309

def handle(self):

712

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

713

unicode(self.client_address))

714

logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])

715

# Open IPC pipe to parent process

716

with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:

717

session = (gnutls.connection

718

.ClientSession(self.request,

719

gnutls.connection

720

.X509Credentials()))

721

722

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

723

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

724

try:

725

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

726

raise RuntimeError

727

except (ValueError, IndexError, RuntimeError), error:

728

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

729

return

730

731

# Note: gnutls.connection.X509Credentials is really a

732

# generic GnuTLS certificate credentials object so long as

733

# no X.509 keys are added to it. Therefore, we can use it

734

# here despite using OpenPGP certificates.

735

736

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

737

# u"+AES-256-CBC", u"+SHA1",

738

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

739

# u"+DHE-DSS"))

740

# Use a fallback default, since this MUST be set.

741

priority = self.server.gnutls_priority

742

if priority is None:

743

priority = u"NORMAL"

744

(gnutls.library.functions

745

.gnutls_priority_set_direct(session._c_object,

746

priority, None))

747

748

try:

749

session.handshake()

750

except gnutls.errors.GNUTLSError, error:

751

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

752

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

753

# established. Just abandon the request.

754

return

755

logger.debug(u"Handshake succeeded")

756

try:

757

fpr = self.fingerprint(self.peer_certificate(session))

758

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

759

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

760

session.bye()

761

return

762

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

763

764

for c in self.server.clients:

765

if c.fingerprint == fpr:

766

client = c

767

break

310

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

311

unicode(self.client_address))

312

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

313

gnutls.connection.\

314

X509Credentials())

315

316

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

317

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

318

# "+DHE-DSS"))

319

priority = "SECURE256"

320

321

gnutls.library.functions.gnutls_priority_set_direct\

322

(session._c_object, priority, None);

323

324

try:

325

session.handshake()

326

except gnutls.errors.GNUTLSError, error:

327

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

328

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

329

# established. Just abandon the request.

330

return

331

try:

332

fpr = fingerprint(peer_certificate(session))

333

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

334

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

335

session.bye()

336

return

337

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

338

client = None

339

for c in clients:

340

if c.fingerprint == fpr:

341

client = c

342

break

343

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

344

# that the client timed out while establishing the GnuTLS

345

# session.

346

if (not client) or (not client.still_valid()):

347

if client:

348

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

349

vars(client))

768

350

else:

769

ipc.write(u"NOTFOUND %s\n" % fpr)

770

session.bye()

771

return

772

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

773

# possible that the client timed out while establishing

774

# the GnuTLS session.

775

if not client.still_valid():

776

ipc.write(u"INVALID %s\n" % client.name)

777

session.bye()

778

return

779

ipc.write(u"SENDING %s\n" % client.name)

780

sent_size = 0

781

while sent_size < len(client.secret):

782

sent = session.send(client.secret[sent_size:])

783

logger.debug(u"Sent: %d, remaining: %d",

784

sent, len(client.secret)

785

- (sent_size + sent))

786

sent_size += sent

351

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

352

fpr)

787

353

session.bye()

788

789

@staticmethod

790

def peer_certificate(session):

791

"Return the peer's OpenPGP certificate as a bytestring"

792

# If not an OpenPGP certificate...

793

if (gnutls.library.functions

794

.gnutls_certificate_type_get(session._c_object)

795

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

796

# ...do the normal thing

797

return session.peer_certificate

798

list_size = ctypes.c_uint(1)

799

cert_list = (gnutls.library.functions

800

.gnutls_certificate_get_peers

801

(session._c_object, ctypes.byref(list_size)))

802

if not bool(cert_list) and list_size.value != 0:

803

raise gnutls.errors.GNUTLSError(u"error getting peer"

804

u" certificate")

805

if list_size.value == 0:

806

return None

807

cert = cert_list[0]

808

return ctypes.string_at(cert.data, cert.size)

809

810

@staticmethod

811

def fingerprint(openpgp):

812

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

813

# New GnuTLS "datum" with the OpenPGP public key

814

datum = (gnutls.library.types

815

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

816

ctypes.POINTER

817

(ctypes.c_ubyte)),

818

ctypes.c_uint(len(openpgp))))

819

# New empty GnuTLS certificate

820

crt = gnutls.library.types.gnutls_openpgp_crt_t()

821

(gnutls.library.functions

822

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

823

# Import the OpenPGP public key into the certificate

824

(gnutls.library.functions

825

.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),

826

gnutls.library.constants

827

.GNUTLS_OPENPGP_FMT_RAW))

828

# Verify the self signature in the key

829

crtverify = ctypes.c_uint()

830

(gnutls.library.functions

831

.gnutls_openpgp_crt_verify_self(crt, 0,

832

ctypes.byref(crtverify)))

833

if crtverify.value != 0:

834

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

835

raise (gnutls.errors.CertificateSecurityError

836

(u"Verify failed"))

837

# New buffer for the fingerprint

838

buf = ctypes.create_string_buffer(20)

839

buf_len = ctypes.c_size_t()

840

# Get the fingerprint from the certificate into the buffer

841

(gnutls.library.functions

842

.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),

843

ctypes.byref(buf_len)))

844

# Deinit the certificate

845

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

846

# Convert the buffer to a Python bytestring

847

fpr = ctypes.string_at(buf, buf_len.value)

848

# Convert the bytestring to hexadecimal notation

849

hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)

850

return hex_fpr

851

852

853

class ForkingMixInWithPipe(SocketServer.ForkingMixIn, object):

854

"""Like SocketServer.ForkingMixIn, but also pass a pipe.

855

856

Assumes a gobject.MainLoop event loop.

857

"""

858

def process_request(self, request, client_address):

859

"""Overrides and wraps the original process_request().

860

861

This function creates a new pipe in self.pipe

862

"""

863

self.pipe = os.pipe()

864

super(ForkingMixInWithPipe,

865

self).process_request(request, client_address)

866

os.close(self.pipe[1]) # close write end

867

# Call "handle_ipc" for both data and EOF events

868

gobject.io_add_watch(self.pipe[0],

869

gobject.IO_IN | gobject.IO_HUP,

870

self.handle_ipc)

871

def handle_ipc(source, condition):

872

"""Dummy function; override as necessary"""

873

os.close(source)

874

return False

875

876

877

class IPv6_TCPServer(ForkingMixInWithPipe,

878

SocketServer.TCPServer, object):

879

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

880

354

return

355

sent_size = 0

356

while sent_size < len(client.secret):

357

sent = session.send(client.secret[sent_size:])

358

logger.debug(u"Sent: %d, remaining: %d",

359

sent, len(client.secret)

360

- (sent_size + sent))

361

sent_size += sent

362

session.bye()

363

364

365

class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):

366

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

881

367

Attributes:

882

enabled: Boolean; whether this server is activated yet

883

interface: None or a network interface name (string)

884

use_ipv6: Boolean; to use IPv6 or not

885

----

368

options: Command line options

886

369

clients: Set() of Client objects

887

gnutls_priority GnuTLS priority string

888

use_dbus: Boolean; to emit D-Bus signals or not

889

370

"""

890

def __init__(self, server_address, RequestHandlerClass,

891

interface=None, use_ipv6=True, clients=None,

892

gnutls_priority=None, use_dbus=True):

893

self.enabled = False

894

self.interface = interface

895

if use_ipv6:

896

self.address_family = socket.AF_INET6

897

self.clients = clients

898

self.use_dbus = use_dbus

899

self.gnutls_priority = gnutls_priority

900

SocketServer.TCPServer.__init__(self, server_address,

901

RequestHandlerClass)

371

address_family = socket.AF_INET6

372

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

373

if "options" in kwargs:

374

self.options = kwargs["options"]

375

del kwargs["options"]

376

if "clients" in kwargs:

377

self.clients = kwargs["clients"]

378

del kwargs["clients"]

379

return super(type(self), self).__init__(*args, **kwargs)

902

380

def server_bind(self):

903

381

"""This overrides the normal server_bind() function

904

382

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

905

383

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

906

if self.interface is not None:

384

if self.options.interface:

385

if not hasattr(socket, "SO_BINDTODEVICE"):

386

# From /usr/include/asm-i486/socket.h

387

socket.SO_BINDTODEVICE = 25

907

388

try:

908

389

self.socket.setsockopt(socket.SOL_SOCKET,

909

SO_BINDTODEVICE,

910

str(self.interface + u'\0'))

390

socket.SO_BINDTODEVICE,

391

self.options.interface)

911

392

except socket.error, error:

912

393

if error[0] == errno.EPERM:

913

logger.error(u"No permission to"

914

u" bind to interface %s",

915

self.interface)

394

logger.warning(u"No permission to"

395

u" bind to interface %s",

396

self.options.interface)

916

397

else:

917

raise

398

raise error

918

399

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

919

400

if self.server_address[0] or self.server_address[1]:

920

401

if not self.server_address[0]:

921

if self.address_family == socket.AF_INET6:

922

any_address = u"::" # in6addr_any

923

else:

924

any_address = socket.INADDR_ANY

925

self.server_address = (any_address,

402

in6addr_any = "::"

403

self.server_address = (in6addr_any,

926

404

self.server_address[1])

927

elif not self.server_address[1]:

405

elif self.server_address[1] is None:

928

406

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

929

407

0)

930

# if self.interface:

931

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

932

# 0, # port

933

# 0, # flowinfo

934

# if_nametoindex

935

# (self.interface))

936

return SocketServer.TCPServer.server_bind(self)

937

def server_activate(self):

938

if self.enabled:

939

return SocketServer.TCPServer.server_activate(self)

940

def enable(self):

941

self.enabled = True

942

def handle_ipc(self, source, condition, file_objects={}):

943

condition_names = {

944

gobject.IO_IN: u"IN", # There is data to read.

945

gobject.IO_OUT: u"OUT", # Data can be written (without

946

# blocking).

947

gobject.IO_PRI: u"PRI", # There is urgent data to read.

948

gobject.IO_ERR: u"ERR", # Error condition.

949

gobject.IO_HUP: u"HUP" # Hung up (the connection has been

950

# broken, usually for pipes and

951

# sockets).

952

}

953

conditions_string = ' | '.join(name

954

for cond, name in

955

condition_names.iteritems()

956

if cond & condition)

957

logger.debug(u"Handling IPC: FD = %d, condition = %s", source,

958

conditions_string)

959

960

# Turn the pipe file descriptor into a Python file object

961

if source not in file_objects:

962

file_objects[source] = os.fdopen(source, u"r", 1)

963

964

# Read a line from the file object

965

cmdline = file_objects[source].readline()

966

if not cmdline: # Empty line means end of file

967

# close the IPC pipe

968

file_objects[source].close()

969

del file_objects[source]

970

971

# Stop calling this function

972

return False

973

974

logger.debug(u"IPC command: %r", cmdline)

975

976

# Parse and act on command

977

cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)

978

979

if cmd == u"NOTFOUND":

980

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

981

args)

982

if self.use_dbus:

983

# Emit D-Bus signal

984

mandos_dbus_service.ClientNotFound(args)

985

elif cmd == u"INVALID":

986

for client in self.clients:

987

if client.name == args:

988

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

989

if self.use_dbus:

990

# Emit D-Bus signal

991

client.Rejected()

992

break

993

else:

994

logger.error(u"Unknown client %s is invalid", args)

995

elif cmd == u"SENDING":

996

for client in self.clients:

997

if client.name == args:

998

logger.info(u"Sending secret to %s", client.name)

999

client.checked_ok()

1000

if self.use_dbus:

1001

# Emit D-Bus signal

1002

client.ReceivedSecret()

1003

break

1004

else:

1005

logger.error(u"Sending secret to unknown client %s",

1006

args)

1007

else:

1008

logger.error(u"Unknown IPC command: %r", cmdline)

1009

1010

# Keep calling this function

1011

return True

408

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

1012

409

1013

410

1014

411

def string_to_delta(interval):

1015

412

"""Parse a string and return a datetime.timedelta

1016

1017

>>> string_to_delta(u'7d')

413

414

>>> string_to_delta('7d')

1018

415

datetime.timedelta(7)

1019

>>> string_to_delta(u'60s')

416

>>> string_to_delta('60s')

1020

417

datetime.timedelta(0, 60)

1021

>>> string_to_delta(u'60m')

418

>>> string_to_delta('60m')

1022

419

datetime.timedelta(0, 3600)

1023

>>> string_to_delta(u'24h')

420

>>> string_to_delta('24h')

1024

421

datetime.timedelta(1)

1025

422

>>> string_to_delta(u'1w')

1026

423

datetime.timedelta(7)

1027

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

1028

datetime.timedelta(0, 330)

1029

424

"""

1030

timevalue = datetime.timedelta(0)

1031

for s in interval.split():

1032

try:

1033

suffix = unicode(s[-1])

1034

value = int(s[:-1])

1035

if suffix == u"d":

1036

delta = datetime.timedelta(value)

1037

elif suffix == u"s":

1038

delta = datetime.timedelta(0, value)

1039

elif suffix == u"m":

1040

delta = datetime.timedelta(0, 0, 0, 0, value)

1041

elif suffix == u"h":

1042

delta = datetime.timedelta(0, 0, 0, 0, 0, value)

1043

elif suffix == u"w":

1044

delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

1045

else:

1046

raise ValueError

1047

except (ValueError, IndexError):

425

try:

426

suffix=unicode(interval[-1])

427

value=int(interval[:-1])

428

if suffix == u"d":

429

delta = datetime.timedelta(value)

430

elif suffix == u"s":

431

delta = datetime.timedelta(0, value)

432

elif suffix == u"m":

433

delta = datetime.timedelta(0, 0, 0, 0, value)

434

elif suffix == u"h":

435

delta = datetime.timedelta(0, 0, 0, 0, 0, value)

436

elif suffix == u"w":

437

delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

438

else:

1048

439

raise ValueError

1049

timevalue += delta

1050

return timevalue

440

except (ValueError, IndexError):

441

raise ValueError

442

return delta

443

444

445

def add_service():

446

"""From the Avahi server example code"""

447

global group, serviceName, serviceType, servicePort, serviceTXT, \

448

domain, host

449

if group is None:

450

group = dbus.Interface(

451

bus.get_object( avahi.DBUS_NAME,

452

server.EntryGroupNew()),

453

avahi.DBUS_INTERFACE_ENTRY_GROUP)

454

group.connect_to_signal('StateChanged',

455

entry_group_state_changed)

456

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

457

serviceName, serviceType)

458

459

group.AddService(

460

serviceInterface, # interface

461

avahi.PROTO_INET6, # protocol

462

dbus.UInt32(0), # flags

463

serviceName, serviceType,

464

domain, host,

465

dbus.UInt16(servicePort),

466

avahi.string_array_to_txt_array(serviceTXT))

467

group.Commit()

468

469

470

def remove_service():

471

"""From the Avahi server example code"""

472

global group

473

474

if not group is None:

475

group.Reset()

1051

476

1052

477

1053

478

def server_state_changed(state):

1054

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

479

"""From the Avahi server example code"""

1055

480

if state == avahi.SERVER_COLLISION:

1056

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

1057

service.remove()

481

logger.warning(u"Server name collision")

482

remove_service()

1058

483

elif state == avahi.SERVER_RUNNING:

1059

service.add()

484

add_service()

1060

485

1061

486

1062

487

def entry_group_state_changed(state, error):

1063

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

1064

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

488

"""From the Avahi server example code"""

489

global serviceName, server, rename_count

490

491

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

1065

492

1066

493

if state == avahi.ENTRY_GROUP_ESTABLISHED:

1067

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

494

logger.debug(u"Service established.")

1068

495

elif state == avahi.ENTRY_GROUP_COLLISION:

1069

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

1070

service.rename()

496

497

rename_count = rename_count - 1

498

if rename_count > 0:

499

name = server.GetAlternativeServiceName(name)

500

logger.warning(u"Service name collision, "

501

u"changing name to '%s' ...", name)

502

remove_service()

503

add_service()

504

505

else:

506

logger.error(u"No suitable service name found "

507

u"after %i retries, exiting.",

508

n_rename)

509

main_loop.quit()

1071

510

elif state == avahi.ENTRY_GROUP_FAILURE:

1072

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

1073

unicode(error))

1074

raise AvahiGroupError(u"State changed: %s" % unicode(error))

511

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

512

unicode(error))

513

main_loop.quit()

514

return

515

1075

516

1076

517

def if_nametoindex(interface):

1077

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

1078

1079

Note: This function cannot accept a unicode string."""

1080

global if_nametoindex

518

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

1081

519

try:

1082

if_nametoindex = (ctypes.cdll.LoadLibrary

1083

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

1084

.if_nametoindex)

520

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

521

return libc.if_nametoindex(interface)

1085

522

except (OSError, AttributeError):

1086

logger.warning(u"Doing if_nametoindex the hard way")

1087

def if_nametoindex(interface):

1088

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

1089

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

1090

with closing(socket.socket()) as s:

1091

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1092

struct.pack(str(u"16s16x"),

1093

interface))

1094

interface_index = struct.unpack(str(u"I"),

1095

ifreq[16:20])[0]

1096

return interface_index

1097

return if_nametoindex(interface)

1098

1099

1100

def daemon(nochdir = False, noclose = False):

1101

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

1102

1103

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

1104

if os.fork():

1105

sys.exit()

1106

os.setsid()

1107

if not nochdir:

1108

os.chdir(u"/")

1109

if os.fork():

1110

sys.exit()

1111

if not noclose:

1112

# Close all standard open file descriptors

1113

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

1114

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

1115

raise OSError(errno.ENODEV,

1116

u"/dev/null not a character device")

1117

os.dup2(null, sys.stdin.fileno())

1118

os.dup2(null, sys.stdout.fileno())

1119

os.dup2(null, sys.stderr.fileno())

1120

if null > 2:

1121

os.close(null)

1122

1123

1124

def main():

1125

1126

######################################################################

1127

# Parsing of options, both command line and config file

1128

1129

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

1130

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

1131

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

1132

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

1133

help=u"Address to listen for requests on")

1134

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

1135

help=u"Port number to receive requests on")

1136

parser.add_option("--check", action=u"store_true",

1137

help=u"Run self-test")

1138

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

1139

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

1140

u" terminal")

1141

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

1142

u" priority string (see GnuTLS documentation)")

1143

parser.add_option("--servicename", type=u"string",

1144

metavar=u"NAME", help=u"Zeroconf service name")

1145

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

1146

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

1147

help=u"Directory to search for configuration"

1148

u" files")

1149

parser.add_option("--no-dbus", action=u"store_false",

1150

dest=u"use_dbus", help=u"Do not provide D-Bus"

1151

u" system bus interface")

1152

parser.add_option("--no-ipv6", action=u"store_false",

1153

dest=u"use_ipv6", help=u"Do not use IPv6")

1154

options = parser.parse_args()[0]

523

if "struct" not in sys.modules:

524

import struct

525

if "fcntl" not in sys.modules:

526

import fcntl

527

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

528

s = socket.socket()

529

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

530

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

531

s.close()

532

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

533

return interface_index

534

535

536

if __name__ == '__main__':

537

parser = OptionParser()

538

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

539

default=None, metavar="IF",

540

help="Bind to interface IF")

541

parser.add_option("--cert", type="string", default="cert.pem",

542

metavar="FILE",

543

help="Public key certificate PEM file to use")

544

parser.add_option("--key", type="string", default="key.pem",

545

metavar="FILE",

546

help="Private key PEM file to use")

547

parser.add_option("--ca", type="string", default="ca.pem",

548

metavar="FILE",

549

help="Certificate Authority certificate PEM file to use")

550

parser.add_option("--crl", type="string", default="crl.pem",

551

metavar="FILE",

552

help="Certificate Revokation List PEM file to use")

553

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

554

help="Port number to receive requests on")

555

parser.add_option("--timeout", type="string", # Parsed later

556

default="1h",

557

help="Amount of downtime allowed for clients")

558

parser.add_option("--interval", type="string", # Parsed later

559

default="5m",

560

help="How often to check that a client is up")

561

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

562

help="Run self-test")

563

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

564

help="Debug mode")

565

(options, args) = parser.parse_args()

1155

566

1156

567

if options.check:

1157

568

import doctest

1158

569

doctest.testmod()

1159

570

sys.exit()

1160

571

1161

# Default values for config file for server-global settings

1162

server_defaults = { u"interface": u"",

1163

u"address": u"",

1164

u"port": u"",

1165

u"debug": u"False",

1166

u"priority":

1167

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

1168

u"servicename": u"Mandos",

1169

u"use_dbus": u"True",

1170

u"use_ipv6": u"True",

1171

}

1172

1173

# Parse config file for server-global settings

1174

server_config = ConfigParser.SafeConfigParser(server_defaults)

1175

del server_defaults

1176

server_config.read(os.path.join(options.configdir,

1177

u"mandos.conf"))

1178

# Convert the SafeConfigParser object to a dict

1179

server_settings = server_config.defaults()

1180

# Use the appropriate methods on the non-string config options

1181

for option in (u"debug", u"use_dbus", u"use_ipv6"):

1182

server_settings[option] = server_config.getboolean(u"DEFAULT",

1183

option)

1184

if server_settings["port"]:

1185

server_settings["port"] = server_config.getint(u"DEFAULT",

1186

u"port")

1187

del server_config

1188

1189

# Override the settings from the config file with command line

1190

# options, if set.

1191

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

1192

u"priority", u"servicename", u"configdir",

1193

u"use_dbus", u"use_ipv6"):

1194

value = getattr(options, option)

1195

if value is not None:

1196

server_settings[option] = value

1197

del options

1198

# Force all strings to be unicode

1199

for option in server_settings.keys():

1200

if type(server_settings[option]) is str:

1201

server_settings[option] = unicode(server_settings[option])

1202

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

1203

1204

##################################################################

1205

1206

# For convenience

1207

debug = server_settings[u"debug"]

1208

use_dbus = server_settings[u"use_dbus"]

1209

use_ipv6 = server_settings[u"use_ipv6"]

1210

1211

if not debug:

1212

syslogger.setLevel(logging.WARNING)

1213

console.setLevel(logging.WARNING)

1214

1215

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

1216

syslogger.setFormatter(logging.Formatter

1217

(u'Mandos (%s) [%%(process)d]:'

1218

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

1219

% server_settings[u"servicename"]))

1220

1221

# Parse config file with clients

1222

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

1223

u"interval": u"5m",

1224

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

1225

u"host": u"",

1226

}

1227

client_config = ConfigParser.SafeConfigParser(client_defaults)

1228

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

1229

u"clients.conf"))

1230

1231

global mandos_dbus_service

1232

mandos_dbus_service = None

1233

1234

clients = Set()

1235

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

1236

server_settings[u"port"]),

1237

ClientHandler,

1238

interface=

1239

server_settings[u"interface"],

1240

use_ipv6=use_ipv6,

1241

clients=clients,

1242

gnutls_priority=

1243

server_settings[u"priority"],

1244

use_dbus=use_dbus)

1245

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

1246

try:

1247

pidfile = open(pidfilename, u"w")

1248

except IOError:

1249

logger.error(u"Could not open file %r", pidfilename)

1250

1251

try:

1252

uid = pwd.getpwnam(u"_mandos").pw_uid

1253

gid = pwd.getpwnam(u"_mandos").pw_gid

1254

except KeyError:

1255

try:

1256

uid = pwd.getpwnam(u"mandos").pw_uid

1257

gid = pwd.getpwnam(u"mandos").pw_gid

1258

except KeyError:

1259

try:

1260

uid = pwd.getpwnam(u"nobody").pw_uid

1261

gid = pwd.getpwnam(u"nobody").pw_gid

1262

except KeyError:

1263

uid = 65534

1264

gid = 65534

1265

try:

1266

os.setgid(gid)

1267

os.setuid(uid)

1268

except OSError, error:

1269

if error[0] != errno.EPERM:

1270

raise error

1271

1272

# Enable all possible GnuTLS debugging

1273

if debug:

1274

# "Use a log level over 10 to enable all debugging options."

1275

# - GnuTLS manual

1276

gnutls.library.functions.gnutls_global_set_log_level(11)

1277

1278

@gnutls.library.types.gnutls_log_func

1279

def debug_gnutls(level, string):

1280

logger.debug(u"GnuTLS: %s", string[:-1])

1281

1282

(gnutls.library.functions

1283

.gnutls_global_set_log_function(debug_gnutls))

1284

1285

global service

1286

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1287

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

1288

servicetype = u"_mandos._tcp",

1289

protocol = protocol)

1290

if server_settings["interface"]:

1291

service.interface = (if_nametoindex

1292

(str(server_settings[u"interface"])))

1293

1294

global main_loop

1295

global bus

1296

global server

1297

# From the Avahi example code

572

# Parse the time arguments

573

try:

574

options.timeout = string_to_delta(options.timeout)

575

except ValueError:

576

parser.error("option --timeout: Unparseable time")

577

try:

578

options.interval = string_to_delta(options.interval)

579

except ValueError:

580

parser.error("option --interval: Unparseable time")

581

582

# Parse config file

583

defaults = { "checker": "sleep 1; fping -q -- %%(fqdn)s" }

584

client_config = ConfigParser.SafeConfigParser(defaults)

585

#client_config.readfp(open("secrets.conf"), "secrets.conf")

586

client_config.read("mandos-clients.conf")

587

588

# From the Avahi server example code

1298

589

DBusGMainLoop(set_as_default=True )

1299

590

main_loop = gobject.MainLoop()

1300

591

bus = dbus.SystemBus()

1301

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

1302

avahi.DBUS_PATH_SERVER),

1303

avahi.DBUS_INTERFACE_SERVER)

592

server = dbus.Interface(

593

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

594

avahi.DBUS_INTERFACE_SERVER )

1304

595

# End of Avahi example code

1305

if use_dbus:

1306

bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)

1307

1308

client_class = Client

1309

if use_dbus:

1310

client_class = ClientDBus

1311

clients.update(Set(

1312

client_class(name = section,

1313

config= dict(client_config.items(section)))

1314

for section in client_config.sections()))

1315

if not clients:

1316

logger.warning(u"No clients defined")

1317

1318

if debug:

1319

# Redirect stdin so all checkers get /dev/null

1320

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

1321

os.dup2(null, sys.stdin.fileno())

1322

if null > 2:

1323

os.close(null)

1324

else:

1325

# No console logging

1326

logger.removeHandler(console)

1327

# Close all input and output, do double fork, etc.

1328

daemon()

1329

1330

try:

1331

with closing(pidfile):

1332

pid = os.getpid()

1333

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

1334

del pidfile

1335

except IOError:

1336

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

1337

pidfilename, pid)

1338

except NameError:

1339

# "pidfile" was never created

1340

pass

1341

del pidfilename

1342

1343

def cleanup():

1344

"Cleanup function; run on exit"

1345

global group

1346

# From the Avahi example code

1347

if not group is None:

1348

group.Free()

1349

group = None

1350

# End of Avahi example code

1351

1352

while clients:

1353

client = clients.pop()

1354

client.disable_hook = None

1355

client.disable()

1356

1357

atexit.register(cleanup)

1358

1359

if not debug:

1360

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

1361

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

1362

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

1363

1364

if use_dbus:

1365

class MandosDBusService(dbus.service.Object):

1366

"""A D-Bus proxy object"""

1367

def __init__(self):

1368

dbus.service.Object.__init__(self, bus, u"/")

1369

_interface = u"se.bsnet.fukt.Mandos"

1370

1371

@dbus.service.signal(_interface, signature=u"oa{sv}")

1372

def ClientAdded(self, objpath, properties):

1373

"D-Bus signal"

1374

pass

1375

1376

@dbus.service.signal(_interface, signature=u"s")

1377

def ClientNotFound(self, fingerprint):

1378

"D-Bus signal"

1379

pass

1380

1381

@dbus.service.signal(_interface, signature=u"os")

1382

def ClientRemoved(self, objpath, name):

1383

"D-Bus signal"

1384

pass

1385

1386

@dbus.service.method(_interface, out_signature=u"ao")

1387

def GetAllClients(self):

1388

"D-Bus method"

1389

return dbus.Array(c.dbus_object_path for c in clients)

1390

1391

@dbus.service.method(_interface,

1392

out_signature=u"a{oa{sv}}")

1393

def GetAllClientsWithProperties(self):

1394

"D-Bus method"

1395

return dbus.Dictionary(

1396

((c.dbus_object_path, c.GetAllProperties())

1397

for c in clients),

1398

signature=u"oa{sv}")

1399

1400

@dbus.service.method(_interface, in_signature=u"o")

1401

def RemoveClient(self, object_path):

1402

"D-Bus method"

1403

for c in clients:

1404

if c.dbus_object_path == object_path:

1405

clients.remove(c)

1406

c.remove_from_connection()

1407

# Don't signal anything except ClientRemoved

1408

c.disable(signal=False)

1409

# Emit D-Bus signal

1410

self.ClientRemoved(object_path, c.name)

1411

return

1412

raise KeyError

1413

1414

del _interface

1415

1416

mandos_dbus_service = MandosDBusService()

1417

596

597

debug = options.debug

598

599

clients = Set()

600

def remove_from_clients(client):

601

clients.remove(client)

602

if not clients:

603

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

604

main_loop.quit()

605

606

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

607

stop_hook = remove_from_clients,

608

**(dict(client_config\

609

.items(section))))

610

for section in client_config.sections()))

1418

611

for client in clients:

1419

if use_dbus:

1420

# Emit D-Bus signal

1421

mandos_dbus_service.ClientAdded(client.dbus_object_path,

1422

client.GetAllProperties())

1423

client.enable()

1424

1425

tcp_server.enable()

1426

tcp_server.server_activate()

1427

1428

# Find out what port we got

1429

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

1430

if use_ipv6:

1431

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

1432

" flowinfo %d, scope_id %d"

1433

% tcp_server.socket.getsockname())

1434

else: # IPv4

1435

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

1436

% tcp_server.socket.getsockname())

1437

1438

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

1439

612

client.start()

613

614

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

615

tcp_handler,

616

options=options,

617

clients=clients)

618

# Find out what random port we got

619

servicePort = tcp_server.socket.getsockname()[1]

620

logger.debug(u"Now listening on port %d", servicePort)

621

622

if options.interface is not None:

623

serviceInterface = if_nametoindex(options.interface)

624

625

# From the Avahi server example code

626

server.connect_to_signal("StateChanged", server_state_changed)

627

server_state_changed(server.GetState())

628

# End of Avahi example code

629

630

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

631

lambda *args, **kwargs:

632

tcp_server.handle_request(*args[2:],

633

**kwargs) or True)

1440

634

try:

1441

# From the Avahi example code

1442

server.connect_to_signal(u"StateChanged", server_state_changed)

1443

try:

1444

server_state_changed(server.GetState())

1445

except dbus.exceptions.DBusException, error:

1446

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

1447

sys.exit(1)

1448

# End of Avahi example code

1449

1450

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

1451

lambda *args, **kwargs:

1452

(tcp_server.handle_request

1453

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

1454

1455

logger.debug(u"Starting main loop")

1456

635

main_loop.run()

1457

except AvahiError, error:

1458

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

1459

sys.exit(1)

1460

636

except KeyboardInterrupt:

1461

if debug:

1462

print >> sys.stderr

1463

logger.debug(u"Server received KeyboardInterrupt")

1464

logger.debug(u"Server exiting")

637

print

638

639

# Cleanup here

1465

640

1466

if __name__ == '__main__':

1467

main()

641

# From the Avahi server example code

642

if not group is None:

643

group.Free()

644

# End of Avahi example code

645

646

for client in clients:

647

client.stop_hook = None

648

client.stop()