To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 217
- compare with another revision
- download diff
- download tarball
- view history from revision 217
- Committer: Teddy Hogeborn
- Date: 2008-09-30 07:23:39 UTC
- Revision ID: teddy@fukt.bsnet.se-20080930072339-jn15gyrtfpdk2dhx
* .bzrignore: Added "man" directory (created by "make install-html").
* Makefile: Add "common.ent" dependency to all manual pages.
(htmldir, version, SED): New variables.
(CFLAGS): Add -D option to define VERSION to $(version).
(MANPOST, HTMLPOST): Use $(SED).
(PROGS): Use $(CPROGS)
(CPROGS): New; C-only programs.
(objects): Use $(CPROGS).
(common.ent, mandos, mandos-keygen): New targets; update version
number to $(version).
(clean): Use $(CPROGS).
(check): Depend on "all".
(install-html): Install to $(htmldir).
* common.ent: New file with "version" entity.
* mandos-clients.conf.xml: Use "common.ent".
* mandos-keygen.xml: - '' -
* mandos.conf.xml: - '' -
* mandos.xml: - '' -
* plugin-runner.xml: - '' -
* plugins.d/mandos-client.xml: - '' -
* plugins.d/password-prompt.xml: - '' -
* plugin-runner.c (argp_program_version): Use VERSION.
* plugins.d/mandos-client.c (argp_program_version): - '' -
* plugins.d/password-prompt.c (argp_program_version): - '' -
* Makefile: Add "common.ent" dependency to all manual pages.
(htmldir, version, SED): New variables.
(CFLAGS): Add -D option to define VERSION to $(version).
(MANPOST, HTMLPOST): Use $(SED).
(PROGS): Use $(CPROGS)
(CPROGS): New; C-only programs.
(objects): Use $(CPROGS).
(common.ent, mandos, mandos-keygen): New targets; update version
number to $(version).
(clean): Use $(CPROGS).
(check): Depend on "all".
(install-html): Install to $(htmldir).
* common.ent: New file with "version" entity.
* mandos-clients.conf.xml: Use "common.ent".
* mandos-keygen.xml: - '' -
* mandos.conf.xml: - '' -
* mandos.xml: - '' -
* plugin-runner.xml: - '' -
* plugins.d/mandos-client.xml: - '' -
* plugins.d/password-prompt.xml: - '' -
* plugin-runner.c (argp_program_version): Use VERSION.
* plugins.d/mandos-client.c (argp_program_version): - '' -
* plugins.d/password-prompt.c (argp_program_version): - '' -
- files added:
- debian/mandos-client.config
- files removed:
- DBUS-API
- debian/source
- files modified:
- .bzrignore
added
removed
mandos
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
# methods "add", "remove", "server_state_changed",
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
# "AvahiService" class, and some lines 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
12
#
13
13
# Everything else is
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 Björn Påhlsson
14
# Copyright © 2008 Teddy Hogeborn & Björn Påhlsson
16
15
#
17
16
# This program is free software: you can redistribute it and/or modify
18
17
# it under the terms of the GNU General Public License as published by
28
27
# along with this program. If not, see
29
28
# <http://www.gnu.org/licenses/>.
30
29
#
31
# Contact the authors at <mandos@recompile.se>.
30
# Contact the authors at <mandos@fukt.bsnet.se>.
32
31
#
33
32
34
from __future__ import (division, absolute_import, print_function,
35
unicode_literals)
33
from __future__ import division
36
34
37
import SocketServer as socketserver
35
import SocketServer
38
36
import socket
39
import argparse
37
from optparse import OptionParser
40
38
import datetime
41
39
import errno
42
40
import gnutls.crypto
45
43
import gnutls.library.functions
46
44
import gnutls.library.constants
47
45
import gnutls.library.types
48
import ConfigParser as configparser
46
import ConfigParser
49
47
import sys
50
48
import re
51
49
import os
52
50
import signal
51
from sets import Set
53
52
import subprocess
54
53
import atexit
55
54
import stat
56
55
import logging
57
56
import logging.handlers
58
57
import pwd
59
import contextlib
60
import struct
61
import fcntl
62
import functools
63
import cPickle as pickle
64
import multiprocessing
65
import types
66
import binascii
67
import tempfile
68
58
69
59
import dbus
70
import dbus.service
71
60
import gobject
72
61
import avahi
73
62
from dbus.mainloop.glib import DBusGMainLoop
74
63
import ctypes
75
64
import ctypes.util
76
import xml.dom.minidom
77
import inspect
78
import GnuPGInterface
79
80
try:
81
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
82
except AttributeError:
83
try:
84
from IN import SO_BINDTODEVICE
85
except ImportError:
86
SO_BINDTODEVICE = None
87
88
89
version = "1.4.1"
90
stored_state_file = "clients.pickle"
91
92
logger = logging.getLogger()
93
syslogger = (logging.handlers.SysLogHandler
94
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
95
address = str("/dev/log")))
96
97
try:
98
if_nametoindex = (ctypes.cdll.LoadLibrary
99
(ctypes.util.find_library("c"))
100
.if_nametoindex)
101
except (OSError, AttributeError):
102
def if_nametoindex(interface):
103
"Get an interface index the hard way, i.e. using fcntl()"
104
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
105
with contextlib.closing(socket.socket()) as s:
106
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
107
struct.pack(str("16s16x"),
108
interface))
109
interface_index = struct.unpack(str("I"),
110
ifreq[16:20])[0]
111
return interface_index
112
113
114
def initlogger(level=logging.WARNING):
115
"""init logger and add loglevel"""
116
117
syslogger.setFormatter(logging.Formatter
118
('Mandos [%(process)d]: %(levelname)s:'
119
' %(message)s'))
120
logger.addHandler(syslogger)
121
122
console = logging.StreamHandler()
123
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
124
' [%(process)d]:'
125
' %(levelname)s:'
126
' %(message)s'))
127
logger.addHandler(console)
128
logger.setLevel(level)
129
130
131
class CryptoError(Exception):
132
pass
133
134
135
class Crypto(object):
136
"""A simple class for OpenPGP symmetric encryption & decryption"""
137
def __init__(self):
138
self.gnupg = GnuPGInterface.GnuPG()
139
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
140
self.gnupg = GnuPGInterface.GnuPG()
141
self.gnupg.options.meta_interactive = False
142
self.gnupg.options.homedir = self.tempdir
143
self.gnupg.options.extra_args.extend(['--force-mdc',
144
'--quiet'])
145
146
def __enter__(self):
147
return self
148
149
def __exit__ (self, exc_type, exc_value, traceback):
150
self._cleanup()
151
return False
152
153
def __del__(self):
154
self._cleanup()
155
156
def _cleanup(self):
157
if self.tempdir is not None:
158
# Delete contents of tempdir
159
for root, dirs, files in os.walk(self.tempdir,
160
topdown = False):
161
for filename in files:
162
os.remove(os.path.join(root, filename))
163
for dirname in dirs:
164
os.rmdir(os.path.join(root, dirname))
165
# Remove tempdir
166
os.rmdir(self.tempdir)
167
self.tempdir = None
168
169
def password_encode(self, password):
170
# Passphrase can not be empty and can not contain newlines or
171
# NUL bytes. So we prefix it and hex encode it.
172
return b"mandos" + binascii.hexlify(password)
173
174
def encrypt(self, data, password):
175
self.gnupg.passphrase = self.password_encode(password)
176
with open(os.devnull) as devnull:
177
try:
178
proc = self.gnupg.run(['--symmetric'],
179
create_fhs=['stdin', 'stdout'],
180
attach_fhs={'stderr': devnull})
181
with contextlib.closing(proc.handles['stdin']) as f:
182
f.write(data)
183
with contextlib.closing(proc.handles['stdout']) as f:
184
ciphertext = f.read()
185
proc.wait()
186
except IOError as e:
187
raise CryptoError(e)
188
self.gnupg.passphrase = None
189
return ciphertext
190
191
def decrypt(self, data, password):
192
self.gnupg.passphrase = self.password_encode(password)
193
with open(os.devnull) as devnull:
194
try:
195
proc = self.gnupg.run(['--decrypt'],
196
create_fhs=['stdin', 'stdout'],
197
attach_fhs={'stderr': devnull})
198
with contextlib.closing(proc.handles['stdin'] ) as f:
199
f.write(data)
200
with contextlib.closing(proc.handles['stdout']) as f:
201
decrypted_plaintext = f.read()
202
proc.wait()
203
except IOError as e:
204
raise CryptoError(e)
205
self.gnupg.passphrase = None
206
return decrypted_plaintext
207
208
65
66
version = "1.0"
67
68
logger = logging.Logger('mandos')
69
syslogger = logging.handlers.SysLogHandler\
70
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
71
address = "/dev/log")
72
syslogger.setFormatter(logging.Formatter\
73
('Mandos: %(levelname)s: %(message)s'))
74
logger.addHandler(syslogger)
75
76
console = logging.StreamHandler()
77
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
78
' %(message)s'))
79
logger.addHandler(console)
209
80
210
81
class AvahiError(Exception):
211
def __init__(self, value, *args, **kwargs):
82
def __init__(self, value):
212
83
self.value = value
213
super(AvahiError, self).__init__(value, *args, **kwargs)
214
def __unicode__(self):
215
return unicode(repr(self.value))
84
super(AvahiError, self).__init__()
85
def __str__(self):
86
return repr(self.value)
216
87
217
88
class AvahiServiceError(AvahiError):
218
89
pass
223
94
224
95
class AvahiService(object):
225
96
"""An Avahi (Zeroconf) service.
226
227
97
Attributes:
228
98
interface: integer; avahi.IF_UNSPEC or an interface index.
229
99
Used to optionally bind to the specified interface.
237
107
max_renames: integer; maximum number of renames
238
108
rename_count: integer; counter so we only rename after collisions
239
109
a sensible number of times
240
group: D-Bus Entry Group
241
server: D-Bus Server
242
bus: dbus.SystemBus()
243
110
"""
244
111
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
245
servicetype = None, port = None, TXT = None,
246
domain = "", host = "", max_renames = 32768,
247
protocol = avahi.PROTO_UNSPEC, bus = None):
112
servicetype = None, port = None, TXT = None, domain = "",
113
host = "", max_renames = 32768):
248
114
self.interface = interface
249
115
self.name = name
250
116
self.type = servicetype
251
117
self.port = port
252
self.TXT = TXT if TXT is not None else []
118
if TXT is None:
119
self.TXT = []
120
else:
121
self.TXT = TXT
253
122
self.domain = domain
254
123
self.host = host
255
124
self.rename_count = 0
256
125
self.max_renames = max_renames
257
self.protocol = protocol
258
self.group = None # our entry group
259
self.server = None
260
self.bus = bus
261
self.entry_group_state_changed_match = None
262
126
def rename(self):
263
127
"""Derived from the Avahi example code"""
264
128
if self.rename_count >= self.max_renames:
265
logger.critical("No suitable Zeroconf service name found"
266
" after %i retries, exiting.",
129
logger.critical(u"No suitable Zeroconf service name found"
130
u" after %i retries, exiting.",
267
131
self.rename_count)
268
132
raise AvahiServiceError("Too many renames")
269
self.name = unicode(self.server
270
.GetAlternativeServiceName(self.name))
271
logger.info("Changing Zeroconf service name to %r ...",
272
self.name)
133
self.name = server.GetAlternativeServiceName(self.name)
134
logger.info(u"Changing Zeroconf service name to %r ...",
135
str(self.name))
136
syslogger.setFormatter(logging.Formatter\
137
('Mandos (%s): %%(levelname)s:'
138
' %%(message)s' % self.name))
273
139
self.remove()
274
try:
275
self.add()
276
except dbus.exceptions.DBusException as error:
277
logger.critical("DBusException: %s", error)
278
self.cleanup()
279
os._exit(1)
140
self.add()
280
141
self.rename_count += 1
281
142
def remove(self):
282
143
"""Derived from the Avahi example code"""
283
if self.entry_group_state_changed_match is not None:
284
self.entry_group_state_changed_match.remove()
285
self.entry_group_state_changed_match = None
286
if self.group is not None:
287
self.group.Reset()
144
if group is not None:
145
group.Reset()
288
146
def add(self):
289
147
"""Derived from the Avahi example code"""
290
self.remove()
291
if self.group is None:
292
self.group = dbus.Interface(
293
self.bus.get_object(avahi.DBUS_NAME,
294
self.server.EntryGroupNew()),
295
avahi.DBUS_INTERFACE_ENTRY_GROUP)
296
self.entry_group_state_changed_match = (
297
self.group.connect_to_signal(
298
'StateChanged', self.entry_group_state_changed))
299
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
300
self.name, self.type)
301
self.group.AddService(
302
self.interface,
303
self.protocol,
304
dbus.UInt32(0), # flags
305
self.name, self.type,
306
self.domain, self.host,
307
dbus.UInt16(self.port),
308
avahi.string_array_to_txt_array(self.TXT))
309
self.group.Commit()
310
def entry_group_state_changed(self, state, error):
311
"""Derived from the Avahi example code"""
312
logger.debug("Avahi entry group state change: %i", state)
313
314
if state == avahi.ENTRY_GROUP_ESTABLISHED:
315
logger.debug("Zeroconf service established.")
316
elif state == avahi.ENTRY_GROUP_COLLISION:
317
logger.info("Zeroconf service name collision.")
318
self.rename()
319
elif state == avahi.ENTRY_GROUP_FAILURE:
320
logger.critical("Avahi: Error in group state changed %s",
321
unicode(error))
322
raise AvahiGroupError("State changed: %s"
323
% unicode(error))
324
def cleanup(self):
325
"""Derived from the Avahi example code"""
326
if self.group is not None:
327
try:
328
self.group.Free()
329
except (dbus.exceptions.UnknownMethodException,
330
dbus.exceptions.DBusException):
331
pass
332
self.group = None
333
self.remove()
334
def server_state_changed(self, state, error=None):
335
"""Derived from the Avahi example code"""
336
logger.debug("Avahi server state change: %i", state)
337
bad_states = { avahi.SERVER_INVALID:
338
"Zeroconf server invalid",
339
avahi.SERVER_REGISTERING: None,
340
avahi.SERVER_COLLISION:
341
"Zeroconf server name collision",
342
avahi.SERVER_FAILURE:
343
"Zeroconf server failure" }
344
if state in bad_states:
345
if bad_states[state] is not None:
346
if error is None:
347
logger.error(bad_states[state])
348
else:
349
logger.error(bad_states[state] + ": %r", error)
350
self.cleanup()
351
elif state == avahi.SERVER_RUNNING:
352
self.add()
353
else:
354
if error is None:
355
logger.debug("Unknown state: %r", state)
356
else:
357
logger.debug("Unknown state: %r: %r", state, error)
358
def activate(self):
359
"""Derived from the Avahi example code"""
360
if self.server is None:
361
self.server = dbus.Interface(
362
self.bus.get_object(avahi.DBUS_NAME,
363
avahi.DBUS_PATH_SERVER,
364
follow_name_owner_changes=True),
365
avahi.DBUS_INTERFACE_SERVER)
366
self.server.connect_to_signal("StateChanged",
367
self.server_state_changed)
368
self.server_state_changed(self.server.GetState())
369
370
class AvahiServiceToSyslog(AvahiService):
371
def rename(self):
372
"""Add the new name to the syslog messages"""
373
ret = AvahiService.rename(self)
374
syslogger.setFormatter(logging.Formatter
375
('Mandos (%s) [%%(process)d]:'
376
' %%(levelname)s: %%(message)s'
377
% self.name))
378
return ret
379
380
def _timedelta_to_milliseconds(td):
381
"Convert a datetime.timedelta() to milliseconds"
382
return ((td.days * 24 * 60 * 60 * 1000)
383
+ (td.seconds * 1000)
384
+ (td.microseconds // 1000))
385
148
global group
149
if group is None:
150
group = dbus.Interface\
151
(bus.get_object(avahi.DBUS_NAME,
152
server.EntryGroupNew()),
153
avahi.DBUS_INTERFACE_ENTRY_GROUP)
154
group.connect_to_signal('StateChanged',
155
entry_group_state_changed)
156
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
157
service.name, service.type)
158
group.AddService(
159
self.interface, # interface
160
avahi.PROTO_INET6, # protocol
161
dbus.UInt32(0), # flags
162
self.name, self.type,
163
self.domain, self.host,
164
dbus.UInt16(self.port),
165
avahi.string_array_to_txt_array(self.TXT))
166
group.Commit()
167
168
# From the Avahi example code:
169
group = None # our entry group
170
# End of Avahi example code
171
172
386
173
class Client(object):
387
174
"""A representation of a client host served by this server.
388
389
175
Attributes:
390
_approved: bool(); 'None' if not yet approved/disapproved
391
approval_delay: datetime.timedelta(); Time to wait for approval
392
approval_duration: datetime.timedelta(); Duration of one approval
393
checker: subprocess.Popen(); a running checker process used
394
to see if the client lives.
395
'None' if no process is running.
396
checker_callback_tag: a gobject event source tag, or None
397
checker_command: string; External command which is run to check
398
if client lives. %() expansions are done at
176
name: string; from the config file, used in log messages
177
fingerprint: string (40 or 32 hexadecimal digits); used to
178
uniquely identify the client
179
secret: bytestring; sent verbatim (over TLS) to client
180
host: string; available for use by the checker command
181
created: datetime.datetime(); object creation, not client host
182
last_checked_ok: datetime.datetime() or None if not yet checked OK
183
timeout: datetime.timedelta(); How long from last_checked_ok
184
until this client is invalid
185
interval: datetime.timedelta(); How often to start a new checker
186
stop_hook: If set, called by stop() as stop_hook(self)
187
checker: subprocess.Popen(); a running checker process used
188
to see if the client lives.
189
'None' if no process is running.
190
checker_initiator_tag: a gobject event source tag, or None
191
stop_initiator_tag: - '' -
192
checker_callback_tag: - '' -
193
checker_command: string; External command which is run to check if
194
client lives. %() expansions are done at
399
195
runtime with vars(self) as dict, so that for
400
196
instance %(name)s can be used in the command.
401
checker_initiator_tag: a gobject event source tag, or None
402
created: datetime.datetime(); (UTC) object creation
403
client_structure: Object describing what attributes a client has
404
and is used for storing the client at exit
405
current_checker_command: string; current running checker_command
406
disable_initiator_tag: a gobject event source tag, or None
407
enabled: bool()
408
fingerprint: string (40 or 32 hexadecimal digits); used to
409
uniquely identify the client
410
host: string; available for use by the checker command
411
interval: datetime.timedelta(); How often to start a new checker
412
last_approval_request: datetime.datetime(); (UTC) or None
413
last_checked_ok: datetime.datetime(); (UTC) or None
414
415
last_checker_status: integer between 0 and 255 reflecting exit
416
status of last checker. -1 reflects crashed
417
checker, or None.
418
last_enabled: datetime.datetime(); (UTC)
419
name: string; from the config file, used in log messages and
420
D-Bus identifiers
421
secret: bytestring; sent verbatim (over TLS) to client
422
timeout: datetime.timedelta(); How long from last_checked_ok
423
until this client is disabled
424
extended_timeout: extra long timeout when password has been sent
425
runtime_expansions: Allowed attributes for runtime expansion.
426
expires: datetime.datetime(); time (UTC) when a client will be
427
disabled, or None
197
Private attibutes:
198
_timeout: Real variable for 'timeout'
199
_interval: Real variable for 'interval'
200
_timeout_milliseconds: Used when calling gobject.timeout_add()
201
_interval_milliseconds: - '' -
428
202
"""
429
430
runtime_expansions = ("approval_delay", "approval_duration",
431
"created", "enabled", "fingerprint",
432
"host", "interval", "last_checked_ok",
433
"last_enabled", "name", "timeout")
434
435
def timeout_milliseconds(self):
436
"Return the 'timeout' attribute in milliseconds"
437
return _timedelta_to_milliseconds(self.timeout)
438
439
def extended_timeout_milliseconds(self):
440
"Return the 'extended_timeout' attribute in milliseconds"
441
return _timedelta_to_milliseconds(self.extended_timeout)
442
443
def interval_milliseconds(self):
444
"Return the 'interval' attribute in milliseconds"
445
return _timedelta_to_milliseconds(self.interval)
446
447
def approval_delay_milliseconds(self):
448
return _timedelta_to_milliseconds(self.approval_delay)
449
450
def __init__(self, name = None, config=None):
203
def _set_timeout(self, timeout):
204
"Setter function for 'timeout' attribute"
205
self._timeout = timeout
206
self._timeout_milliseconds = ((self.timeout.days
207
* 24 * 60 * 60 * 1000)
208
+ (self.timeout.seconds * 1000)
209
+ (self.timeout.microseconds
210
// 1000))
211
timeout = property(lambda self: self._timeout,
212
_set_timeout)
213
del _set_timeout
214
def _set_interval(self, interval):
215
"Setter function for 'interval' attribute"
216
self._interval = interval
217
self._interval_milliseconds = ((self.interval.days
218
* 24 * 60 * 60 * 1000)
219
+ (self.interval.seconds
220
* 1000)
221
+ (self.interval.microseconds
222
// 1000))
223
interval = property(lambda self: self._interval,
224
_set_interval)
225
del _set_interval
226
def __init__(self, name = None, stop_hook=None, config=None):
451
227
"""Note: the 'checker' key in 'config' sets the
452
228
'checker_command' attribute and *not* the 'checker'
453
229
attribute."""
454
self.name = name
455
230
if config is None:
456
231
config = {}
457
logger.debug("Creating client %r", self.name)
232
self.name = name
233
logger.debug(u"Creating client %r", self.name)
458
234
# Uppercase and remove spaces from fingerprint for later
459
235
# comparison purposes with return value from the fingerprint()
460
236
# function
461
self.fingerprint = (config["fingerprint"].upper()
462
.replace(" ", ""))
463
logger.debug(" Fingerprint: %s", self.fingerprint)
237
self.fingerprint = config["fingerprint"].upper()\
238
.replace(u" ", u"")
239
logger.debug(u" Fingerprint: %s", self.fingerprint)
464
240
if "secret" in config:
465
self.secret = config["secret"].decode("base64")
241
self.secret = config["secret"].decode(u"base64")
466
242
elif "secfile" in config:
467
with open(os.path.expanduser(os.path.expandvars
468
(config["secfile"])),
469
"rb") as secfile:
470
self.secret = secfile.read()
243
secfile = open(config["secfile"])
244
self.secret = secfile.read()
245
secfile.close()
471
246
else:
472
raise TypeError("No secret or secfile for client %s"
247
raise TypeError(u"No secret or secfile for client %s"
473
248
% self.name)
474
249
self.host = config.get("host", "")
475
self.created = datetime.datetime.utcnow()
476
self.enabled = True
477
self.last_approval_request = None
478
self.last_enabled = datetime.datetime.utcnow()
250
self.created = datetime.datetime.now()
479
251
self.last_checked_ok = None
480
self.last_checker_status = None
481
252
self.timeout = string_to_delta(config["timeout"])
482
self.extended_timeout = string_to_delta(config
483
["extended_timeout"])
484
253
self.interval = string_to_delta(config["interval"])
254
self.stop_hook = stop_hook
485
255
self.checker = None
486
256
self.checker_initiator_tag = None
487
self.disable_initiator_tag = None
488
self.expires = datetime.datetime.utcnow() + self.timeout
257
self.stop_initiator_tag = None
489
258
self.checker_callback_tag = None
490
self.checker_command = config["checker"]
491
self.current_checker_command = None
492
self._approved = None
493
self.approved_by_default = config.get("approved_by_default",
494
True)
495
self.approvals_pending = 0
496
self.approval_delay = string_to_delta(
497
config["approval_delay"])
498
self.approval_duration = string_to_delta(
499
config["approval_duration"])
500
self.changedstate = (multiprocessing_manager
501
.Condition(multiprocessing_manager
502
.Lock()))
503
self.client_structure = [attr for attr in
504
self.__dict__.iterkeys()
505
if not attr.startswith("_")]
506
self.client_structure.append("client_structure")
507
508
for name, t in inspect.getmembers(type(self),
509
lambda obj:
510
isinstance(obj,
511
property)):
512
if not name.startswith("_"):
513
self.client_structure.append(name)
514
515
# Send notice to process children that client state has changed
516
def send_changedstate(self):
517
with self.changedstate:
518
self.changedstate.notify_all()
519
520
def enable(self):
259
self.check_command = config["checker"]
260
def start(self):
521
261
"""Start this client's checker and timeout hooks"""
522
if getattr(self, "enabled", False):
523
# Already enabled
524
return
525
self.send_changedstate()
526
self.expires = datetime.datetime.utcnow() + self.timeout
527
self.enabled = True
528
self.last_enabled = datetime.datetime.utcnow()
529
self.init_checker()
530
531
def disable(self, quiet=True):
532
"""Disable this client."""
533
if not getattr(self, "enabled", False):
262
# Schedule a new checker to be started an 'interval' from now,
263
# and every interval from then on.
264
self.checker_initiator_tag = gobject.timeout_add\
265
(self._interval_milliseconds,
266
self.start_checker)
267
# Also start a new checker *right now*.
268
self.start_checker()
269
# Schedule a stop() when 'timeout' has passed
270
self.stop_initiator_tag = gobject.timeout_add\
271
(self._timeout_milliseconds,
272
self.stop)
273
def stop(self):
274
"""Stop this client.
275
The possibility that a client might be restarted is left open,
276
but not currently used."""
277
# If this client doesn't have a secret, it is already stopped.
278
if hasattr(self, "secret") and self.secret:
279
logger.info(u"Stopping client %s", self.name)
280
self.secret = None
281
else:
534
282
return False
535
if not quiet:
536
self.send_changedstate()
537
if not quiet:
538
logger.info("Disabling client %s", self.name)
539
if getattr(self, "disable_initiator_tag", False):
540
gobject.source_remove(self.disable_initiator_tag)
541
self.disable_initiator_tag = None
542
self.expires = None
283
if getattr(self, "stop_initiator_tag", False):
284
gobject.source_remove(self.stop_initiator_tag)
285
self.stop_initiator_tag = None
543
286
if getattr(self, "checker_initiator_tag", False):
544
287
gobject.source_remove(self.checker_initiator_tag)
545
288
self.checker_initiator_tag = None
546
289
self.stop_checker()
547
self.enabled = False
290
if self.stop_hook:
291
self.stop_hook(self)
548
292
# Do not run this again if called by a gobject.timeout_add
549
293
return False
550
551
294
def __del__(self):
552
self.disable()
553
554
def init_checker(self):
555
# Schedule a new checker to be started an 'interval' from now,
556
# and every interval from then on.
557
self.checker_initiator_tag = (gobject.timeout_add
558
(self.interval_milliseconds(),
559
self.start_checker))
560
# Schedule a disable() when 'timeout' has passed
561
self.disable_initiator_tag = (gobject.timeout_add
562
(self.timeout_milliseconds(),
563
self.disable))
564
# Also start a new checker *right now*.
565
self.start_checker()
566
567
def checker_callback(self, pid, condition, command):
295
self.stop_hook = None
296
self.stop()
297
def checker_callback(self, pid, condition):
568
298
"""The checker has completed, so take appropriate actions."""
299
now = datetime.datetime.now()
569
300
self.checker_callback_tag = None
570
301
self.checker = None
571
if os.WIFEXITED(condition):
572
self.last_checker_status = os.WEXITSTATUS(condition)
573
if self.last_checker_status == 0:
574
logger.info("Checker for %(name)s succeeded",
575
vars(self))
576
self.checked_ok()
577
else:
578
logger.info("Checker for %(name)s failed",
579
vars(self))
580
else:
581
self.last_checker_status = -1
582
logger.warning("Checker for %(name)s crashed?",
302
if os.WIFEXITED(condition) \
303
and (os.WEXITSTATUS(condition) == 0):
304
logger.info(u"Checker for %(name)s succeeded",
305
vars(self))
306
self.last_checked_ok = now
307
gobject.source_remove(self.stop_initiator_tag)
308
self.stop_initiator_tag = gobject.timeout_add\
309
(self._timeout_milliseconds,
310
self.stop)
311
elif not os.WIFEXITED(condition):
312
logger.warning(u"Checker for %(name)s crashed?",
583
313
vars(self))
584
585
def checked_ok(self, timeout=None):
586
"""Bump up the timeout for this client.
587
588
This should only be called when the client has been seen,
589
alive and well.
590
"""
591
if timeout is None:
592
timeout = self.timeout
593
self.last_checked_ok = datetime.datetime.utcnow()
594
if self.disable_initiator_tag is not None:
595
gobject.source_remove(self.disable_initiator_tag)
596
if getattr(self, "enabled", False):
597
self.disable_initiator_tag = (gobject.timeout_add
598
(_timedelta_to_milliseconds
599
(timeout), self.disable))
600
self.expires = datetime.datetime.utcnow() + timeout
601
602
def need_approval(self):
603
self.last_approval_request = datetime.datetime.utcnow()
604
314
else:
315
logger.info(u"Checker for %(name)s failed",
316
vars(self))
605
317
def start_checker(self):
606
318
"""Start a new checker subprocess if one is not running.
607
608
319
If a checker already exists, leave it running and do
609
320
nothing."""
610
321
# The reason for not killing a running checker is that if we
613
324
# client would inevitably timeout, since no checker would get
614
325
# a chance to run to completion. If we instead leave running
615
326
# checkers alone, the checker would have to take more time
616
# than 'timeout' for the client to be disabled, which is as it
617
# should be.
618
619
# If a checker exists, make sure it is not a zombie
620
try:
621
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
622
except (AttributeError, OSError) as error:
623
if (isinstance(error, OSError)
624
and error.errno != errno.ECHILD):
625
raise error
626
else:
627
if pid:
628
logger.warning("Checker was a zombie")
629
gobject.source_remove(self.checker_callback_tag)
630
self.checker_callback(pid, status,
631
self.current_checker_command)
632
# Start a new checker if needed
327
# than 'timeout' for the client to be declared invalid, which
328
# is as it should be.
633
329
if self.checker is None:
634
330
try:
635
# In case checker_command has exactly one % operator
636
command = self.checker_command % self.host
331
# In case check_command has exactly one % operator
332
command = self.check_command % self.host
637
333
except TypeError:
638
334
# Escape attributes for the shell
639
escaped_attrs = dict(
640
(attr,
641
re.escape(unicode(str(getattr(self, attr, "")),
642
errors=
643
'replace')))
644
for attr in
645
self.runtime_expansions)
646
335
escaped_attrs = dict((key, re.escape(str(val)))
336
for key, val in
337
vars(self).iteritems())
647
338
try:
648
command = self.checker_command % escaped_attrs
649
except TypeError as error:
650
logger.error('Could not format string "%s":'
651
' %s', self.checker_command, error)
339
command = self.check_command % escaped_attrs
340
except TypeError, error:
341
logger.error(u'Could not format string "%s":'
342
u' %s', self.check_command, error)
652
343
return True # Try again later
653
self.current_checker_command = command
654
344
try:
655
logger.info("Starting checker %r for %s",
345
logger.info(u"Starting checker %r for %s",
656
346
command, self.name)
657
347
# We don't need to redirect stdout and stderr, since
658
348
# in normal mode, that is already done by daemon(),
661
351
self.checker = subprocess.Popen(command,
662
352
close_fds=True,
663
353
shell=True, cwd="/")
664
self.checker_callback_tag = (gobject.child_watch_add
665
(self.checker.pid,
666
self.checker_callback,
667
data=command))
668
# The checker may have completed before the gobject
669
# watch was added. Check for this.
670
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
671
if pid:
672
gobject.source_remove(self.checker_callback_tag)
673
self.checker_callback(pid, status, command)
674
except OSError as error:
675
logger.error("Failed to start subprocess: %s",
354
self.checker_callback_tag = gobject.child_watch_add\
355
(self.checker.pid,
356
self.checker_callback)
357
except OSError, error:
358
logger.error(u"Failed to start subprocess: %s",
676
359
error)
677
360
# Re-run this periodically if run by gobject.timeout_add
678
361
return True
679
680
362
def stop_checker(self):
681
363
"""Force the checker process, if any, to stop."""
682
364
if self.checker_callback_tag:
684
366
self.checker_callback_tag = None
685
367
if getattr(self, "checker", None) is None:
686
368
return
687
logger.debug("Stopping checker for %(name)s", vars(self))
369
logger.debug(u"Stopping checker for %(name)s", vars(self))
688
370
try:
689
371
os.kill(self.checker.pid, signal.SIGTERM)
690
#time.sleep(0.5)
372
#os.sleep(0.5)
691
373
#if self.checker.poll() is None:
692
374
# os.kill(self.checker.pid, signal.SIGKILL)
693
except OSError as error:
375
except OSError, error:
694
376
if error.errno != errno.ESRCH: # No such process
695
377
raise
696
378
self.checker = None
697
698
699
def dbus_service_property(dbus_interface, signature="v",
700
access="readwrite", byte_arrays=False):
701
"""Decorators for marking methods of a DBusObjectWithProperties to
702
become properties on the D-Bus.
703
704
The decorated method will be called with no arguments by "Get"
705
and with one argument by "Set".
706
707
The parameters, where they are supported, are the same as
708
dbus.service.method, except there is only "signature", since the
709
type from Get() and the type sent to Set() is the same.
710
"""
711
# Encoding deeply encoded byte arrays is not supported yet by the
712
# "Set" method, so we fail early here:
713
if byte_arrays and signature != "ay":
714
raise ValueError("Byte arrays not supported for non-'ay'"
715
" signature %r" % signature)
716
def decorator(func):
717
func._dbus_is_property = True
718
func._dbus_interface = dbus_interface
719
func._dbus_signature = signature
720
func._dbus_access = access
721
func._dbus_name = func.__name__
722
if func._dbus_name.endswith("_dbus_property"):
723
func._dbus_name = func._dbus_name[:-14]
724
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
725
return func
726
return decorator
727
728
729
class DBusPropertyException(dbus.exceptions.DBusException):
730
"""A base class for D-Bus property-related exceptions
731
"""
732
def __unicode__(self):
733
return unicode(str(self))
734
735
736
class DBusPropertyAccessException(DBusPropertyException):
737
"""A property's access permissions disallows an operation.
738
"""
739
pass
740
741
742
class DBusPropertyNotFound(DBusPropertyException):
743
"""An attempt was made to access a non-existing property.
744
"""
745
pass
746
747
748
class DBusObjectWithProperties(dbus.service.Object):
749
"""A D-Bus object with properties.
750
751
Classes inheriting from this can use the dbus_service_property
752
decorator to expose methods as D-Bus properties. It exposes the
753
standard Get(), Set(), and GetAll() methods on the D-Bus.
754
"""
755
756
@staticmethod
757
def _is_dbus_property(obj):
758
return getattr(obj, "_dbus_is_property", False)
759
760
def _get_all_dbus_properties(self):
761
"""Returns a generator of (name, attribute) pairs
762
"""
763
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
764
for cls in self.__class__.__mro__
765
for name, prop in
766
inspect.getmembers(cls, self._is_dbus_property))
767
768
def _get_dbus_property(self, interface_name, property_name):
769
"""Returns a bound method if one exists which is a D-Bus
770
property with the specified name and interface.
771
"""
772
for cls in self.__class__.__mro__:
773
for name, value in (inspect.getmembers
774
(cls, self._is_dbus_property)):
775
if (value._dbus_name == property_name
776
and value._dbus_interface == interface_name):
777
return value.__get__(self)
778
779
# No such property
780
raise DBusPropertyNotFound(self.dbus_object_path + ":"
781
+ interface_name + "."
782
+ property_name)
783
784
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
785
out_signature="v")
786
def Get(self, interface_name, property_name):
787
"""Standard D-Bus property Get() method, see D-Bus standard.
788
"""
789
prop = self._get_dbus_property(interface_name, property_name)
790
if prop._dbus_access == "write":
791
raise DBusPropertyAccessException(property_name)
792
value = prop()
793
if not hasattr(value, "variant_level"):
794
return value
795
return type(value)(value, variant_level=value.variant_level+1)
796
797
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
798
def Set(self, interface_name, property_name, value):
799
"""Standard D-Bus property Set() method, see D-Bus standard.
800
"""
801
prop = self._get_dbus_property(interface_name, property_name)
802
if prop._dbus_access == "read":
803
raise DBusPropertyAccessException(property_name)
804
if prop._dbus_get_args_options["byte_arrays"]:
805
# The byte_arrays option is not supported yet on
806
# signatures other than "ay".
807
if prop._dbus_signature != "ay":
808
raise ValueError
809
value = dbus.ByteArray(''.join(unichr(byte)
810
for byte in value))
811
prop(value)
812
813
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
814
out_signature="a{sv}")
815
def GetAll(self, interface_name):
816
"""Standard D-Bus property GetAll() method, see D-Bus
817
standard.
818
819
Note: Will not include properties with access="write".
820
"""
821
properties = {}
822
for name, prop in self._get_all_dbus_properties():
823
if (interface_name
824
and interface_name != prop._dbus_interface):
825
# Interface non-empty but did not match
826
continue
827
# Ignore write-only properties
828
if prop._dbus_access == "write":
829
continue
830
value = prop()
831
if not hasattr(value, "variant_level"):
832
properties[name] = value
833
continue
834
properties[name] = type(value)(value, variant_level=
835
value.variant_level+1)
836
return dbus.Dictionary(properties, signature="sv")
837
838
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
839
out_signature="s",
840
path_keyword='object_path',
841
connection_keyword='connection')
842
def Introspect(self, object_path, connection):
843
"""Standard D-Bus method, overloaded to insert property tags.
844
"""
845
xmlstring = dbus.service.Object.Introspect(self, object_path,
846
connection)
847
try:
848
document = xml.dom.minidom.parseString(xmlstring)
849
def make_tag(document, name, prop):
850
e = document.createElement("property")
851
e.setAttribute("name", name)
852
e.setAttribute("type", prop._dbus_signature)
853
e.setAttribute("access", prop._dbus_access)
854
return e
855
for if_tag in document.getElementsByTagName("interface"):
856
for tag in (make_tag(document, name, prop)
857
for name, prop
858
in self._get_all_dbus_properties()
859
if prop._dbus_interface
860
== if_tag.getAttribute("name")):
861
if_tag.appendChild(tag)
862
# Add the names to the return values for the
863
# "org.freedesktop.DBus.Properties" methods
864
if (if_tag.getAttribute("name")
865
== "org.freedesktop.DBus.Properties"):
866
for cn in if_tag.getElementsByTagName("method"):
867
if cn.getAttribute("name") == "Get":
868
for arg in cn.getElementsByTagName("arg"):
869
if (arg.getAttribute("direction")
870
== "out"):
871
arg.setAttribute("name", "value")
872
elif cn.getAttribute("name") == "GetAll":
873
for arg in cn.getElementsByTagName("arg"):
874
if (arg.getAttribute("direction")
875
== "out"):
876
arg.setAttribute("name", "props")
877
xmlstring = document.toxml("utf-8")
878
document.unlink()
879
except (AttributeError, xml.dom.DOMException,
880
xml.parsers.expat.ExpatError) as error:
881
logger.error("Failed to override Introspection method",
882
error)
883
return xmlstring
884
885
886
def datetime_to_dbus (dt, variant_level=0):
887
"""Convert a UTC datetime.datetime() to a D-Bus type."""
888
if dt is None:
889
return dbus.String("", variant_level = variant_level)
890
return dbus.String(dt.isoformat(),
891
variant_level=variant_level)
892
893
894
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
895
.__metaclass__):
896
"""Applied to an empty subclass of a D-Bus object, this metaclass
897
will add additional D-Bus attributes matching a certain pattern.
898
"""
899
def __new__(mcs, name, bases, attr):
900
# Go through all the base classes which could have D-Bus
901
# methods, signals, or properties in them
902
for base in (b for b in bases
903
if issubclass(b, dbus.service.Object)):
904
# Go though all attributes of the base class
905
for attrname, attribute in inspect.getmembers(base):
906
# Ignore non-D-Bus attributes, and D-Bus attributes
907
# with the wrong interface name
908
if (not hasattr(attribute, "_dbus_interface")
909
or not attribute._dbus_interface
910
.startswith("se.recompile.Mandos")):
911
continue
912
# Create an alternate D-Bus interface name based on
913
# the current name
914
alt_interface = (attribute._dbus_interface
915
.replace("se.recompile.Mandos",
916
"se.bsnet.fukt.Mandos"))
917
# Is this a D-Bus signal?
918
if getattr(attribute, "_dbus_is_signal", False):
919
# Extract the original non-method function by
920
# black magic
921
nonmethod_func = (dict(
922
zip(attribute.func_code.co_freevars,
923
attribute.__closure__))["func"]
924
.cell_contents)
925
# Create a new, but exactly alike, function
926
# object, and decorate it to be a new D-Bus signal
927
# with the alternate D-Bus interface name
928
new_function = (dbus.service.signal
929
(alt_interface,
930
attribute._dbus_signature)
931
(types.FunctionType(
932
nonmethod_func.func_code,
933
nonmethod_func.func_globals,
934
nonmethod_func.func_name,
935
nonmethod_func.func_defaults,
936
nonmethod_func.func_closure)))
937
# Define a creator of a function to call both the
938
# old and new functions, so both the old and new
939
# signals gets sent when the function is called
940
def fixscope(func1, func2):
941
"""This function is a scope container to pass
942
func1 and func2 to the "call_both" function
943
outside of its arguments"""
944
def call_both(*args, **kwargs):
945
"""This function will emit two D-Bus
946
signals by calling func1 and func2"""
947
func1(*args, **kwargs)
948
func2(*args, **kwargs)
949
return call_both
950
# Create the "call_both" function and add it to
951
# the class
952
attr[attrname] = fixscope(attribute,
953
new_function)
954
# Is this a D-Bus method?
955
elif getattr(attribute, "_dbus_is_method", False):
956
# Create a new, but exactly alike, function
957
# object. Decorate it to be a new D-Bus method
958
# with the alternate D-Bus interface name. Add it
959
# to the class.
960
attr[attrname] = (dbus.service.method
961
(alt_interface,
962
attribute._dbus_in_signature,
963
attribute._dbus_out_signature)
964
(types.FunctionType
965
(attribute.func_code,
966
attribute.func_globals,
967
attribute.func_name,
968
attribute.func_defaults,
969
attribute.func_closure)))
970
# Is this a D-Bus property?
971
elif getattr(attribute, "_dbus_is_property", False):
972
# Create a new, but exactly alike, function
973
# object, and decorate it to be a new D-Bus
974
# property with the alternate D-Bus interface
975
# name. Add it to the class.
976
attr[attrname] = (dbus_service_property
977
(alt_interface,
978
attribute._dbus_signature,
979
attribute._dbus_access,
980
attribute
981
._dbus_get_args_options
982
["byte_arrays"])
983
(types.FunctionType
984
(attribute.func_code,
985
attribute.func_globals,
986
attribute.func_name,
987
attribute.func_defaults,
988
attribute.func_closure)))
989
return type.__new__(mcs, name, bases, attr)
990
991
992
class ClientDBus(Client, DBusObjectWithProperties):
993
"""A Client class using D-Bus
994
995
Attributes:
996
dbus_object_path: dbus.ObjectPath
997
bus: dbus.SystemBus()
998
"""
999
1000
runtime_expansions = (Client.runtime_expansions
1001
+ ("dbus_object_path",))
1002
1003
# dbus.service.Object doesn't use super(), so we can't either.
1004
1005
def __init__(self, bus = None, *args, **kwargs):
1006
self.bus = bus
1007
Client.__init__(self, *args, **kwargs)
1008
1009
self._approvals_pending = 0
1010
# Only now, when this client is initialized, can it show up on
1011
# the D-Bus
1012
client_object_name = unicode(self.name).translate(
1013
{ord("."): ord("_"),
1014
ord("-"): ord("_")})
1015
self.dbus_object_path = (dbus.ObjectPath
1016
("/clients/" + client_object_name))
1017
DBusObjectWithProperties.__init__(self, self.bus,
1018
self.dbus_object_path)
1019
1020
def notifychangeproperty(transform_func,
1021
dbus_name, type_func=lambda x: x,
1022
variant_level=1):
1023
""" Modify a variable so that it's a property which announces
1024
its changes to DBus.
1025
1026
transform_fun: Function that takes a value and a variant_level
1027
and transforms it to a D-Bus type.
1028
dbus_name: D-Bus name of the variable
1029
type_func: Function that transform the value before sending it
1030
to the D-Bus. Default: no transform
1031
variant_level: D-Bus variant level. Default: 1
1032
"""
1033
attrname = "_{0}".format(dbus_name)
1034
def setter(self, value):
1035
if hasattr(self, "dbus_object_path"):
1036
if (not hasattr(self, attrname) or
1037
type_func(getattr(self, attrname, None))
1038
!= type_func(value)):
1039
dbus_value = transform_func(type_func(value),
1040
variant_level
1041
=variant_level)
1042
self.PropertyChanged(dbus.String(dbus_name),
1043
dbus_value)
1044
setattr(self, attrname, value)
1045
1046
return property(lambda self: getattr(self, attrname), setter)
1047
1048
1049
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1050
approvals_pending = notifychangeproperty(dbus.Boolean,
1051
"ApprovalPending",
1052
type_func = bool)
1053
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1054
last_enabled = notifychangeproperty(datetime_to_dbus,
1055
"LastEnabled")
1056
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1057
type_func = lambda checker:
1058
checker is not None)
1059
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1060
"LastCheckedOK")
1061
last_approval_request = notifychangeproperty(
1062
datetime_to_dbus, "LastApprovalRequest")
1063
approved_by_default = notifychangeproperty(dbus.Boolean,
1064
"ApprovedByDefault")
1065
approval_delay = notifychangeproperty(dbus.UInt16,
1066
"ApprovalDelay",
1067
type_func =
1068
_timedelta_to_milliseconds)
1069
approval_duration = notifychangeproperty(
1070
dbus.UInt16, "ApprovalDuration",
1071
type_func = _timedelta_to_milliseconds)
1072
host = notifychangeproperty(dbus.String, "Host")
1073
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
1074
type_func =
1075
_timedelta_to_milliseconds)
1076
extended_timeout = notifychangeproperty(
1077
dbus.UInt16, "ExtendedTimeout",
1078
type_func = _timedelta_to_milliseconds)
1079
interval = notifychangeproperty(dbus.UInt16,
1080
"Interval",
1081
type_func =
1082
_timedelta_to_milliseconds)
1083
checker_command = notifychangeproperty(dbus.String, "Checker")
1084
1085
del notifychangeproperty
1086
1087
def __del__(self, *args, **kwargs):
1088
try:
1089
self.remove_from_connection()
1090
except LookupError:
1091
pass
1092
if hasattr(DBusObjectWithProperties, "__del__"):
1093
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1094
Client.__del__(self, *args, **kwargs)
1095
1096
def checker_callback(self, pid, condition, command,
1097
*args, **kwargs):
1098
self.checker_callback_tag = None
1099
self.checker = None
1100
if os.WIFEXITED(condition):
1101
exitstatus = os.WEXITSTATUS(condition)
1102
# Emit D-Bus signal
1103
self.CheckerCompleted(dbus.Int16(exitstatus),
1104
dbus.Int64(condition),
1105
dbus.String(command))
1106
else:
1107
# Emit D-Bus signal
1108
self.CheckerCompleted(dbus.Int16(-1),
1109
dbus.Int64(condition),
1110
dbus.String(command))
1111
1112
return Client.checker_callback(self, pid, condition, command,
1113
*args, **kwargs)
1114
1115
def start_checker(self, *args, **kwargs):
1116
old_checker = self.checker
1117
if self.checker is not None:
1118
old_checker_pid = self.checker.pid
1119
else:
1120
old_checker_pid = None
1121
r = Client.start_checker(self, *args, **kwargs)
1122
# Only if new checker process was started
1123
if (self.checker is not None
1124
and old_checker_pid != self.checker.pid):
1125
# Emit D-Bus signal
1126
self.CheckerStarted(self.current_checker_command)
1127
return r
1128
1129
def _reset_approved(self):
1130
self._approved = None
1131
return False
1132
1133
def approve(self, value=True):
1134
self.send_changedstate()
1135
self._approved = value
1136
gobject.timeout_add(_timedelta_to_milliseconds
1137
(self.approval_duration),
1138
self._reset_approved)
1139
1140
1141
## D-Bus methods, signals & properties
1142
_interface = "se.recompile.Mandos.Client"
1143
1144
## Signals
1145
1146
# CheckerCompleted - signal
1147
@dbus.service.signal(_interface, signature="nxs")
1148
def CheckerCompleted(self, exitcode, waitstatus, command):
1149
"D-Bus signal"
1150
pass
1151
1152
# CheckerStarted - signal
1153
@dbus.service.signal(_interface, signature="s")
1154
def CheckerStarted(self, command):
1155
"D-Bus signal"
1156
pass
1157
1158
# PropertyChanged - signal
1159
@dbus.service.signal(_interface, signature="sv")
1160
def PropertyChanged(self, property, value):
1161
"D-Bus signal"
1162
pass
1163
1164
# GotSecret - signal
1165
@dbus.service.signal(_interface)
1166
def GotSecret(self):
1167
"""D-Bus signal
1168
Is sent after a successful transfer of secret from the Mandos
1169
server to mandos-client
1170
"""
1171
pass
1172
1173
# Rejected - signal
1174
@dbus.service.signal(_interface, signature="s")
1175
def Rejected(self, reason):
1176
"D-Bus signal"
1177
pass
1178
1179
# NeedApproval - signal
1180
@dbus.service.signal(_interface, signature="tb")
1181
def NeedApproval(self, timeout, default):
1182
"D-Bus signal"
1183
return self.need_approval()
1184
1185
# NeRwequest - signal
1186
@dbus.service.signal(_interface, signature="s")
1187
def NewRequest(self, ip):
1188
"""D-Bus signal
1189
Is sent after a client request a password.
1190
"""
1191
pass
1192
1193
## Methods
1194
1195
# Approve - method
1196
@dbus.service.method(_interface, in_signature="b")
1197
def Approve(self, value):
1198
self.approve(value)
1199
1200
# CheckedOK - method
1201
@dbus.service.method(_interface)
1202
def CheckedOK(self):
1203
self.checked_ok()
1204
1205
# Enable - method
1206
@dbus.service.method(_interface)
1207
def Enable(self):
1208
"D-Bus method"
1209
self.enable()
1210
1211
# StartChecker - method
1212
@dbus.service.method(_interface)
1213
def StartChecker(self):
1214
"D-Bus method"
1215
self.start_checker()
1216
1217
# Disable - method
1218
@dbus.service.method(_interface)
1219
def Disable(self):
1220
"D-Bus method"
1221
self.disable()
1222
1223
# StopChecker - method
1224
@dbus.service.method(_interface)
1225
def StopChecker(self):
1226
self.stop_checker()
1227
1228
## Properties
1229
1230
# ApprovalPending - property
1231
@dbus_service_property(_interface, signature="b", access="read")
1232
def ApprovalPending_dbus_property(self):
1233
return dbus.Boolean(bool(self.approvals_pending))
1234
1235
# ApprovedByDefault - property
1236
@dbus_service_property(_interface, signature="b",
1237
access="readwrite")
1238
def ApprovedByDefault_dbus_property(self, value=None):
1239
if value is None: # get
1240
return dbus.Boolean(self.approved_by_default)
1241
self.approved_by_default = bool(value)
1242
1243
# ApprovalDelay - property
1244
@dbus_service_property(_interface, signature="t",
1245
access="readwrite")
1246
def ApprovalDelay_dbus_property(self, value=None):
1247
if value is None: # get
1248
return dbus.UInt64(self.approval_delay_milliseconds())
1249
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1250
1251
# ApprovalDuration - property
1252
@dbus_service_property(_interface, signature="t",
1253
access="readwrite")
1254
def ApprovalDuration_dbus_property(self, value=None):
1255
if value is None: # get
1256
return dbus.UInt64(_timedelta_to_milliseconds(
1257
self.approval_duration))
1258
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1259
1260
# Name - property
1261
@dbus_service_property(_interface, signature="s", access="read")
1262
def Name_dbus_property(self):
1263
return dbus.String(self.name)
1264
1265
# Fingerprint - property
1266
@dbus_service_property(_interface, signature="s", access="read")
1267
def Fingerprint_dbus_property(self):
1268
return dbus.String(self.fingerprint)
1269
1270
# Host - property
1271
@dbus_service_property(_interface, signature="s",
1272
access="readwrite")
1273
def Host_dbus_property(self, value=None):
1274
if value is None: # get
1275
return dbus.String(self.host)
1276
self.host = value
1277
1278
# Created - property
1279
@dbus_service_property(_interface, signature="s", access="read")
1280
def Created_dbus_property(self):
1281
return dbus.String(datetime_to_dbus(self.created))
1282
1283
# LastEnabled - property
1284
@dbus_service_property(_interface, signature="s", access="read")
1285
def LastEnabled_dbus_property(self):
1286
return datetime_to_dbus(self.last_enabled)
1287
1288
# Enabled - property
1289
@dbus_service_property(_interface, signature="b",
1290
access="readwrite")
1291
def Enabled_dbus_property(self, value=None):
1292
if value is None: # get
1293
return dbus.Boolean(self.enabled)
1294
if value:
1295
self.enable()
1296
else:
1297
self.disable()
1298
1299
# LastCheckedOK - property
1300
@dbus_service_property(_interface, signature="s",
1301
access="readwrite")
1302
def LastCheckedOK_dbus_property(self, value=None):
1303
if value is not None:
1304
self.checked_ok()
1305
return
1306
return datetime_to_dbus(self.last_checked_ok)
1307
1308
# Expires - property
1309
@dbus_service_property(_interface, signature="s", access="read")
1310
def Expires_dbus_property(self):
1311
return datetime_to_dbus(self.expires)
1312
1313
# LastApprovalRequest - property
1314
@dbus_service_property(_interface, signature="s", access="read")
1315
def LastApprovalRequest_dbus_property(self):
1316
return datetime_to_dbus(self.last_approval_request)
1317
1318
# Timeout - property
1319
@dbus_service_property(_interface, signature="t",
1320
access="readwrite")
1321
def Timeout_dbus_property(self, value=None):
1322
if value is None: # get
1323
return dbus.UInt64(self.timeout_milliseconds())
1324
self.timeout = datetime.timedelta(0, 0, 0, value)
1325
if getattr(self, "disable_initiator_tag", None) is None:
1326
return
1327
# Reschedule timeout
1328
gobject.source_remove(self.disable_initiator_tag)
1329
self.disable_initiator_tag = None
1330
self.expires = None
1331
time_to_die = _timedelta_to_milliseconds((self
1332
.last_checked_ok
1333
+ self.timeout)
1334
- datetime.datetime
1335
.utcnow())
1336
if time_to_die <= 0:
1337
# The timeout has passed
1338
self.disable()
1339
else:
1340
self.expires = (datetime.datetime.utcnow()
1341
+ datetime.timedelta(milliseconds =
1342
time_to_die))
1343
self.disable_initiator_tag = (gobject.timeout_add
1344
(time_to_die, self.disable))
1345
1346
# ExtendedTimeout - property
1347
@dbus_service_property(_interface, signature="t",
1348
access="readwrite")
1349
def ExtendedTimeout_dbus_property(self, value=None):
1350
if value is None: # get
1351
return dbus.UInt64(self.extended_timeout_milliseconds())
1352
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1353
1354
# Interval - property
1355
@dbus_service_property(_interface, signature="t",
1356
access="readwrite")
1357
def Interval_dbus_property(self, value=None):
1358
if value is None: # get
1359
return dbus.UInt64(self.interval_milliseconds())
1360
self.interval = datetime.timedelta(0, 0, 0, value)
1361
if getattr(self, "checker_initiator_tag", None) is None:
1362
return
1363
# Reschedule checker run
1364
gobject.source_remove(self.checker_initiator_tag)
1365
self.checker_initiator_tag = (gobject.timeout_add
1366
(value, self.start_checker))
1367
self.start_checker() # Start one now, too
1368
1369
# Checker - property
1370
@dbus_service_property(_interface, signature="s",
1371
access="readwrite")
1372
def Checker_dbus_property(self, value=None):
1373
if value is None: # get
1374
return dbus.String(self.checker_command)
1375
self.checker_command = value
1376
1377
# CheckerRunning - property
1378
@dbus_service_property(_interface, signature="b",
1379
access="readwrite")
1380
def CheckerRunning_dbus_property(self, value=None):
1381
if value is None: # get
1382
return dbus.Boolean(self.checker is not None)
1383
if value:
1384
self.start_checker()
1385
else:
1386
self.stop_checker()
1387
1388
# ObjectPath - property
1389
@dbus_service_property(_interface, signature="o", access="read")
1390
def ObjectPath_dbus_property(self):
1391
return self.dbus_object_path # is already a dbus.ObjectPath
1392
1393
# Secret = property
1394
@dbus_service_property(_interface, signature="ay",
1395
access="write", byte_arrays=True)
1396
def Secret_dbus_property(self, value):
1397
self.secret = str(value)
1398
1399
del _interface
1400
1401
1402
class ProxyClient(object):
1403
def __init__(self, child_pipe, fpr, address):
1404
self._pipe = child_pipe
1405
self._pipe.send(('init', fpr, address))
1406
if not self._pipe.recv():
1407
raise KeyError()
1408
1409
def __getattribute__(self, name):
1410
if(name == '_pipe'):
1411
return super(ProxyClient, self).__getattribute__(name)
1412
self._pipe.send(('getattr', name))
1413
data = self._pipe.recv()
1414
if data[0] == 'data':
1415
return data[1]
1416
if data[0] == 'function':
1417
def func(*args, **kwargs):
1418
self._pipe.send(('funcall', name, args, kwargs))
1419
return self._pipe.recv()[1]
1420
return func
1421
1422
def __setattr__(self, name, value):
1423
if(name == '_pipe'):
1424
return super(ProxyClient, self).__setattr__(name, value)
1425
self._pipe.send(('setattr', name, value))
1426
1427
1428
class ClientDBusTransitional(ClientDBus):
1429
__metaclass__ = AlternateDBusNamesMetaclass
1430
1431
1432
class ClientHandler(socketserver.BaseRequestHandler, object):
1433
"""A class to handle client connections.
1434
1435
Instantiated once for each connection to handle it.
379
def still_valid(self):
380
"""Has the timeout not yet passed for this client?"""
381
now = datetime.datetime.now()
382
if self.last_checked_ok is None:
383
return now < (self.created + self.timeout)
384
else:
385
return now < (self.last_checked_ok + self.timeout)
386
387
388
def peer_certificate(session):
389
"Return the peer's OpenPGP certificate as a bytestring"
390
# If not an OpenPGP certificate...
391
if gnutls.library.functions.gnutls_certificate_type_get\
392
(session._c_object) \
393
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
394
# ...do the normal thing
395
return session.peer_certificate
396
list_size = ctypes.c_uint()
397
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
398
(session._c_object, ctypes.byref(list_size))
399
if list_size.value == 0:
400
return None
401
cert = cert_list[0]
402
return ctypes.string_at(cert.data, cert.size)
403
404
405
def fingerprint(openpgp):
406
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
407
# New GnuTLS "datum" with the OpenPGP public key
408
datum = gnutls.library.types.gnutls_datum_t\
409
(ctypes.cast(ctypes.c_char_p(openpgp),
410
ctypes.POINTER(ctypes.c_ubyte)),
411
ctypes.c_uint(len(openpgp)))
412
# New empty GnuTLS certificate
413
crt = gnutls.library.types.gnutls_openpgp_crt_t()
414
gnutls.library.functions.gnutls_openpgp_crt_init\
415
(ctypes.byref(crt))
416
# Import the OpenPGP public key into the certificate
417
gnutls.library.functions.gnutls_openpgp_crt_import\
418
(crt, ctypes.byref(datum),
419
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
420
# Verify the self signature in the key
421
crtverify = ctypes.c_uint()
422
gnutls.library.functions.gnutls_openpgp_crt_verify_self\
423
(crt, 0, ctypes.byref(crtverify))
424
if crtverify.value != 0:
425
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
426
raise gnutls.errors.CertificateSecurityError("Verify failed")
427
# New buffer for the fingerprint
428
buf = ctypes.create_string_buffer(20)
429
buf_len = ctypes.c_size_t()
430
# Get the fingerprint from the certificate into the buffer
431
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
432
(crt, ctypes.byref(buf), ctypes.byref(buf_len))
433
# Deinit the certificate
434
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
435
# Convert the buffer to a Python bytestring
436
fpr = ctypes.string_at(buf, buf_len.value)
437
# Convert the bytestring to hexadecimal notation
438
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
439
return hex_fpr
440
441
442
class TCP_handler(SocketServer.BaseRequestHandler, object):
443
"""A TCP request handler class.
444
Instantiated by IPv6_TCPServer for each request to handle it.
1436
445
Note: This will run in its own forked process."""
1437
446
1438
447
def handle(self):
1439
with contextlib.closing(self.server.child_pipe) as child_pipe:
1440
logger.info("TCP connection from: %s",
1441
unicode(self.client_address))
1442
logger.debug("Pipe FD: %d",
1443
self.server.child_pipe.fileno())
1444
1445
session = (gnutls.connection
1446
.ClientSession(self.request,
1447
gnutls.connection
1448
.X509Credentials()))
1449
1450
# Note: gnutls.connection.X509Credentials is really a
1451
# generic GnuTLS certificate credentials object so long as
1452
# no X.509 keys are added to it. Therefore, we can use it
1453
# here despite using OpenPGP certificates.
1454
1455
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1456
# "+AES-256-CBC", "+SHA1",
1457
# "+COMP-NULL", "+CTYPE-OPENPGP",
1458
# "+DHE-DSS"))
1459
# Use a fallback default, since this MUST be set.
1460
priority = self.server.gnutls_priority
1461
if priority is None:
1462
priority = "NORMAL"
1463
(gnutls.library.functions
1464
.gnutls_priority_set_direct(session._c_object,
1465
priority, None))
1466
1467
# Start communication using the Mandos protocol
1468
# Get protocol number
1469
line = self.request.makefile().readline()
1470
logger.debug("Protocol version: %r", line)
1471
try:
1472
if int(line.strip().split()[0]) > 1:
1473
raise RuntimeError
1474
except (ValueError, IndexError, RuntimeError) as error:
1475
logger.error("Unknown protocol version: %s", error)
1476
return
1477
1478
# Start GnuTLS connection
1479
try:
1480
session.handshake()
1481
except gnutls.errors.GNUTLSError as error:
1482
logger.warning("Handshake failed: %s", error)
1483
# Do not run session.bye() here: the session is not
1484
# established. Just abandon the request.
1485
return
1486
logger.debug("Handshake succeeded")
1487
1488
approval_required = False
1489
try:
1490
try:
1491
fpr = self.fingerprint(self.peer_certificate
1492
(session))
1493
except (TypeError,
1494
gnutls.errors.GNUTLSError) as error:
1495
logger.warning("Bad certificate: %s", error)
1496
return
1497
logger.debug("Fingerprint: %s", fpr)
1498
if self.server.use_dbus:
1499
# Emit D-Bus signal
1500
client.NewRequest(str(self.client_address))
1501
1502
try:
1503
client = ProxyClient(child_pipe, fpr,
1504
self.client_address)
1505
except KeyError:
1506
return
1507
1508
if client.approval_delay:
1509
delay = client.approval_delay
1510
client.approvals_pending += 1
1511
approval_required = True
1512
1513
while True:
1514
if not client.enabled:
1515
logger.info("Client %s is disabled",
1516
client.name)
1517
if self.server.use_dbus:
1518
# Emit D-Bus signal
1519
client.Rejected("Disabled")
1520
return
1521
1522
if client._approved or not client.approval_delay:
1523
#We are approved or approval is disabled
1524
break
1525
elif client._approved is None:
1526
logger.info("Client %s needs approval",
1527
client.name)
1528
if self.server.use_dbus:
1529
# Emit D-Bus signal
1530
client.NeedApproval(
1531
client.approval_delay_milliseconds(),
1532
client.approved_by_default)
1533
else:
1534
logger.warning("Client %s was not approved",
1535
client.name)
1536
if self.server.use_dbus:
1537
# Emit D-Bus signal
1538
client.Rejected("Denied")
1539
return
1540
1541
#wait until timeout or approved
1542
time = datetime.datetime.now()
1543
client.changedstate.acquire()
1544
(client.changedstate.wait
1545
(float(client._timedelta_to_milliseconds(delay)
1546
/ 1000)))
1547
client.changedstate.release()
1548
time2 = datetime.datetime.now()
1549
if (time2 - time) >= delay:
1550
if not client.approved_by_default:
1551
logger.warning("Client %s timed out while"
1552
" waiting for approval",
1553
client.name)
1554
if self.server.use_dbus:
1555
# Emit D-Bus signal
1556
client.Rejected("Approval timed out")
1557
return
1558
else:
1559
break
1560
else:
1561
delay -= time2 - time
1562
1563
sent_size = 0
1564
while sent_size < len(client.secret):
1565
try:
1566
sent = session.send(client.secret[sent_size:])
1567
except gnutls.errors.GNUTLSError as error:
1568
logger.warning("gnutls send failed")
1569
return
1570
logger.debug("Sent: %d, remaining: %d",
1571
sent, len(client.secret)
1572
- (sent_size + sent))
1573
sent_size += sent
1574
1575
logger.info("Sending secret to %s", client.name)
1576
# bump the timeout using extended_timeout
1577
client.checked_ok(client.extended_timeout)
1578
if self.server.use_dbus:
1579
# Emit D-Bus signal
1580
client.GotSecret()
1581
1582
finally:
1583
if approval_required:
1584
client.approvals_pending -= 1
1585
try:
1586
session.bye()
1587
except gnutls.errors.GNUTLSError as error:
1588
logger.warning("GnuTLS bye failed")
1589
1590
@staticmethod
1591
def peer_certificate(session):
1592
"Return the peer's OpenPGP certificate as a bytestring"
1593
# If not an OpenPGP certificate...
1594
if (gnutls.library.functions
1595
.gnutls_certificate_type_get(session._c_object)
1596
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1597
# ...do the normal thing
1598
return session.peer_certificate
1599
list_size = ctypes.c_uint(1)
1600
cert_list = (gnutls.library.functions
1601
.gnutls_certificate_get_peers
1602
(session._c_object, ctypes.byref(list_size)))
1603
if not bool(cert_list) and list_size.value != 0:
1604
raise gnutls.errors.GNUTLSError("error getting peer"
1605
" certificate")
1606
if list_size.value == 0:
1607
return None
1608
cert = cert_list[0]
1609
return ctypes.string_at(cert.data, cert.size)
1610
1611
@staticmethod
1612
def fingerprint(openpgp):
1613
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1614
# New GnuTLS "datum" with the OpenPGP public key
1615
datum = (gnutls.library.types
1616
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1617
ctypes.POINTER
1618
(ctypes.c_ubyte)),
1619
ctypes.c_uint(len(openpgp))))
1620
# New empty GnuTLS certificate
1621
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1622
(gnutls.library.functions
1623
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1624
# Import the OpenPGP public key into the certificate
1625
(gnutls.library.functions
1626
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1627
gnutls.library.constants
1628
.GNUTLS_OPENPGP_FMT_RAW))
1629
# Verify the self signature in the key
1630
crtverify = ctypes.c_uint()
1631
(gnutls.library.functions
1632
.gnutls_openpgp_crt_verify_self(crt, 0,
1633
ctypes.byref(crtverify)))
1634
if crtverify.value != 0:
1635
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1636
raise (gnutls.errors.CertificateSecurityError
1637
("Verify failed"))
1638
# New buffer for the fingerprint
1639
buf = ctypes.create_string_buffer(20)
1640
buf_len = ctypes.c_size_t()
1641
# Get the fingerprint from the certificate into the buffer
1642
(gnutls.library.functions
1643
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1644
ctypes.byref(buf_len)))
1645
# Deinit the certificate
1646
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1647
# Convert the buffer to a Python bytestring
1648
fpr = ctypes.string_at(buf, buf_len.value)
1649
# Convert the bytestring to hexadecimal notation
1650
hex_fpr = binascii.hexlify(fpr).upper()
1651
return hex_fpr
1652
1653
1654
class MultiprocessingMixIn(object):
1655
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1656
def sub_process_main(self, request, address):
1657
try:
1658
self.finish_request(request, address)
1659
except:
1660
self.handle_error(request, address)
1661
self.close_request(request)
1662
1663
def process_request(self, request, address):
1664
"""Start a new process to process the request."""
1665
proc = multiprocessing.Process(target = self.sub_process_main,
1666
args = (request,
1667
address))
1668
proc.start()
1669
return proc
1670
1671
1672
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1673
""" adds a pipe to the MixIn """
1674
def process_request(self, request, client_address):
1675
"""Overrides and wraps the original process_request().
1676
1677
This function creates a new pipe in self.pipe
1678
"""
1679
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1680
1681
proc = MultiprocessingMixIn.process_request(self, request,
1682
client_address)
1683
self.child_pipe.close()
1684
self.add_pipe(parent_pipe, proc)
1685
1686
def add_pipe(self, parent_pipe, proc):
1687
"""Dummy function; override as necessary"""
1688
raise NotImplementedError
1689
1690
1691
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1692
socketserver.TCPServer, object):
1693
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1694
448
logger.info(u"TCP connection from: %s",
449
unicode(self.client_address))
450
session = gnutls.connection.ClientSession\
451
(self.request, gnutls.connection.X509Credentials())
452
453
line = self.request.makefile().readline()
454
logger.debug(u"Protocol version: %r", line)
455
try:
456
if int(line.strip().split()[0]) > 1:
457
raise RuntimeError
458
except (ValueError, IndexError, RuntimeError), error:
459
logger.error(u"Unknown protocol version: %s", error)
460
return
461
462
# Note: gnutls.connection.X509Credentials is really a generic
463
# GnuTLS certificate credentials object so long as no X.509
464
# keys are added to it. Therefore, we can use it here despite
465
# using OpenPGP certificates.
466
467
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
468
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
469
# "+DHE-DSS"))
470
priority = "NORMAL" # Fallback default, since this
471
# MUST be set.
472
if self.server.settings["priority"]:
473
priority = self.server.settings["priority"]
474
gnutls.library.functions.gnutls_priority_set_direct\
475
(session._c_object, priority, None)
476
477
try:
478
session.handshake()
479
except gnutls.errors.GNUTLSError, error:
480
logger.warning(u"Handshake failed: %s", error)
481
# Do not run session.bye() here: the session is not
482
# established. Just abandon the request.
483
return
484
try:
485
fpr = fingerprint(peer_certificate(session))
486
except (TypeError, gnutls.errors.GNUTLSError), error:
487
logger.warning(u"Bad certificate: %s", error)
488
session.bye()
489
return
490
logger.debug(u"Fingerprint: %s", fpr)
491
client = None
492
for c in self.server.clients:
493
if c.fingerprint == fpr:
494
client = c
495
break
496
if not client:
497
logger.warning(u"Client not found for fingerprint: %s",
498
fpr)
499
session.bye()
500
return
501
# Have to check if client.still_valid(), since it is possible
502
# that the client timed out while establishing the GnuTLS
503
# session.
504
if not client.still_valid():
505
logger.warning(u"Client %(name)s is invalid",
506
vars(client))
507
session.bye()
508
return
509
sent_size = 0
510
while sent_size < len(client.secret):
511
sent = session.send(client.secret[sent_size:])
512
logger.debug(u"Sent: %d, remaining: %d",
513
sent, len(client.secret)
514
- (sent_size + sent))
515
sent_size += sent
516
session.bye()
517
518
519
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
520
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1695
521
Attributes:
522
settings: Server settings
523
clients: Set() of Client objects
1696
524
enabled: Boolean; whether this server is activated yet
1697
interface: None or a network interface name (string)
1698
use_ipv6: Boolean; to use IPv6 or not
1699
525
"""
1700
def __init__(self, server_address, RequestHandlerClass,
1701
interface=None, use_ipv6=True):
1702
self.interface = interface
1703
if use_ipv6:
1704
self.address_family = socket.AF_INET6
1705
socketserver.TCPServer.__init__(self, server_address,
1706
RequestHandlerClass)
526
address_family = socket.AF_INET6
527
def __init__(self, *args, **kwargs):
528
if "settings" in kwargs:
529
self.settings = kwargs["settings"]
530
del kwargs["settings"]
531
if "clients" in kwargs:
532
self.clients = kwargs["clients"]
533
del kwargs["clients"]
534
self.enabled = False
535
super(IPv6_TCPServer, self).__init__(*args, **kwargs)
1707
536
def server_bind(self):
1708
537
"""This overrides the normal server_bind() function
1709
538
to bind to an interface if one was specified, and also NOT to
1710
539
bind to an address or port if they were not specified."""
1711
if self.interface is not None:
1712
if SO_BINDTODEVICE is None:
1713
logger.error("SO_BINDTODEVICE does not exist;"
1714
" cannot bind to interface %s",
1715
self.interface)
1716
else:
1717
try:
1718
self.socket.setsockopt(socket.SOL_SOCKET,
1719
SO_BINDTODEVICE,
1720
str(self.interface
1721
+ '\0'))
1722
except socket.error as error:
1723
if error[0] == errno.EPERM:
1724
logger.error("No permission to"
1725
" bind to interface %s",
1726
self.interface)
1727
elif error[0] == errno.ENOPROTOOPT:
1728
logger.error("SO_BINDTODEVICE not available;"
1729
" cannot bind to interface %s",
1730
self.interface)
1731
else:
1732
raise
540
if self.settings["interface"]:
541
# 25 is from /usr/include/asm-i486/socket.h
542
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
543
try:
544
self.socket.setsockopt(socket.SOL_SOCKET,
545
SO_BINDTODEVICE,
546
self.settings["interface"])
547
except socket.error, error:
548
if error[0] == errno.EPERM:
549
logger.error(u"No permission to"
550
u" bind to interface %s",
551
self.settings["interface"])
552
else:
553
raise error
1733
554
# Only bind(2) the socket if we really need to.
1734
555
if self.server_address[0] or self.server_address[1]:
1735
556
if not self.server_address[0]:
1736
if self.address_family == socket.AF_INET6:
1737
any_address = "::" # in6addr_any
1738
else:
1739
any_address = socket.INADDR_ANY
1740
self.server_address = (any_address,
557
in6addr_any = "::"
558
self.server_address = (in6addr_any,
1741
559
self.server_address[1])
1742
560
elif not self.server_address[1]:
1743
561
self.server_address = (self.server_address[0],
1744
562
0)
1745
# if self.interface:
563
# if self.settings["interface"]:
1746
564
# self.server_address = (self.server_address[0],
1747
565
# 0, # port
1748
566
# 0, # flowinfo
1749
567
# if_nametoindex
1750
# (self.interface))
1751
return socketserver.TCPServer.server_bind(self)
1752
1753
1754
class MandosServer(IPv6_TCPServer):
1755
"""Mandos server.
1756
1757
Attributes:
1758
clients: set of Client objects
1759
gnutls_priority GnuTLS priority string
1760
use_dbus: Boolean; to emit D-Bus signals or not
1761
1762
Assumes a gobject.MainLoop event loop.
1763
"""
1764
def __init__(self, server_address, RequestHandlerClass,
1765
interface=None, use_ipv6=True, clients=None,
1766
gnutls_priority=None, use_dbus=True):
1767
self.enabled = False
1768
self.clients = clients
1769
if self.clients is None:
1770
self.clients = {}
1771
self.use_dbus = use_dbus
1772
self.gnutls_priority = gnutls_priority
1773
IPv6_TCPServer.__init__(self, server_address,
1774
RequestHandlerClass,
1775
interface = interface,
1776
use_ipv6 = use_ipv6)
568
# (self.settings
569
# ["interface"]))
570
return super(IPv6_TCPServer, self).server_bind()
1777
571
def server_activate(self):
1778
572
if self.enabled:
1779
return socketserver.TCPServer.server_activate(self)
1780
573
return super(IPv6_TCPServer, self).server_activate()
1781
574
def enable(self):
1782
575
self.enabled = True
1783
1784
def add_pipe(self, parent_pipe, proc):
1785
# Call "handle_ipc" for both data and EOF events
1786
gobject.io_add_watch(parent_pipe.fileno(),
1787
gobject.IO_IN | gobject.IO_HUP,
1788
functools.partial(self.handle_ipc,
1789
parent_pipe =
1790
parent_pipe,
1791
proc = proc))
1792
1793
def handle_ipc(self, source, condition, parent_pipe=None,
1794
proc = None, client_object=None):
1795
condition_names = {
1796
gobject.IO_IN: "IN", # There is data to read.
1797
gobject.IO_OUT: "OUT", # Data can be written (without
1798
# blocking).
1799
gobject.IO_PRI: "PRI", # There is urgent data to read.
1800
gobject.IO_ERR: "ERR", # Error condition.
1801
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1802
# broken, usually for pipes and
1803
# sockets).
1804
}
1805
conditions_string = ' | '.join(name
1806
for cond, name in
1807
condition_names.iteritems()
1808
if cond & condition)
1809
# error, or the other end of multiprocessing.Pipe has closed
1810
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1811
# Wait for other process to exit
1812
proc.join()
1813
return False
1814
1815
# Read a request from the child
1816
request = parent_pipe.recv()
1817
command = request[0]
1818
1819
if command == 'init':
1820
fpr = request[1]
1821
address = request[2]
1822
1823
for c in self.clients.itervalues():
1824
if c.fingerprint == fpr:
1825
client = c
1826
break
1827
else:
1828
logger.info("Client not found for fingerprint: %s, ad"
1829
"dress: %s", fpr, address)
1830
if self.use_dbus:
1831
# Emit D-Bus signal
1832
mandos_dbus_service.ClientNotFound(fpr,
1833
address[0])
1834
parent_pipe.send(False)
1835
return False
1836
1837
gobject.io_add_watch(parent_pipe.fileno(),
1838
gobject.IO_IN | gobject.IO_HUP,
1839
functools.partial(self.handle_ipc,
1840
parent_pipe =
1841
parent_pipe,
1842
proc = proc,
1843
client_object =
1844
client))
1845
parent_pipe.send(True)
1846
# remove the old hook in favor of the new above hook on
1847
# same fileno
1848
return False
1849
if command == 'funcall':
1850
funcname = request[1]
1851
args = request[2]
1852
kwargs = request[3]
1853
1854
parent_pipe.send(('data', getattr(client_object,
1855
funcname)(*args,
1856
**kwargs)))
1857
1858
if command == 'getattr':
1859
attrname = request[1]
1860
if callable(client_object.__getattribute__(attrname)):
1861
parent_pipe.send(('function',))
1862
else:
1863
parent_pipe.send(('data', client_object
1864
.__getattribute__(attrname)))
1865
1866
if command == 'setattr':
1867
attrname = request[1]
1868
value = request[2]
1869
setattr(client_object, attrname, value)
1870
1871
return True
1872
576
1873
577
1874
578
def string_to_delta(interval):
1875
579
"""Parse a string and return a datetime.timedelta
1876
580
1877
581
>>> string_to_delta('7d')
1878
582
datetime.timedelta(7)
1879
583
>>> string_to_delta('60s')
1882
586
datetime.timedelta(0, 3600)
1883
587
>>> string_to_delta('24h')
1884
588
datetime.timedelta(1)
1885
>>> string_to_delta('1w')
589
>>> string_to_delta(u'1w')
1886
590
datetime.timedelta(7)
1887
591
>>> string_to_delta('5m 30s')
1888
592
datetime.timedelta(0, 330)
1892
596
try:
1893
597
suffix = unicode(s[-1])
1894
598
value = int(s[:-1])
1895
if suffix == "d":
599
if suffix == u"d":
1896
600
delta = datetime.timedelta(value)
1897
elif suffix == "s":
601
elif suffix == u"s":
1898
602
delta = datetime.timedelta(0, value)
1899
elif suffix == "m":
603
elif suffix == u"m":
1900
604
delta = datetime.timedelta(0, 0, 0, 0, value)
1901
elif suffix == "h":
605
elif suffix == u"h":
1902
606
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1903
elif suffix == "w":
607
elif suffix == u"w":
1904
608
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1905
609
else:
1906
raise ValueError("Unknown suffix %r" % suffix)
1907
except (ValueError, IndexError) as e:
1908
raise ValueError(*(e.args))
610
raise ValueError
611
except (ValueError, IndexError):
612
raise ValueError
1909
613
timevalue += delta
1910
614
return timevalue
1911
615
1912
616
617
def server_state_changed(state):
618
"""Derived from the Avahi example code"""
619
if state == avahi.SERVER_COLLISION:
620
logger.error(u"Zeroconf server name collision")
621
service.remove()
622
elif state == avahi.SERVER_RUNNING:
623
service.add()
624
625
626
def entry_group_state_changed(state, error):
627
"""Derived from the Avahi example code"""
628
logger.debug(u"Avahi state change: %i", state)
629
630
if state == avahi.ENTRY_GROUP_ESTABLISHED:
631
logger.debug(u"Zeroconf service established.")
632
elif state == avahi.ENTRY_GROUP_COLLISION:
633
logger.warning(u"Zeroconf service name collision.")
634
service.rename()
635
elif state == avahi.ENTRY_GROUP_FAILURE:
636
logger.critical(u"Avahi: Error in group state changed %s",
637
unicode(error))
638
raise AvahiGroupError("State changed: %s", str(error))
639
640
def if_nametoindex(interface):
641
"""Call the C function if_nametoindex(), or equivalent"""
642
global if_nametoindex
643
try:
644
if_nametoindex = ctypes.cdll.LoadLibrary\
645
(ctypes.util.find_library("c")).if_nametoindex
646
except (OSError, AttributeError):
647
if "struct" not in sys.modules:
648
import struct
649
if "fcntl" not in sys.modules:
650
import fcntl
651
def if_nametoindex(interface):
652
"Get an interface index the hard way, i.e. using fcntl()"
653
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
654
s = socket.socket()
655
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
656
struct.pack("16s16x", interface))
657
s.close()
658
interface_index = struct.unpack("I", ifreq[16:20])[0]
659
return interface_index
660
return if_nametoindex(interface)
661
662
1913
663
def daemon(nochdir = False, noclose = False):
1914
664
"""See daemon(3). Standard BSD Unix function.
1915
1916
665
This should really exist as os.daemon, but it doesn't (yet)."""
1917
666
if os.fork():
1918
667
sys.exit()
1926
675
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1927
676
if not stat.S_ISCHR(os.fstat(null).st_mode):
1928
677
raise OSError(errno.ENODEV,
1929
"%s not a character device"
1930
% os.path.devnull)
678
"/dev/null not a character device")
1931
679
os.dup2(null, sys.stdin.fileno())
1932
680
os.dup2(null, sys.stdout.fileno())
1933
681
os.dup2(null, sys.stderr.fileno())
1936
684
1937
685
1938
686
def main():
1939
1940
##################################################################
1941
# Parsing of options, both command line and config file
1942
1943
parser = argparse.ArgumentParser()
1944
parser.add_argument("-v", "--version", action="version",
1945
version = "%%(prog)s %s" % version,
1946
help="show version number and exit")
1947
parser.add_argument("-i", "--interface", metavar="IF",
1948
help="Bind to interface IF")
1949
parser.add_argument("-a", "--address",
1950
help="Address to listen for requests on")
1951
parser.add_argument("-p", "--port", type=int,
1952
help="Port number to receive requests on")
1953
parser.add_argument("--check", action="store_true",
1954
help="Run self-test")
1955
parser.add_argument("--debug", action="store_true",
1956
help="Debug mode; run in foreground and log"
1957
" to terminal")
1958
parser.add_argument("--debuglevel", metavar="LEVEL",
1959
help="Debug level for stdout output")
1960
parser.add_argument("--priority", help="GnuTLS"
1961
" priority string (see GnuTLS documentation)")
1962
parser.add_argument("--servicename",
1963
metavar="NAME", help="Zeroconf service name")
1964
parser.add_argument("--configdir",
1965
default="/etc/mandos", metavar="DIR",
1966
help="Directory to search for configuration"
1967
" files")
1968
parser.add_argument("--no-dbus", action="store_false",
1969
dest="use_dbus", help="Do not provide D-Bus"
1970
" system bus interface")
1971
parser.add_argument("--no-ipv6", action="store_false",
1972
dest="use_ipv6", help="Do not use IPv6")
1973
parser.add_argument("--no-restore", action="store_false",
1974
dest="restore", help="Do not restore stored"
1975
" state")
1976
parser.add_argument("--statedir", metavar="DIR",
1977
help="Directory to save/restore state in")
1978
1979
options = parser.parse_args()
687
parser = OptionParser(version = "%%prog %s" % version)
688
parser.add_option("-i", "--interface", type="string",
689
metavar="IF", help="Bind to interface IF")
690
parser.add_option("-a", "--address", type="string",
691
help="Address to listen for requests on")
692
parser.add_option("-p", "--port", type="int",
693
help="Port number to receive requests on")
694
parser.add_option("--check", action="store_true", default=False,
695
help="Run self-test")
696
parser.add_option("--debug", action="store_true",
697
help="Debug mode; run in foreground and log to"
698
" terminal")
699
parser.add_option("--priority", type="string", help="GnuTLS"
700
" priority string (see GnuTLS documentation)")
701
parser.add_option("--servicename", type="string", metavar="NAME",
702
help="Zeroconf service name")
703
parser.add_option("--configdir", type="string",
704
default="/etc/mandos", metavar="DIR",
705
help="Directory to search for configuration"
706
" files")
707
options = parser.parse_args()[0]
1980
708
1981
709
if options.check:
1982
710
import doctest
1991
719
"priority":
1992
720
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1993
721
"servicename": "Mandos",
1994
"use_dbus": "True",
1995
"use_ipv6": "True",
1996
"debuglevel": "",
1997
"restore": "True",
1998
"statedir": "/var/lib/mandos"
1999
722
}
2000
723
2001
724
# Parse config file for server-global settings
2002
server_config = configparser.SafeConfigParser(server_defaults)
725
server_config = ConfigParser.SafeConfigParser(server_defaults)
2003
726
del server_defaults
2004
server_config.read(os.path.join(options.configdir,
2005
"mandos.conf"))
727
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2006
728
# Convert the SafeConfigParser object to a dict
2007
729
server_settings = server_config.defaults()
2008
# Use the appropriate methods on the non-string config options
2009
for option in ("debug", "use_dbus", "use_ipv6"):
2010
server_settings[option] = server_config.getboolean("DEFAULT",
2011
option)
2012
if server_settings["port"]:
2013
server_settings["port"] = server_config.getint("DEFAULT",
2014
"port")
730
# Use getboolean on the boolean config option
731
server_settings["debug"] = server_config.getboolean\
732
("DEFAULT", "debug")
2015
733
del server_config
2016
734
2017
735
# Override the settings from the config file with command line
2018
736
# options, if set.
2019
737
for option in ("interface", "address", "port", "debug",
2020
"priority", "servicename", "configdir",
2021
"use_dbus", "use_ipv6", "debuglevel", "restore",
2022
"statedir"):
738
"priority", "servicename", "configdir"):
2023
739
value = getattr(options, option)
2024
740
if value is not None:
2025
741
server_settings[option] = value
2026
742
del options
2027
# Force all strings to be unicode
2028
for option in server_settings.keys():
2029
if type(server_settings[option]) is str:
2030
server_settings[option] = unicode(server_settings[option])
2031
743
# Now we have our good server settings in "server_settings"
2032
744
2033
##################################################################
2034
2035
# For convenience
2036
745
debug = server_settings["debug"]
2037
debuglevel = server_settings["debuglevel"]
2038
use_dbus = server_settings["use_dbus"]
2039
use_ipv6 = server_settings["use_ipv6"]
2040
stored_state_path = os.path.join(server_settings["statedir"],
2041
stored_state_file)
2042
746
2043
if debug:
2044
initlogger(logging.DEBUG)
2045
else:
2046
if not debuglevel:
2047
initlogger()
2048
else:
2049
level = getattr(logging, debuglevel.upper())
2050
initlogger(level)
747
if not debug:
748
syslogger.setLevel(logging.WARNING)
749
console.setLevel(logging.WARNING)
2051
750
2052
751
if server_settings["servicename"] != "Mandos":
2053
syslogger.setFormatter(logging.Formatter
2054
('Mandos (%s) [%%(process)d]:'
2055
' %%(levelname)s: %%(message)s'
752
syslogger.setFormatter(logging.Formatter\
753
('Mandos (%s): %%(levelname)s:'
754
' %%(message)s'
2056
755
% server_settings["servicename"]))
2057
756
2058
757
# Parse config file with clients
2059
client_defaults = { "timeout": "5m",
2060
"extended_timeout": "15m",
2061
"interval": "2m",
2062
"checker": "fping -q -- %%(host)s",
758
client_defaults = { "timeout": "1h",
759
"interval": "5m",
760
"checker": "fping -q -- %(host)s",
2063
761
"host": "",
2064
"approval_delay": "0s",
2065
"approval_duration": "1s",
2066
762
}
2067
client_config = configparser.SafeConfigParser(client_defaults)
763
client_config = ConfigParser.SafeConfigParser(client_defaults)
2068
764
client_config.read(os.path.join(server_settings["configdir"],
2069
765
"clients.conf"))
2070
766
2071
global mandos_dbus_service
2072
mandos_dbus_service = None
2073
2074
tcp_server = MandosServer((server_settings["address"],
2075
server_settings["port"]),
2076
ClientHandler,
2077
interface=(server_settings["interface"]
2078
or None),
2079
use_ipv6=use_ipv6,
2080
gnutls_priority=
2081
server_settings["priority"],
2082
use_dbus=use_dbus)
2083
if not debug:
2084
pidfilename = "/var/run/mandos.pid"
2085
try:
2086
pidfile = open(pidfilename, "w")
2087
except IOError:
2088
logger.error("Could not open file %r", pidfilename)
2089
2090
try:
2091
uid = pwd.getpwnam("_mandos").pw_uid
2092
gid = pwd.getpwnam("_mandos").pw_gid
2093
except KeyError:
2094
try:
2095
uid = pwd.getpwnam("mandos").pw_uid
2096
gid = pwd.getpwnam("mandos").pw_gid
2097
except KeyError:
2098
try:
2099
uid = pwd.getpwnam("nobody").pw_uid
2100
gid = pwd.getpwnam("nobody").pw_gid
2101
except KeyError:
2102
uid = 65534
2103
gid = 65534
2104
try:
767
clients = Set()
768
tcp_server = IPv6_TCPServer((server_settings["address"],
769
server_settings["port"]),
770
TCP_handler,
771
settings=server_settings,
772
clients=clients)
773
pidfilename = "/var/run/mandos.pid"
774
try:
775
pidfile = open(pidfilename, "w")
776
except IOError, error:
777
logger.error("Could not open file %r", pidfilename)
778
779
uid = 65534
780
gid = 65534
781
try:
782
uid = pwd.getpwnam("mandos").pw_uid
783
except KeyError:
784
try:
785
uid = pwd.getpwnam("nobody").pw_uid
786
except KeyError:
787
pass
788
try:
789
gid = pwd.getpwnam("mandos").pw_gid
790
except KeyError:
791
try:
792
gid = pwd.getpwnam("nogroup").pw_gid
793
except KeyError:
794
pass
795
try:
796
os.setuid(uid)
2105
797
os.setgid(gid)
2106
os.setuid(uid)
2107
except OSError as error:
798
except OSError, error:
2108
799
if error[0] != errno.EPERM:
2109
800
raise error
2110
801
2111
if debug:
2112
# Enable all possible GnuTLS debugging
2113
2114
# "Use a log level over 10 to enable all debugging options."
2115
# - GnuTLS manual
2116
gnutls.library.functions.gnutls_global_set_log_level(11)
2117
2118
@gnutls.library.types.gnutls_log_func
2119
def debug_gnutls(level, string):
2120
logger.debug("GnuTLS: %s", string[:-1])
2121
2122
(gnutls.library.functions
2123
.gnutls_global_set_log_function(debug_gnutls))
2124
2125
# Redirect stdin so all checkers get /dev/null
2126
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2127
os.dup2(null, sys.stdin.fileno())
2128
if null > 2:
2129
os.close(null)
2130
else:
2131
# No console logging
2132
logger.removeHandler(console)
2133
2134
# Need to fork before connecting to D-Bus
2135
if not debug:
2136
# Close all input and output, do double fork, etc.
2137
daemon()
802
global service
803
service = AvahiService(name = server_settings["servicename"],
804
servicetype = "_mandos._tcp", )
805
if server_settings["interface"]:
806
service.interface = if_nametoindex\
807
(server_settings["interface"])
2138
808
2139
809
global main_loop
810
global bus
811
global server
2140
812
# From the Avahi example code
2141
813
DBusGMainLoop(set_as_default=True )
2142
814
main_loop = gobject.MainLoop()
2143
815
bus = dbus.SystemBus()
816
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
817
avahi.DBUS_PATH_SERVER),
818
avahi.DBUS_INTERFACE_SERVER)
2144
819
# End of Avahi example code
2145
if use_dbus:
2146
try:
2147
bus_name = dbus.service.BusName("se.recompile.Mandos",
2148
bus, do_not_queue=True)
2149
old_bus_name = (dbus.service.BusName
2150
("se.bsnet.fukt.Mandos", bus,
2151
do_not_queue=True))
2152
except dbus.exceptions.NameExistsException as e:
2153
logger.error(unicode(e) + ", disabling D-Bus")
2154
use_dbus = False
2155
server_settings["use_dbus"] = False
2156
tcp_server.use_dbus = False
2157
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2158
service = AvahiServiceToSyslog(name =
2159
server_settings["servicename"],
2160
servicetype = "_mandos._tcp",
2161
protocol = protocol, bus = bus)
2162
if server_settings["interface"]:
2163
service.interface = (if_nametoindex
2164
(str(server_settings["interface"])))
2165
2166
global multiprocessing_manager
2167
multiprocessing_manager = multiprocessing.Manager()
2168
2169
client_class = Client
2170
if use_dbus:
2171
client_class = functools.partial(ClientDBusTransitional,
2172
bus = bus)
2173
2174
special_settings = {
2175
# Some settings need to be accessd by special methods;
2176
# booleans need .getboolean(), etc. Here is a list of them:
2177
"approved_by_default":
2178
lambda section:
2179
client_config.getboolean(section, "approved_by_default"),
2180
}
2181
# Construct a new dict of client settings of this form:
2182
# { client_name: {setting_name: value, ...}, ...}
2183
# with exceptions for any special settings as defined above
2184
client_settings = dict((clientname,
2185
dict((setting,
2186
(value
2187
if setting not in special_settings
2188
else special_settings[setting]
2189
(clientname)))
2190
for setting, value in
2191
client_config.items(clientname)))
2192
for clientname in client_config.sections())
2193
2194
old_client_settings = {}
2195
clients_data = []
2196
2197
# Get client data and settings from last running state.
2198
if server_settings["restore"]:
2199
try:
2200
with open(stored_state_path, "rb") as stored_state:
2201
clients_data, old_client_settings = (pickle.load
2202
(stored_state))
2203
os.remove(stored_state_path)
2204
except IOError as e:
2205
logger.warning("Could not load persistent state: {0}"
2206
.format(e))
2207
if e.errno != errno.ENOENT:
2208
raise
2209
2210
with Crypto() as crypt:
2211
for client in clients_data:
2212
client_name = client["name"]
2213
2214
# Decide which value to use after restoring saved state.
2215
# We have three different values: Old config file,
2216
# new config file, and saved state.
2217
# New config value takes precedence if it differs from old
2218
# config value, otherwise use saved state.
2219
for name, value in client_settings[client_name].items():
2220
try:
2221
# For each value in new config, check if it
2222
# differs from the old config value (Except for
2223
# the "secret" attribute)
2224
if (name != "secret" and
2225
value != old_client_settings[client_name]
2226
[name]):
2227
setattr(client, name, value)
2228
except KeyError:
2229
pass
2230
2231
# Clients who has passed its expire date can still be
2232
# enabled if its last checker was sucessful. Clients
2233
# whose checker failed before we stored its state is
2234
# assumed to have failed all checkers during downtime.
2235
if client["enabled"] and client["last_checked_ok"]:
2236
if ((datetime.datetime.utcnow()
2237
- client["last_checked_ok"])
2238
> client["interval"]):
2239
if client["last_checker_status"] != 0:
2240
client["enabled"] = False
2241
else:
2242
client["expires"] = (datetime.datetime
2243
.utcnow()
2244
+ client["timeout"])
2245
2246
client["changedstate"] = (multiprocessing_manager
2247
.Condition
2248
(multiprocessing_manager
2249
.Lock()))
2250
if use_dbus:
2251
new_client = (ClientDBusTransitional.__new__
2252
(ClientDBusTransitional))
2253
tcp_server.clients[client_name] = new_client
2254
new_client.bus = bus
2255
for name, value in client.iteritems():
2256
setattr(new_client, name, value)
2257
client_object_name = unicode(client_name).translate(
2258
{ord("."): ord("_"),
2259
ord("-"): ord("_")})
2260
new_client.dbus_object_path = (dbus.ObjectPath
2261
("/clients/"
2262
+ client_object_name))
2263
DBusObjectWithProperties.__init__(new_client,
2264
new_client.bus,
2265
new_client
2266
.dbus_object_path)
2267
else:
2268
tcp_server.clients[client_name] = (Client.__new__
2269
(Client))
2270
for name, value in client.iteritems():
2271
setattr(tcp_server.clients[client_name],
2272
name, value)
2273
2274
try:
2275
tcp_server.clients[client_name].secret = (
2276
crypt.decrypt(tcp_server.clients[client_name]
2277
.encrypted_secret,
2278
client_settings[client_name]
2279
["secret"]))
2280
except CryptoError:
2281
# If decryption fails, we use secret from new settings
2282
tcp_server.clients[client_name].secret = (
2283
client_settings[client_name]["secret"])
2284
2285
# Create/remove clients based on new changes made to config
2286
for clientname in set(old_client_settings) - set(client_settings):
2287
del tcp_server.clients[clientname]
2288
for clientname in set(client_settings) - set(old_client_settings):
2289
tcp_server.clients[clientname] = (client_class(name
2290
= clientname,
2291
config =
2292
client_settings
2293
[clientname]))
2294
2295
if not tcp_server.clients:
2296
logger.warning("No clients defined")
820
821
def remove_from_clients(client):
822
clients.remove(client)
823
if not clients:
824
logger.critical(u"No clients left, exiting")
825
sys.exit()
826
827
clients.update(Set(Client(name = section,
828
stop_hook = remove_from_clients,
829
config
830
= dict(client_config.items(section)))
831
for section in client_config.sections()))
832
if not clients:
833
logger.critical(u"No clients defined")
834
sys.exit(1)
835
836
if debug:
837
# Redirect stdin so all checkers get /dev/null
838
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
839
os.dup2(null, sys.stdin.fileno())
840
if null > 2:
841
os.close(null)
842
else:
843
# No console logging
844
logger.removeHandler(console)
845
# Close all input and output, do double fork, etc.
846
daemon()
847
848
try:
849
pid = os.getpid()
850
pidfile.write(str(pid) + "\n")
851
pidfile.close()
852
del pidfile
853
except IOError:
854
logger.error(u"Could not write to file %r with PID %d",
855
pidfilename, pid)
856
except NameError:
857
# "pidfile" was never created
858
pass
859
del pidfilename
860
861
def cleanup():
862
"Cleanup function; run on exit"
863
global group
864
# From the Avahi example code
865
if not group is None:
866
group.Free()
867
group = None
868
# End of Avahi example code
2297
869
870
while clients:
871
client = clients.pop()
872
client.stop_hook = None
873
client.stop()
874
875
atexit.register(cleanup)
876
2298
877
if not debug:
2299
try:
2300
with pidfile:
2301
pid = os.getpid()
2302
pidfile.write(str(pid) + "\n".encode("utf-8"))
2303
del pidfile
2304
except IOError:
2305
logger.error("Could not write to file %r with PID %d",
2306
pidfilename, pid)
2307
except NameError:
2308
# "pidfile" was never created
2309
pass
2310
del pidfilename
2311
2312
878
signal.signal(signal.SIGINT, signal.SIG_IGN)
2313
2314
879
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2315
880
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2316
881
2317
if use_dbus:
2318
class MandosDBusService(dbus.service.Object):
2319
"""A D-Bus proxy object"""
2320
def __init__(self):
2321
dbus.service.Object.__init__(self, bus, "/")
2322
_interface = "se.recompile.Mandos"
2323
2324
@dbus.service.signal(_interface, signature="o")
2325
def ClientAdded(self, objpath):
2326
"D-Bus signal"
2327
pass
2328
2329
@dbus.service.signal(_interface, signature="ss")
2330
def ClientNotFound(self, fingerprint, address):
2331
"D-Bus signal"
2332
pass
2333
2334
@dbus.service.signal(_interface, signature="os")
2335
def ClientRemoved(self, objpath, name):
2336
"D-Bus signal"
2337
pass
2338
2339
@dbus.service.method(_interface, out_signature="ao")
2340
def GetAllClients(self):
2341
"D-Bus method"
2342
return dbus.Array(c.dbus_object_path
2343
for c in
2344
tcp_server.clients.itervalues())
2345
2346
@dbus.service.method(_interface,
2347
out_signature="a{oa{sv}}")
2348
def GetAllClientsWithProperties(self):
2349
"D-Bus method"
2350
return dbus.Dictionary(
2351
((c.dbus_object_path, c.GetAll(""))
2352
for c in tcp_server.clients.itervalues()),
2353
signature="oa{sv}")
2354
2355
@dbus.service.method(_interface, in_signature="o")
2356
def RemoveClient(self, object_path):
2357
"D-Bus method"
2358
for c in tcp_server.clients.itervalues():
2359
if c.dbus_object_path == object_path:
2360
del tcp_server.clients[c.name]
2361
c.remove_from_connection()
2362
# Don't signal anything except ClientRemoved
2363
c.disable(quiet=True)
2364
# Emit D-Bus signal
2365
self.ClientRemoved(object_path, c.name)
2366
return
2367
raise KeyError(object_path)
2368
2369
del _interface
2370
2371
class MandosDBusServiceTransitional(MandosDBusService):
2372
__metaclass__ = AlternateDBusNamesMetaclass
2373
mandos_dbus_service = MandosDBusServiceTransitional()
2374
2375
def cleanup():
2376
"Cleanup function; run on exit"
2377
service.cleanup()
2378
2379
multiprocessing.active_children()
2380
if not (tcp_server.clients or client_settings):
2381
return
2382
2383
# Store client before exiting. Secrets are encrypted with key
2384
# based on what config file has. If config file is
2385
# removed/edited, old secret will thus be unrecovable.
2386
clients = []
2387
with Crypto() as crypt:
2388
for client in tcp_server.clients.itervalues():
2389
key = client_settings[client.name]["secret"]
2390
client.encrypted_secret = crypt.encrypt(client.secret,
2391
key)
2392
client_dict = {}
2393
2394
# A list of attributes that will not be stored when
2395
# shutting down.
2396
exclude = set(("bus", "changedstate", "secret"))
2397
for name, typ in (inspect.getmembers
2398
(dbus.service.Object)):
2399
exclude.add(name)
2400
2401
client_dict["encrypted_secret"] = (client
2402
.encrypted_secret)
2403
for attr in client.client_structure:
2404
if attr not in exclude:
2405
client_dict[attr] = getattr(client, attr)
2406
2407
clients.append(client_dict)
2408
del client_settings[client.name]["secret"]
2409
2410
try:
2411
with os.fdopen(os.open(stored_state_path,
2412
os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
2413
0600), "wb") as stored_state:
2414
pickle.dump((clients, client_settings), stored_state)
2415
except (IOError, OSError) as e:
2416
logger.warning("Could not save persistent state: {0}"
2417
.format(e))
2418
if e.errno not in (errno.ENOENT, errno.EACCES):
2419
raise
2420
2421
# Delete all clients, and settings from config
2422
while tcp_server.clients:
2423
name, client = tcp_server.clients.popitem()
2424
if use_dbus:
2425
client.remove_from_connection()
2426
# Don't signal anything except ClientRemoved
2427
client.disable(quiet=True)
2428
if use_dbus:
2429
# Emit D-Bus signal
2430
mandos_dbus_service.ClientRemoved(client
2431
.dbus_object_path,
2432
client.name)
2433
client_settings.clear()
2434
2435
atexit.register(cleanup)
2436
2437
for client in tcp_server.clients.itervalues():
2438
if use_dbus:
2439
# Emit D-Bus signal
2440
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2441
# Need to initiate checking of clients
2442
if client.enabled:
2443
client.init_checker()
882
for client in clients:
883
client.start()
2444
884
2445
885
tcp_server.enable()
2446
886
tcp_server.server_activate()
2447
887
2448
888
# Find out what port we got
2449
889
service.port = tcp_server.socket.getsockname()[1]
2450
if use_ipv6:
2451
logger.info("Now listening on address %r, port %d,"
2452
" flowinfo %d, scope_id %d"
2453
% tcp_server.socket.getsockname())
2454
else: # IPv4
2455
logger.info("Now listening on address %r, port %d"
2456
% tcp_server.socket.getsockname())
890
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
891
u" scope_id %d" % tcp_server.socket.getsockname())
2457
892
2458
893
#service.interface = tcp_server.socket.getsockname()[3]
2459
894
2460
895
try:
2461
896
# From the Avahi example code
897
server.connect_to_signal("StateChanged", server_state_changed)
2462
898
try:
2463
service.activate()
2464
except dbus.exceptions.DBusException as error:
2465
logger.critical("DBusException: %s", error)
2466
cleanup()
899
server_state_changed(server.GetState())
900
except dbus.exceptions.DBusException, error:
901
logger.critical(u"DBusException: %s", error)
2467
902
sys.exit(1)
2468
903
# End of Avahi example code
2469
904
2470
905
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2471
906
lambda *args, **kwargs:
2472
(tcp_server.handle_request
2473
(*args[2:], **kwargs) or True))
907
tcp_server.handle_request\
908
(*args[2:], **kwargs) or True)
2474
909
2475
logger.debug("Starting main loop")
910
logger.debug(u"Starting main loop")
2476
911
main_loop.run()
2477
except AvahiError as error:
2478
logger.critical("AvahiError: %s", error)
2479
cleanup()
912
except AvahiError, error:
913
logger.critical(u"AvahiError: %s" + unicode(error))
2480
914
sys.exit(1)
2481
915
except KeyboardInterrupt:
2482
916
if debug:
2483
print("", file=sys.stderr)
2484
logger.debug("Server received KeyboardInterrupt")
2485
logger.debug("Server exiting")
2486
# Must run before the D-Bus bus name gets deregistered
2487
cleanup()
2488
917
print
2489
918
2490
919
if __name__ == '__main__':
2491
920
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0