98
118
class AvahiService(object):
119
"""An Avahi (Zeroconf) service.
100
122
interface: integer; avahi.IF_UNSPEC or an interface index.
101
123
Used to optionally bind to the specified interface.
102
name = string; Example: "Mandos"
103
type = string; Example: "_mandos._tcp".
104
See <http://www.dns-sd.org/ServiceTypes.html>
105
port = integer; what port to announce
106
TXT = list of strings; TXT record for the service
107
domain = string; Domain to publish on, default to .local if empty.
108
host = string; Host to publish records for, default to localhost
110
max_renames = integer; maximum number of renames
111
rename_count = integer; counter so we only rename after collisions
112
a sensible number of times
124
name: string; Example: 'Mandos'
125
type: string; Example: '_mandos._tcp'.
126
See <http://www.dns-sd.org/ServiceTypes.html>
127
port: integer; what port to announce
128
TXT: list of strings; TXT record for the service
129
domain: string; Domain to publish on, default to .local if empty.
130
host: string; Host to publish records for, default is localhost
131
max_renames: integer; maximum number of renames
132
rename_count: integer; counter so we only rename after collisions
133
a sensible number of times
134
group: D-Bus Entry Group
136
bus: dbus.SystemBus()
114
138
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
115
type = None, port = None, TXT = None, domain = "",
116
host = "", max_renames = 12):
117
"""An Avahi (Zeroconf) service. """
139
servicetype = None, port = None, TXT = None,
140
domain = "", host = "", max_renames = 32768,
141
protocol = avahi.PROTO_UNSPEC, bus = None):
118
142
self.interface = interface
144
self.type = servicetype
146
self.TXT = TXT if TXT is not None else []
126
147
self.domain = domain
128
149
self.rename_count = 0
150
self.max_renames = max_renames
151
self.protocol = protocol
152
self.group = None # our entry group
155
self.entry_group_state_changed_match = None
129
156
def rename(self):
130
157
"""Derived from the Avahi example code"""
131
158
if self.rename_count >= self.max_renames:
132
logger.critical(u"No suitable service name found after %i"
133
u" retries, exiting.", rename_count)
159
logger.critical("No suitable Zeroconf service name found"
160
" after %i retries, exiting.",
134
162
raise AvahiServiceError("Too many renames")
135
name = server.GetAlternativeServiceName(name)
136
logger.notice(u"Changing name to %r ...", name)
163
self.name = unicode(self.server.GetAlternativeServiceName(self.name))
164
logger.info("Changing Zeroconf service name to %r ...",
166
syslogger.setFormatter(logging.Formatter
167
('Mandos (%s) [%%(process)d]:'
168
' %%(levelname)s: %%(message)s'
173
except dbus.exceptions.DBusException as error:
174
logger.critical("DBusException: %s", error)
139
177
self.rename_count += 1
140
178
def remove(self):
141
179
"""Derived from the Avahi example code"""
142
if group is not None:
180
if self.entry_group_state_changed_match is not None:
181
self.entry_group_state_changed_match.remove()
182
self.entry_group_state_changed_match = None
183
if self.group is not None:
145
186
"""Derived from the Avahi example code"""
148
group = dbus.Interface\
149
(bus.get_object(avahi.DBUS_NAME,
150
server.EntryGroupNew()),
151
avahi.DBUS_INTERFACE_ENTRY_GROUP)
152
group.connect_to_signal('StateChanged',
153
entry_group_state_changed)
154
logger.debug(u"Adding service '%s' of type '%s' ...",
155
service.name, service.type)
157
self.interface, # interface
158
avahi.PROTO_INET6, # protocol
159
dbus.UInt32(0), # flags
160
self.name, self.type,
161
self.domain, self.host,
162
dbus.UInt16(self.port),
163
avahi.string_array_to_txt_array(self.TXT))
166
# From the Avahi example code:
167
group = None # our entry group
168
# End of Avahi example code
188
if self.group is None:
189
self.group = dbus.Interface(
190
self.bus.get_object(avahi.DBUS_NAME,
191
self.server.EntryGroupNew()),
192
avahi.DBUS_INTERFACE_ENTRY_GROUP)
193
self.entry_group_state_changed_match = (
194
self.group.connect_to_signal(
195
'StateChanged', self .entry_group_state_changed))
196
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
197
self.name, self.type)
198
self.group.AddService(
201
dbus.UInt32(0), # flags
202
self.name, self.type,
203
self.domain, self.host,
204
dbus.UInt16(self.port),
205
avahi.string_array_to_txt_array(self.TXT))
207
def entry_group_state_changed(self, state, error):
208
"""Derived from the Avahi example code"""
209
logger.debug("Avahi entry group state change: %i", state)
211
if state == avahi.ENTRY_GROUP_ESTABLISHED:
212
logger.debug("Zeroconf service established.")
213
elif state == avahi.ENTRY_GROUP_COLLISION:
214
logger.info("Zeroconf service name collision.")
216
elif state == avahi.ENTRY_GROUP_FAILURE:
217
logger.critical("Avahi: Error in group state changed %s",
219
raise AvahiGroupError("State changed: %s"
222
"""Derived from the Avahi example code"""
223
if self.group is not None:
226
except (dbus.exceptions.UnknownMethodException,
227
dbus.exceptions.DBusException) as e:
231
def server_state_changed(self, state, error=None):
232
"""Derived from the Avahi example code"""
233
logger.debug("Avahi server state change: %i", state)
234
bad_states = { avahi.SERVER_INVALID:
235
"Zeroconf server invalid",
236
avahi.SERVER_REGISTERING: None,
237
avahi.SERVER_COLLISION:
238
"Zeroconf server name collision",
239
avahi.SERVER_FAILURE:
240
"Zeroconf server failure" }
241
if state in bad_states:
242
if bad_states[state] is not None:
244
logger.error(bad_states[state])
246
logger.error(bad_states[state] + ": %r", error)
248
elif state == avahi.SERVER_RUNNING:
252
logger.debug("Unknown state: %r", state)
254
logger.debug("Unknown state: %r: %r", state, error)
256
"""Derived from the Avahi example code"""
257
if self.server is None:
258
self.server = dbus.Interface(
259
self.bus.get_object(avahi.DBUS_NAME,
260
avahi.DBUS_PATH_SERVER,
261
follow_name_owner_changes=True),
262
avahi.DBUS_INTERFACE_SERVER)
263
self.server.connect_to_signal("StateChanged",
264
self.server_state_changed)
265
self.server_state_changed(self.server.GetState())
268
def _timedelta_to_milliseconds(td):
269
"Convert a datetime.timedelta() to milliseconds"
270
return ((td.days * 24 * 60 * 60 * 1000)
271
+ (td.seconds * 1000)
272
+ (td.microseconds // 1000))
171
274
class Client(object):
172
275
"""A representation of a client host served by this server.
174
name: string; from the config file, used in log messages
278
_approved: bool(); 'None' if not yet approved/disapproved
279
approval_delay: datetime.timedelta(); Time to wait for approval
280
approval_duration: datetime.timedelta(); Duration of one approval
281
checker: subprocess.Popen(); a running checker process used
282
to see if the client lives.
283
'None' if no process is running.
284
checker_callback_tag: a gobject event source tag, or None
285
checker_command: string; External command which is run to check
286
if client lives. %() expansions are done at
287
runtime with vars(self) as dict, so that for
288
instance %(name)s can be used in the command.
289
checker_initiator_tag: a gobject event source tag, or None
290
created: datetime.datetime(); (UTC) object creation
291
current_checker_command: string; current running checker_command
292
disable_hook: If set, called by disable() as disable_hook(self)
293
disable_initiator_tag: a gobject event source tag, or None
175
295
fingerprint: string (40 or 32 hexadecimal digits); used to
176
296
uniquely identify the client
177
secret: bytestring; sent verbatim (over TLS) to client
178
fqdn: string (FQDN); available for use by the checker command
179
created: datetime.datetime(); object creation, not client host
180
last_checked_ok: datetime.datetime() or None if not yet checked OK
181
timeout: datetime.timedelta(); How long from last_checked_ok
182
until this client is invalid
183
interval: datetime.timedelta(); How often to start a new checker
184
stop_hook: If set, called by stop() as stop_hook(self)
185
checker: subprocess.Popen(); a running checker process used
186
to see if the client lives.
187
'None' if no process is running.
188
checker_initiator_tag: a gobject event source tag, or None
189
stop_initiator_tag: - '' -
190
checker_callback_tag: - '' -
191
checker_command: string; External command which is run to check if
192
client lives. %() expansions are done at
193
runtime with vars(self) as dict, so that for
194
instance %(name)s can be used in the command.
196
_timeout: Real variable for 'timeout'
197
_interval: Real variable for 'interval'
198
_timeout_milliseconds: Used when calling gobject.timeout_add()
199
_interval_milliseconds: - '' -
297
host: string; available for use by the checker command
298
interval: datetime.timedelta(); How often to start a new checker
299
last_approval_request: datetime.datetime(); (UTC) or None
300
last_checked_ok: datetime.datetime(); (UTC) or None
301
last_enabled: datetime.datetime(); (UTC)
302
name: string; from the config file, used in log messages and
304
secret: bytestring; sent verbatim (over TLS) to client
305
timeout: datetime.timedelta(); How long from last_checked_ok
306
until this client is disabled
307
extended_timeout: extra long timeout when password has been sent
308
runtime_expansions: Allowed attributes for runtime expansion.
309
expires: datetime.datetime(); time (UTC) when a client will be
201
def _set_timeout(self, timeout):
202
"Setter function for 'timeout' attribute"
203
self._timeout = timeout
204
self._timeout_milliseconds = ((self.timeout.days
205
* 24 * 60 * 60 * 1000)
206
+ (self.timeout.seconds * 1000)
207
+ (self.timeout.microseconds
209
timeout = property(lambda self: self._timeout,
212
def _set_interval(self, interval):
213
"Setter function for 'interval' attribute"
214
self._interval = interval
215
self._interval_milliseconds = ((self.interval.days
216
* 24 * 60 * 60 * 1000)
217
+ (self.interval.seconds
219
+ (self.interval.microseconds
221
interval = property(lambda self: self._interval,
224
def __init__(self, name=None, stop_hook=None, fingerprint=None,
225
secret=None, secfile=None, fqdn=None, timeout=None,
226
interval=-1, checker=None):
227
"""Note: the 'checker' argument sets the 'checker_command'
228
attribute and not the 'checker' attribute.."""
313
runtime_expansions = ("approval_delay", "approval_duration",
314
"created", "enabled", "fingerprint",
315
"host", "interval", "last_checked_ok",
316
"last_enabled", "name", "timeout")
318
def timeout_milliseconds(self):
319
"Return the 'timeout' attribute in milliseconds"
320
return _timedelta_to_milliseconds(self.timeout)
322
def extended_timeout_milliseconds(self):
323
"Return the 'extended_timeout' attribute in milliseconds"
324
return _timedelta_to_milliseconds(self.extended_timeout)
326
def interval_milliseconds(self):
327
"Return the 'interval' attribute in milliseconds"
328
return _timedelta_to_milliseconds(self.interval)
330
def approval_delay_milliseconds(self):
331
return _timedelta_to_milliseconds(self.approval_delay)
333
def __init__(self, name = None, disable_hook=None, config=None):
334
"""Note: the 'checker' key in 'config' sets the
335
'checker_command' attribute and *not* the 'checker'
230
logger.debug(u"Creating client %r", self.name)
231
# Uppercase and remove spaces from fingerprint
232
# for later comparison purposes with return value of
233
# the fingerprint() function
234
self.fingerprint = fingerprint.upper().replace(u" ", u"")
235
logger.debug(u" Fingerprint: %s", self.fingerprint)
237
self.secret = secret.decode(u"base64")
240
self.secret = sf.read()
340
logger.debug("Creating client %r", self.name)
341
# Uppercase and remove spaces from fingerprint for later
342
# comparison purposes with return value from the fingerprint()
344
self.fingerprint = (config["fingerprint"].upper()
346
logger.debug(" Fingerprint: %s", self.fingerprint)
347
if "secret" in config:
348
self.secret = config["secret"].decode("base64")
349
elif "secfile" in config:
350
with open(os.path.expanduser(os.path.expandvars
351
(config["secfile"])),
353
self.secret = secfile.read()
243
raise TypeError(u"No secret or secfile for client %s"
355
raise TypeError("No secret or secfile for client %s"
246
self.created = datetime.datetime.now()
357
self.host = config.get("host", "")
358
self.created = datetime.datetime.utcnow()
360
self.last_approval_request = None
361
self.last_enabled = None
247
362
self.last_checked_ok = None
248
self.timeout = string_to_delta(timeout)
249
self.interval = string_to_delta(interval)
250
self.stop_hook = stop_hook
363
self.timeout = string_to_delta(config["timeout"])
364
self.extended_timeout = string_to_delta(config["extended_timeout"])
365
self.interval = string_to_delta(config["interval"])
366
self.disable_hook = disable_hook
251
367
self.checker = None
252
368
self.checker_initiator_tag = None
253
self.stop_initiator_tag = None
369
self.disable_initiator_tag = None
254
371
self.checker_callback_tag = None
255
self.check_command = checker
372
self.checker_command = config["checker"]
373
self.current_checker_command = None
374
self.last_connect = None
375
self._approved = None
376
self.approved_by_default = config.get("approved_by_default",
378
self.approvals_pending = 0
379
self.approval_delay = string_to_delta(
380
config["approval_delay"])
381
self.approval_duration = string_to_delta(
382
config["approval_duration"])
383
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
385
def send_changedstate(self):
386
self.changedstate.acquire()
387
self.changedstate.notify_all()
388
self.changedstate.release()
257
391
"""Start this client's checker and timeout hooks"""
392
if getattr(self, "enabled", False):
395
self.send_changedstate()
258
396
# Schedule a new checker to be started an 'interval' from now,
259
397
# and every interval from then on.
260
self.checker_initiator_tag = gobject.timeout_add\
261
(self._interval_milliseconds,
398
self.checker_initiator_tag = (gobject.timeout_add
399
(self.interval_milliseconds(),
401
# Schedule a disable() when 'timeout' has passed
402
self.expires = datetime.datetime.utcnow() + self.timeout
403
self.disable_initiator_tag = (gobject.timeout_add
404
(self.timeout_milliseconds(),
407
self.last_enabled = datetime.datetime.utcnow()
263
408
# Also start a new checker *right now*.
264
409
self.start_checker()
265
# Schedule a stop() when 'timeout' has passed
266
self.stop_initiator_tag = gobject.timeout_add\
267
(self._timeout_milliseconds,
271
The possibility that a client might be restarted is left open,
272
but not currently used."""
273
# If this client doesn't have a secret, it is already stopped.
275
logger.debug(u"Stopping client %s", self.name)
411
def disable(self, quiet=True):
412
"""Disable this client."""
413
if not getattr(self, "enabled", False):
279
if getattr(self, "stop_initiator_tag", False):
280
gobject.source_remove(self.stop_initiator_tag)
281
self.stop_initiator_tag = None
416
self.send_changedstate()
418
logger.info("Disabling client %s", self.name)
419
if getattr(self, "disable_initiator_tag", False):
420
gobject.source_remove(self.disable_initiator_tag)
421
self.disable_initiator_tag = None
282
423
if getattr(self, "checker_initiator_tag", False):
283
424
gobject.source_remove(self.checker_initiator_tag)
284
425
self.checker_initiator_tag = None
285
426
self.stop_checker()
427
if self.disable_hook:
428
self.disable_hook(self)
288
430
# Do not run this again if called by a gobject.timeout_add
290
433
def __del__(self):
291
self.stop_hook = None
293
def checker_callback(self, pid, condition):
434
self.disable_hook = None
437
def checker_callback(self, pid, condition, command):
294
438
"""The checker has completed, so take appropriate actions."""
295
now = datetime.datetime.now()
296
439
self.checker_callback_tag = None
297
440
self.checker = None
298
if os.WIFEXITED(condition) \
299
and (os.WEXITSTATUS(condition) == 0):
300
logger.debug(u"Checker for %(name)s succeeded",
302
self.last_checked_ok = now
303
gobject.source_remove(self.stop_initiator_tag)
304
self.stop_initiator_tag = gobject.timeout_add\
305
(self._timeout_milliseconds,
307
elif not os.WIFEXITED(condition):
308
logger.warning(u"Checker for %(name)s crashed?",
441
if os.WIFEXITED(condition):
442
exitstatus = os.WEXITSTATUS(condition)
444
logger.info("Checker for %(name)s succeeded",
448
logger.info("Checker for %(name)s failed",
451
logger.warning("Checker for %(name)s crashed?",
311
logger.debug(u"Checker for %(name)s failed",
454
def checked_ok(self, timeout=None):
455
"""Bump up the timeout for this client.
457
This should only be called when the client has been seen,
461
timeout = self.timeout
462
self.last_checked_ok = datetime.datetime.utcnow()
463
gobject.source_remove(self.disable_initiator_tag)
464
self.expires = datetime.datetime.utcnow() + timeout
465
self.disable_initiator_tag = (gobject.timeout_add
466
(_timedelta_to_milliseconds(timeout),
469
def need_approval(self):
470
self.last_approval_request = datetime.datetime.utcnow()
313
472
def start_checker(self):
314
473
"""Start a new checker subprocess if one is not running.
315
475
If a checker already exists, leave it running and do
317
477
# The reason for not killing a running checker is that if we
361
554
logger.debug("Stopping checker for %(name)s", vars(self))
363
556
os.kill(self.checker.pid, signal.SIGTERM)
365
558
#if self.checker.poll() is None:
366
559
# os.kill(self.checker.pid, signal.SIGKILL)
367
except OSError, error:
560
except OSError as error:
368
561
if error.errno != errno.ESRCH: # No such process
370
563
self.checker = None
371
def still_valid(self):
372
"""Has the timeout not yet passed for this client?"""
373
now = datetime.datetime.now()
374
if self.last_checked_ok is None:
375
return now < (self.created + self.timeout)
377
return now < (self.last_checked_ok + self.timeout)
380
def peer_certificate(session):
381
"Return the peer's OpenPGP certificate as a bytestring"
382
# If not an OpenPGP certificate...
383
if gnutls.library.functions.gnutls_certificate_type_get\
384
(session._c_object) \
385
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
386
# ...do the normal thing
387
return session.peer_certificate
388
list_size = ctypes.c_uint()
389
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
390
(session._c_object, ctypes.byref(list_size))
391
if list_size.value == 0:
394
return ctypes.string_at(cert.data, cert.size)
397
def fingerprint(openpgp):
398
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
399
# New empty GnuTLS certificate
400
crt = gnutls.library.types.gnutls_openpgp_crt_t()
401
gnutls.library.functions.gnutls_openpgp_crt_init\
403
# New GnuTLS "datum" with the OpenPGP public key
404
datum = gnutls.library.types.gnutls_datum_t\
405
(ctypes.cast(ctypes.c_char_p(openpgp),
406
ctypes.POINTER(ctypes.c_ubyte)),
407
ctypes.c_uint(len(openpgp)))
408
# Import the OpenPGP public key into the certificate
409
ret = gnutls.library.functions.gnutls_openpgp_crt_import\
412
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
413
# New buffer for the fingerprint
414
buffer = ctypes.create_string_buffer(20)
415
buffer_length = ctypes.c_size_t()
416
# Get the fingerprint from the certificate into the buffer
417
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
418
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
419
# Deinit the certificate
420
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
421
# Convert the buffer to a Python bytestring
422
fpr = ctypes.string_at(buffer, buffer_length.value)
423
# Convert the bytestring to hexadecimal notation
424
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
428
class tcp_handler(SocketServer.BaseRequestHandler, object):
429
"""A TCP request handler class.
430
Instantiated by IPv6_TCPServer for each request to handle it.
566
def dbus_service_property(dbus_interface, signature="v",
567
access="readwrite", byte_arrays=False):
568
"""Decorators for marking methods of a DBusObjectWithProperties to
569
become properties on the D-Bus.
571
The decorated method will be called with no arguments by "Get"
572
and with one argument by "Set".
574
The parameters, where they are supported, are the same as
575
dbus.service.method, except there is only "signature", since the
576
type from Get() and the type sent to Set() is the same.
578
# Encoding deeply encoded byte arrays is not supported yet by the
579
# "Set" method, so we fail early here:
580
if byte_arrays and signature != "ay":
581
raise ValueError("Byte arrays not supported for non-'ay'"
582
" signature %r" % signature)
584
func._dbus_is_property = True
585
func._dbus_interface = dbus_interface
586
func._dbus_signature = signature
587
func._dbus_access = access
588
func._dbus_name = func.__name__
589
if func._dbus_name.endswith("_dbus_property"):
590
func._dbus_name = func._dbus_name[:-14]
591
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
596
class DBusPropertyException(dbus.exceptions.DBusException):
597
"""A base class for D-Bus property-related exceptions
599
def __unicode__(self):
600
return unicode(str(self))
603
class DBusPropertyAccessException(DBusPropertyException):
604
"""A property's access permissions disallows an operation.
609
class DBusPropertyNotFound(DBusPropertyException):
610
"""An attempt was made to access a non-existing property.
615
class DBusObjectWithProperties(dbus.service.Object):
616
"""A D-Bus object with properties.
618
Classes inheriting from this can use the dbus_service_property
619
decorator to expose methods as D-Bus properties. It exposes the
620
standard Get(), Set(), and GetAll() methods on the D-Bus.
624
def _is_dbus_property(obj):
625
return getattr(obj, "_dbus_is_property", False)
627
def _get_all_dbus_properties(self):
628
"""Returns a generator of (name, attribute) pairs
630
return ((prop._dbus_name, prop)
632
inspect.getmembers(self, self._is_dbus_property))
634
# def _get_dbus_property(self, interface_name, property_name):
635
# """Returns a bound method if one exists which is a D-Bus
636
# property with the specified name and interface.
638
# print("get_property({0!r}, {1!r}".format(interface_name, property_name),file=sys.stderr)
639
# print(dir(self), sys.stderr)
640
# for name in (property_name,
641
# property_name + "_dbus_property"):
642
# prop = getattr(self, name, None)
644
# or not self._is_dbus_property(prop)
645
# or prop._dbus_name != property_name
646
# or (interface_name and prop._dbus_interface
647
# and interface_name != prop._dbus_interface)):
651
# raise DBusPropertyNotFound(self.dbus_object_path + ":"
652
# + interface_name + "."
655
def _get_dbus_property(self, interface_name, property_name):
656
"""Returns a bound method if one exists which is a D-Bus
657
property with the specified name and interface.
659
for name, value in inspect.getmembers(self, self._is_dbus_property):
660
if value._dbus_name == property_name and value._dbus_interface == interface_name:
664
raise DBusPropertyNotFound(self.dbus_object_path + ":"
665
+ interface_name + "."
669
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
671
def Get(self, interface_name, property_name):
672
"""Standard D-Bus property Get() method, see D-Bus standard.
674
prop = self._get_dbus_property(interface_name, property_name)
675
if prop._dbus_access == "write":
676
raise DBusPropertyAccessException(property_name)
678
if not hasattr(value, "variant_level"):
680
return type(value)(value, variant_level=value.variant_level+1)
682
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
683
def Set(self, interface_name, property_name, value):
684
"""Standard D-Bus property Set() method, see D-Bus standard.
686
prop = self._get_dbus_property(interface_name, property_name)
687
if prop._dbus_access == "read":
688
raise DBusPropertyAccessException(property_name)
689
if prop._dbus_get_args_options["byte_arrays"]:
690
# The byte_arrays option is not supported yet on
691
# signatures other than "ay".
692
if prop._dbus_signature != "ay":
694
value = dbus.ByteArray(''.join(unichr(byte)
698
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
699
out_signature="a{sv}")
700
def GetAll(self, interface_name):
701
"""Standard D-Bus property GetAll() method, see D-Bus
704
Note: Will not include properties with access="write".
707
for name, prop in self._get_all_dbus_properties():
709
and interface_name != prop._dbus_interface):
710
# Interface non-empty but did not match
712
# Ignore write-only properties
713
if prop._dbus_access == "write":
716
if not hasattr(value, "variant_level"):
719
all[name] = type(value)(value, variant_level=
720
value.variant_level+1)
721
return dbus.Dictionary(all, signature="sv")
723
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
725
path_keyword='object_path',
726
connection_keyword='connection')
727
def Introspect(self, object_path, connection):
728
"""Standard D-Bus method, overloaded to insert property tags.
730
xmlstring = dbus.service.Object.Introspect(self, object_path,
733
document = xml.dom.minidom.parseString(xmlstring)
734
def make_tag(document, name, prop):
735
e = document.createElement("property")
736
e.setAttribute("name", name)
737
e.setAttribute("type", prop._dbus_signature)
738
e.setAttribute("access", prop._dbus_access)
740
for if_tag in document.getElementsByTagName("interface"):
741
for tag in (make_tag(document, name, prop)
743
in self._get_all_dbus_properties()
744
if prop._dbus_interface
745
== if_tag.getAttribute("name")):
746
if_tag.appendChild(tag)
747
# Add the names to the return values for the
748
# "org.freedesktop.DBus.Properties" methods
749
if (if_tag.getAttribute("name")
750
== "org.freedesktop.DBus.Properties"):
751
for cn in if_tag.getElementsByTagName("method"):
752
if cn.getAttribute("name") == "Get":
753
for arg in cn.getElementsByTagName("arg"):
754
if (arg.getAttribute("direction")
756
arg.setAttribute("name", "value")
757
elif cn.getAttribute("name") == "GetAll":
758
for arg in cn.getElementsByTagName("arg"):
759
if (arg.getAttribute("direction")
761
arg.setAttribute("name", "props")
762
xmlstring = document.toxml("utf-8")
764
except (AttributeError, xml.dom.DOMException,
765
xml.parsers.expat.ExpatError) as error:
766
logger.error("Failed to override Introspection method",
771
def datetime_to_dbus (dt, variant_level=0):
772
"""Convert a UTC datetime.datetime() to a D-Bus type."""
774
return dbus.String("", variant_level = variant_level)
775
return dbus.String(dt.isoformat(),
776
variant_level=variant_level)
778
class transitional_clientdbus(DBusObjectWithProperties.__metaclass__):
779
def __new__(mcs, name, bases, attr):
780
for key, old_dbusobj in attr.items():
781
new_interface = getattr(old_dbusobj, "_dbus_interface", "").replace("se.bsnet.fukt.", "se.recompile.")
782
if getattr(old_dbusobj, "_dbus_is_signal", False):
783
unwrappedfunc = dict(zip(old_dbusobj.func_code.co_freevars,
784
old_dbusobj.__closure__))["func"].cell_contents
785
newfunc = types.FunctionType(unwrappedfunc.func_code,
786
unwrappedfunc.func_globals,
787
unwrappedfunc.func_name,
788
unwrappedfunc.func_defaults,
789
unwrappedfunc.func_closure)
790
new_dbusfunc = dbus.service.signal(
791
new_interface, old_dbusobj._dbus_signature)(newfunc)
792
attr["_transitional_{0}_1".format(key)] = new_dbusfunc
793
attr["_transitional_{0}_0".format(key)] = old_dbusobj
794
def fixscope(func1, func2):
795
def newcall(*args, **kwargs):
796
func1(*args, **kwargs)
797
func2(*args, **kwargs)
800
attr[key] = fixscope(
801
old_dbusobj, attr["_transitional_{0}_1".format(key)])
803
if getattr(old_dbusobj, "_dbus_is_method", False):
804
new_dbusfunc = (dbus.service.method
806
old_dbusobj._dbus_in_signature,
807
old_dbusobj._dbus_out_signature)
809
(old_dbusobj.func_code,
810
old_dbusobj.func_globals,
811
old_dbusobj.func_name,
812
old_dbusobj.func_defaults,
813
old_dbusobj.func_closure)))
815
attr["_transitional_{0}".format(key)] = new_dbusfunc
816
if getattr(old_dbusobj, "_dbus_is_property", False):
817
new_dbusfunc = (dbus_service_property
819
old_dbusobj._dbus_signature,
820
old_dbusobj._dbus_access,
821
old_dbusobj._dbus_get_args_options["byte_arrays"])
823
(old_dbusobj.func_code,
824
old_dbusobj.func_globals,
825
old_dbusobj.func_name,
826
old_dbusobj.func_defaults,
827
old_dbusobj.func_closure)))
829
attr["_transitional_{0}".format(key)] = new_dbusfunc
830
return type.__new__(mcs, name, bases, attr)
832
class ClientDBus(Client, DBusObjectWithProperties):
833
"""A Client class using D-Bus
836
dbus_object_path: dbus.ObjectPath
837
bus: dbus.SystemBus()
840
runtime_expansions = (Client.runtime_expansions
841
+ ("dbus_object_path",))
843
__metaclass__ = transitional_clientdbus
845
# dbus.service.Object doesn't use super(), so we can't either.
847
def __init__(self, bus = None, *args, **kwargs):
848
self._approvals_pending = 0
850
Client.__init__(self, *args, **kwargs)
851
# Only now, when this client is initialized, can it show up on
853
client_object_name = unicode(self.name).translate(
856
self.dbus_object_path = (dbus.ObjectPath
857
("/clients/" + client_object_name))
858
DBusObjectWithProperties.__init__(self, self.bus,
859
self.dbus_object_path)
861
def notifychangeproperty(transform_func,
862
dbus_name, type_func=lambda x: x,
864
""" Modify a variable so that its a property that announce its
866
transform_fun: Function that takes a value and transform it to
868
dbus_name: DBus name of the variable
869
type_func: Function that transform the value before sending it
871
variant_level: DBus variant level. default: 1
874
def setter(self, value):
875
old_value = real_value[0]
876
real_value[0] = value
877
if hasattr(self, "dbus_object_path"):
878
if type_func(old_value) != type_func(real_value[0]):
879
dbus_value = transform_func(type_func(real_value[0]),
881
self.PropertyChanged(dbus.String(dbus_name),
884
return property(lambda self: real_value[0], setter)
887
expires = notifychangeproperty(datetime_to_dbus, "Expires")
888
approvals_pending = notifychangeproperty(dbus.Boolean,
891
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
892
last_enabled = notifychangeproperty(datetime_to_dbus,
894
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
895
type_func = lambda checker: checker is not None)
896
last_checked_ok = notifychangeproperty(datetime_to_dbus,
898
last_approval_request = notifychangeproperty(datetime_to_dbus,
899
"LastApprovalRequest")
900
approved_by_default = notifychangeproperty(dbus.Boolean,
902
approval_delay = notifychangeproperty(dbus.UInt16, "ApprovalDelay",
903
type_func = _timedelta_to_milliseconds)
904
approval_duration = notifychangeproperty(dbus.UInt16, "ApprovalDuration",
905
type_func = _timedelta_to_milliseconds)
906
host = notifychangeproperty(dbus.String, "Host")
907
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
908
type_func = _timedelta_to_milliseconds)
909
extended_timeout = notifychangeproperty(dbus.UInt16, "ExtendedTimeout",
910
type_func = _timedelta_to_milliseconds)
911
interval = notifychangeproperty(dbus.UInt16, "Interval",
912
type_func = _timedelta_to_milliseconds)
913
checker_command = notifychangeproperty(dbus.String, "Checker")
915
del notifychangeproperty
917
def __del__(self, *args, **kwargs):
919
self.remove_from_connection()
922
if hasattr(DBusObjectWithProperties, "__del__"):
923
DBusObjectWithProperties.__del__(self, *args, **kwargs)
924
Client.__del__(self, *args, **kwargs)
926
def checker_callback(self, pid, condition, command,
928
self.checker_callback_tag = None
930
if os.WIFEXITED(condition):
931
exitstatus = os.WEXITSTATUS(condition)
933
self.CheckerCompleted(dbus.Int16(exitstatus),
934
dbus.Int64(condition),
935
dbus.String(command))
938
self.CheckerCompleted(dbus.Int16(-1),
939
dbus.Int64(condition),
940
dbus.String(command))
942
return Client.checker_callback(self, pid, condition, command,
945
def start_checker(self, *args, **kwargs):
946
old_checker = self.checker
947
if self.checker is not None:
948
old_checker_pid = self.checker.pid
950
old_checker_pid = None
951
r = Client.start_checker(self, *args, **kwargs)
952
# Only if new checker process was started
953
if (self.checker is not None
954
and old_checker_pid != self.checker.pid):
956
self.CheckerStarted(self.current_checker_command)
959
def _reset_approved(self):
960
self._approved = None
963
def approve(self, value=True):
964
self.send_changedstate()
965
self._approved = value
966
gobject.timeout_add(_timedelta_to_milliseconds
967
(self.approval_duration),
968
self._reset_approved)
971
## D-Bus methods, signals & properties
972
_interface = "se.bsnet.fukt.Mandos.Client"
976
# CheckerCompleted - signal
977
@dbus.service.signal(_interface, signature="nxs")
978
def CheckerCompleted(self, exitcode, waitstatus, command):
982
# CheckerStarted - signal
983
@dbus.service.signal(_interface, signature="s")
984
def CheckerStarted(self, command):
988
# PropertyChanged - signal
989
@dbus.service.signal(_interface, signature="sv")
990
def PropertyChanged(self, property, value):
995
@dbus.service.signal(_interface)
998
Is sent after a successful transfer of secret from the Mandos
999
server to mandos-client
1004
@dbus.service.signal(_interface, signature="s")
1005
def Rejected(self, reason):
1009
# NeedApproval - signal
1010
@dbus.service.signal(_interface, signature="tb")
1011
def NeedApproval(self, timeout, default):
1013
return self.need_approval()
1018
@dbus.service.method(_interface, in_signature="b")
1019
def Approve(self, value):
1022
# CheckedOK - method
1023
@dbus.service.method(_interface)
1024
def CheckedOK(self):
1028
@dbus.service.method(_interface)
1033
# StartChecker - method
1034
@dbus.service.method(_interface)
1035
def StartChecker(self):
1037
self.start_checker()
1040
@dbus.service.method(_interface)
1045
# StopChecker - method
1046
@dbus.service.method(_interface)
1047
def StopChecker(self):
1052
# ApprovalPending - property
1053
@dbus_service_property(_interface, signature="b", access="read")
1054
def ApprovalPending_dbus_property(self):
1055
return dbus.Boolean(bool(self.approvals_pending))
1057
# ApprovedByDefault - property
1058
@dbus_service_property(_interface, signature="b",
1060
def ApprovedByDefault_dbus_property(self, value=None):
1061
if value is None: # get
1062
return dbus.Boolean(self.approved_by_default)
1063
self.approved_by_default = bool(value)
1065
# ApprovalDelay - property
1066
@dbus_service_property(_interface, signature="t",
1068
def ApprovalDelay_dbus_property(self, value=None):
1069
if value is None: # get
1070
return dbus.UInt64(self.approval_delay_milliseconds())
1071
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1073
# ApprovalDuration - property
1074
@dbus_service_property(_interface, signature="t",
1076
def ApprovalDuration_dbus_property(self, value=None):
1077
if value is None: # get
1078
return dbus.UInt64(_timedelta_to_milliseconds(
1079
self.approval_duration))
1080
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1083
@dbus_service_property(_interface, signature="s", access="read")
1084
def Name_dbus_property(self):
1085
return dbus.String(self.name)
1087
# Fingerprint - property
1088
@dbus_service_property(_interface, signature="s", access="read")
1089
def Fingerprint_dbus_property(self):
1090
return dbus.String(self.fingerprint)
1093
@dbus_service_property(_interface, signature="s",
1095
def Host_dbus_property(self, value=None):
1096
if value is None: # get
1097
return dbus.String(self.host)
1100
# Created - property
1101
@dbus_service_property(_interface, signature="s", access="read")
1102
def Created_dbus_property(self):
1103
return dbus.String(datetime_to_dbus(self.created))
1105
# LastEnabled - property
1106
@dbus_service_property(_interface, signature="s", access="read")
1107
def LastEnabled_dbus_property(self):
1108
return datetime_to_dbus(self.last_enabled)
1110
# Enabled - property
1111
@dbus_service_property(_interface, signature="b",
1113
def Enabled_dbus_property(self, value=None):
1114
if value is None: # get
1115
return dbus.Boolean(self.enabled)
1121
# LastCheckedOK - property
1122
@dbus_service_property(_interface, signature="s",
1124
def LastCheckedOK_dbus_property(self, value=None):
1125
if value is not None:
1128
return datetime_to_dbus(self.last_checked_ok)
1130
# Expires - property
1131
@dbus_service_property(_interface, signature="s", access="read")
1132
def Expires_dbus_property(self):
1133
return datetime_to_dbus(self.expires)
1135
# LastApprovalRequest - property
1136
@dbus_service_property(_interface, signature="s", access="read")
1137
def LastApprovalRequest_dbus_property(self):
1138
return datetime_to_dbus(self.last_approval_request)
1140
# Timeout - property
1141
@dbus_service_property(_interface, signature="t",
1143
def Timeout_dbus_property(self, value=None):
1144
if value is None: # get
1145
return dbus.UInt64(self.timeout_milliseconds())
1146
self.timeout = datetime.timedelta(0, 0, 0, value)
1147
if getattr(self, "disable_initiator_tag", None) is None:
1149
# Reschedule timeout
1150
gobject.source_remove(self.disable_initiator_tag)
1151
self.disable_initiator_tag = None
1153
time_to_die = (self.
1154
_timedelta_to_milliseconds((self
1159
if time_to_die <= 0:
1160
# The timeout has passed
1163
self.expires = (datetime.datetime.utcnow()
1164
+ datetime.timedelta(milliseconds = time_to_die))
1165
self.disable_initiator_tag = (gobject.timeout_add
1166
(time_to_die, self.disable))
1168
# ExtendedTimeout - property
1169
@dbus_service_property(_interface, signature="t",
1171
def ExtendedTimeout_dbus_property(self, value=None):
1172
if value is None: # get
1173
return dbus.UInt64(self.extended_timeout_milliseconds())
1174
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1176
# Interval - property
1177
@dbus_service_property(_interface, signature="t",
1179
def Interval_dbus_property(self, value=None):
1180
if value is None: # get
1181
return dbus.UInt64(self.interval_milliseconds())
1182
self.interval = datetime.timedelta(0, 0, 0, value)
1183
if getattr(self, "checker_initiator_tag", None) is None:
1185
# Reschedule checker run
1186
gobject.source_remove(self.checker_initiator_tag)
1187
self.checker_initiator_tag = (gobject.timeout_add
1188
(value, self.start_checker))
1189
self.start_checker() # Start one now, too
1191
# Checker - property
1192
@dbus_service_property(_interface, signature="s",
1194
def Checker_dbus_property(self, value=None):
1195
if value is None: # get
1196
return dbus.String(self.checker_command)
1197
self.checker_command = value
1199
# CheckerRunning - property
1200
@dbus_service_property(_interface, signature="b",
1202
def CheckerRunning_dbus_property(self, value=None):
1203
if value is None: # get
1204
return dbus.Boolean(self.checker is not None)
1206
self.start_checker()
1210
# ObjectPath - property
1211
@dbus_service_property(_interface, signature="o", access="read")
1212
def ObjectPath_dbus_property(self):
1213
return self.dbus_object_path # is already a dbus.ObjectPath
1216
@dbus_service_property(_interface, signature="ay",
1217
access="write", byte_arrays=True)
1218
def Secret_dbus_property(self, value):
1219
self.secret = str(value)
1224
class ProxyClient(object):
1225
def __init__(self, child_pipe, fpr, address):
1226
self._pipe = child_pipe
1227
self._pipe.send(('init', fpr, address))
1228
if not self._pipe.recv():
1231
def __getattribute__(self, name):
1232
if(name == '_pipe'):
1233
return super(ProxyClient, self).__getattribute__(name)
1234
self._pipe.send(('getattr', name))
1235
data = self._pipe.recv()
1236
if data[0] == 'data':
1238
if data[0] == 'function':
1239
def func(*args, **kwargs):
1240
self._pipe.send(('funcall', name, args, kwargs))
1241
return self._pipe.recv()[1]
1244
def __setattr__(self, name, value):
1245
if(name == '_pipe'):
1246
return super(ProxyClient, self).__setattr__(name, value)
1247
self._pipe.send(('setattr', name, value))
1250
class ClientHandler(socketserver.BaseRequestHandler, object):
1251
"""A class to handle client connections.
1253
Instantiated once for each connection to handle it.
431
1254
Note: This will run in its own forked process."""
433
1256
def handle(self):
434
logger.debug(u"TCP connection from: %s",
435
unicode(self.client_address))
436
session = gnutls.connection.ClientSession\
437
(self.request, gnutls.connection.X509Credentials())
438
# Note: gnutls.connection.X509Credentials is really a generic
439
# GnuTLS certificate credentials object so long as no X.509
440
# keys are added to it. Therefore, we can use it here despite
441
# using OpenPGP certificates.
443
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
444
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
446
priority = "NORMAL" # Fallback default, since this
448
if self.server.settings["priority"]:
449
priority = self.server.settings["priority"]
450
gnutls.library.functions.gnutls_priority_set_direct\
451
(session._c_object, priority, None);
455
except gnutls.errors.GNUTLSError, error:
456
logger.debug(u"Handshake failed: %s", error)
457
# Do not run session.bye() here: the session is not
458
# established. Just abandon the request.
461
fpr = fingerprint(peer_certificate(session))
462
except (TypeError, gnutls.errors.GNUTLSError), error:
463
logger.debug(u"Bad certificate: %s", error)
466
logger.debug(u"Fingerprint: %s", fpr)
468
for c in self.server.clients:
469
if c.fingerprint == fpr:
473
logger.debug(u"Client not found for fingerprint: %s", fpr)
476
# Have to check if client.still_valid(), since it is possible
477
# that the client timed out while establishing the GnuTLS
479
if not client.still_valid():
480
logger.debug(u"Client %(name)s is invalid", vars(client))
484
while sent_size < len(client.secret):
485
sent = session.send(client.secret[sent_size:])
486
logger.debug(u"Sent: %d, remaining: %d",
487
sent, len(client.secret)
488
- (sent_size + sent))
493
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
494
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1257
with contextlib.closing(self.server.child_pipe) as child_pipe:
1258
logger.info("TCP connection from: %s",
1259
unicode(self.client_address))
1260
logger.debug("Pipe FD: %d",
1261
self.server.child_pipe.fileno())
1263
session = (gnutls.connection
1264
.ClientSession(self.request,
1266
.X509Credentials()))
1268
# Note: gnutls.connection.X509Credentials is really a
1269
# generic GnuTLS certificate credentials object so long as
1270
# no X.509 keys are added to it. Therefore, we can use it
1271
# here despite using OpenPGP certificates.
1273
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1274
# "+AES-256-CBC", "+SHA1",
1275
# "+COMP-NULL", "+CTYPE-OPENPGP",
1277
# Use a fallback default, since this MUST be set.
1278
priority = self.server.gnutls_priority
1279
if priority is None:
1281
(gnutls.library.functions
1282
.gnutls_priority_set_direct(session._c_object,
1285
# Start communication using the Mandos protocol
1286
# Get protocol number
1287
line = self.request.makefile().readline()
1288
logger.debug("Protocol version: %r", line)
1290
if int(line.strip().split()[0]) > 1:
1292
except (ValueError, IndexError, RuntimeError) as error:
1293
logger.error("Unknown protocol version: %s", error)
1296
# Start GnuTLS connection
1299
except gnutls.errors.GNUTLSError as error:
1300
logger.warning("Handshake failed: %s", error)
1301
# Do not run session.bye() here: the session is not
1302
# established. Just abandon the request.
1304
logger.debug("Handshake succeeded")
1306
approval_required = False
1309
fpr = self.fingerprint(self.peer_certificate
1312
gnutls.errors.GNUTLSError) as error:
1313
logger.warning("Bad certificate: %s", error)
1315
logger.debug("Fingerprint: %s", fpr)
1318
client = ProxyClient(child_pipe, fpr,
1319
self.client_address)
1323
if client.approval_delay:
1324
delay = client.approval_delay
1325
client.approvals_pending += 1
1326
approval_required = True
1329
if not client.enabled:
1330
logger.info("Client %s is disabled",
1332
if self.server.use_dbus:
1334
client.Rejected("Disabled")
1337
if client._approved or not client.approval_delay:
1338
#We are approved or approval is disabled
1340
elif client._approved is None:
1341
logger.info("Client %s needs approval",
1343
if self.server.use_dbus:
1345
client.NeedApproval(
1346
client.approval_delay_milliseconds(),
1347
client.approved_by_default)
1349
logger.warning("Client %s was not approved",
1351
if self.server.use_dbus:
1353
client.Rejected("Denied")
1356
#wait until timeout or approved
1357
#x = float(client._timedelta_to_milliseconds(delay))
1358
time = datetime.datetime.now()
1359
client.changedstate.acquire()
1360
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
1361
client.changedstate.release()
1362
time2 = datetime.datetime.now()
1363
if (time2 - time) >= delay:
1364
if not client.approved_by_default:
1365
logger.warning("Client %s timed out while"
1366
" waiting for approval",
1368
if self.server.use_dbus:
1370
client.Rejected("Approval timed out")
1375
delay -= time2 - time
1378
while sent_size < len(client.secret):
1380
sent = session.send(client.secret[sent_size:])
1381
except gnutls.errors.GNUTLSError as error:
1382
logger.warning("gnutls send failed")
1384
logger.debug("Sent: %d, remaining: %d",
1385
sent, len(client.secret)
1386
- (sent_size + sent))
1389
logger.info("Sending secret to %s", client.name)
1390
# bump the timeout as if seen
1391
client.checked_ok(client.extended_timeout)
1392
if self.server.use_dbus:
1397
if approval_required:
1398
client.approvals_pending -= 1
1401
except gnutls.errors.GNUTLSError as error:
1402
logger.warning("GnuTLS bye failed")
1405
def peer_certificate(session):
1406
"Return the peer's OpenPGP certificate as a bytestring"
1407
# If not an OpenPGP certificate...
1408
if (gnutls.library.functions
1409
.gnutls_certificate_type_get(session._c_object)
1410
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1411
# ...do the normal thing
1412
return session.peer_certificate
1413
list_size = ctypes.c_uint(1)
1414
cert_list = (gnutls.library.functions
1415
.gnutls_certificate_get_peers
1416
(session._c_object, ctypes.byref(list_size)))
1417
if not bool(cert_list) and list_size.value != 0:
1418
raise gnutls.errors.GNUTLSError("error getting peer"
1420
if list_size.value == 0:
1423
return ctypes.string_at(cert.data, cert.size)
1426
def fingerprint(openpgp):
1427
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1428
# New GnuTLS "datum" with the OpenPGP public key
1429
datum = (gnutls.library.types
1430
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1433
ctypes.c_uint(len(openpgp))))
1434
# New empty GnuTLS certificate
1435
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1436
(gnutls.library.functions
1437
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1438
# Import the OpenPGP public key into the certificate
1439
(gnutls.library.functions
1440
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1441
gnutls.library.constants
1442
.GNUTLS_OPENPGP_FMT_RAW))
1443
# Verify the self signature in the key
1444
crtverify = ctypes.c_uint()
1445
(gnutls.library.functions
1446
.gnutls_openpgp_crt_verify_self(crt, 0,
1447
ctypes.byref(crtverify)))
1448
if crtverify.value != 0:
1449
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1450
raise (gnutls.errors.CertificateSecurityError
1452
# New buffer for the fingerprint
1453
buf = ctypes.create_string_buffer(20)
1454
buf_len = ctypes.c_size_t()
1455
# Get the fingerprint from the certificate into the buffer
1456
(gnutls.library.functions
1457
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1458
ctypes.byref(buf_len)))
1459
# Deinit the certificate
1460
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1461
# Convert the buffer to a Python bytestring
1462
fpr = ctypes.string_at(buf, buf_len.value)
1463
# Convert the bytestring to hexadecimal notation
1464
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
1468
class MultiprocessingMixIn(object):
1469
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1470
def sub_process_main(self, request, address):
1472
self.finish_request(request, address)
1474
self.handle_error(request, address)
1475
self.close_request(request)
1477
def process_request(self, request, address):
1478
"""Start a new process to process the request."""
1479
multiprocessing.Process(target = self.sub_process_main,
1480
args = (request, address)).start()
1483
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1484
""" adds a pipe to the MixIn """
1485
def process_request(self, request, client_address):
1486
"""Overrides and wraps the original process_request().
1488
This function creates a new pipe in self.pipe
1490
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1492
super(MultiprocessingMixInWithPipe,
1493
self).process_request(request, client_address)
1494
self.child_pipe.close()
1495
self.add_pipe(parent_pipe)
1497
def add_pipe(self, parent_pipe):
1498
"""Dummy function; override as necessary"""
1499
raise NotImplementedError
1502
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1503
socketserver.TCPServer, object):
1504
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
496
settings: Server settings
497
clients: Set() of Client objects
1507
enabled: Boolean; whether this server is activated yet
1508
interface: None or a network interface name (string)
1509
use_ipv6: Boolean; to use IPv6 or not
499
address_family = socket.AF_INET6
500
def __init__(self, *args, **kwargs):
501
if "settings" in kwargs:
502
self.settings = kwargs["settings"]
503
del kwargs["settings"]
504
if "clients" in kwargs:
505
self.clients = kwargs["clients"]
506
del kwargs["clients"]
507
return super(type(self), self).__init__(*args, **kwargs)
1511
def __init__(self, server_address, RequestHandlerClass,
1512
interface=None, use_ipv6=True):
1513
self.interface = interface
1515
self.address_family = socket.AF_INET6
1516
socketserver.TCPServer.__init__(self, server_address,
1517
RequestHandlerClass)
508
1518
def server_bind(self):
509
1519
"""This overrides the normal server_bind() function
510
1520
to bind to an interface if one was specified, and also NOT to
511
1521
bind to an address or port if they were not specified."""
512
if self.settings["interface"] != avahi.IF_UNSPEC:
513
# 25 is from /usr/include/asm-i486/socket.h
514
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
516
self.socket.setsockopt(socket.SOL_SOCKET,
518
self.settings["interface"])
519
except socket.error, error:
520
if error[0] == errno.EPERM:
521
logger.warning(u"No permission to"
522
u" bind to interface %s",
523
self.settings["interface"])
1522
if self.interface is not None:
1523
if SO_BINDTODEVICE is None:
1524
logger.error("SO_BINDTODEVICE does not exist;"
1525
" cannot bind to interface %s",
1529
self.socket.setsockopt(socket.SOL_SOCKET,
1533
except socket.error as error:
1534
if error[0] == errno.EPERM:
1535
logger.error("No permission to"
1536
" bind to interface %s",
1538
elif error[0] == errno.ENOPROTOOPT:
1539
logger.error("SO_BINDTODEVICE not available;"
1540
" cannot bind to interface %s",
526
1544
# Only bind(2) the socket if we really need to.
527
1545
if self.server_address[0] or self.server_address[1]:
528
1546
if not self.server_address[0]:
530
self.server_address = (in6addr_any,
1547
if self.address_family == socket.AF_INET6:
1548
any_address = "::" # in6addr_any
1550
any_address = socket.INADDR_ANY
1551
self.server_address = (any_address,
531
1552
self.server_address[1])
532
elif self.server_address[1] is None:
1553
elif not self.server_address[1]:
533
1554
self.server_address = (self.server_address[0],
535
return super(type(self), self).server_bind()
1556
# if self.interface:
1557
# self.server_address = (self.server_address[0],
1562
return socketserver.TCPServer.server_bind(self)
1565
class MandosServer(IPv6_TCPServer):
1569
clients: set of Client objects
1570
gnutls_priority GnuTLS priority string
1571
use_dbus: Boolean; to emit D-Bus signals or not
1573
Assumes a gobject.MainLoop event loop.
1575
def __init__(self, server_address, RequestHandlerClass,
1576
interface=None, use_ipv6=True, clients=None,
1577
gnutls_priority=None, use_dbus=True):
1578
self.enabled = False
1579
self.clients = clients
1580
if self.clients is None:
1581
self.clients = set()
1582
self.use_dbus = use_dbus
1583
self.gnutls_priority = gnutls_priority
1584
IPv6_TCPServer.__init__(self, server_address,
1585
RequestHandlerClass,
1586
interface = interface,
1587
use_ipv6 = use_ipv6)
1588
def server_activate(self):
1590
return socketserver.TCPServer.server_activate(self)
1593
def add_pipe(self, parent_pipe):
1594
# Call "handle_ipc" for both data and EOF events
1595
gobject.io_add_watch(parent_pipe.fileno(),
1596
gobject.IO_IN | gobject.IO_HUP,
1597
functools.partial(self.handle_ipc,
1598
parent_pipe = parent_pipe))
1600
def handle_ipc(self, source, condition, parent_pipe=None,
1601
client_object=None):
1603
gobject.IO_IN: "IN", # There is data to read.
1604
gobject.IO_OUT: "OUT", # Data can be written (without
1606
gobject.IO_PRI: "PRI", # There is urgent data to read.
1607
gobject.IO_ERR: "ERR", # Error condition.
1608
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1609
# broken, usually for pipes and
1612
conditions_string = ' | '.join(name
1614
condition_names.iteritems()
1615
if cond & condition)
1616
# error or the other end of multiprocessing.Pipe has closed
1617
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1620
# Read a request from the child
1621
request = parent_pipe.recv()
1622
command = request[0]
1624
if command == 'init':
1626
address = request[2]
1628
for c in self.clients:
1629
if c.fingerprint == fpr:
1633
logger.info("Client not found for fingerprint: %s, ad"
1634
"dress: %s", fpr, address)
1637
mandos_dbus_service.ClientNotFound(fpr, address[0])
1638
parent_pipe.send(False)
1641
gobject.io_add_watch(parent_pipe.fileno(),
1642
gobject.IO_IN | gobject.IO_HUP,
1643
functools.partial(self.handle_ipc,
1644
parent_pipe = parent_pipe,
1645
client_object = client))
1646
parent_pipe.send(True)
1647
# remove the old hook in favor of the new above hook on same fileno
1649
if command == 'funcall':
1650
funcname = request[1]
1654
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1656
if command == 'getattr':
1657
attrname = request[1]
1658
if callable(client_object.__getattribute__(attrname)):
1659
parent_pipe.send(('function',))
1661
parent_pipe.send(('data', client_object.__getattribute__(attrname)))
1663
if command == 'setattr':
1664
attrname = request[1]
1666
setattr(client_object, attrname, value)
538
1671
def string_to_delta(interval):
539
1672
"""Parse a string and return a datetime.timedelta
541
1674
>>> string_to_delta('7d')
542
1675
datetime.timedelta(7)
543
1676
>>> string_to_delta('60s')
687
1807
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
688
1808
"servicename": "Mandos",
691
1814
# Parse config file for server-global settings
692
server_config = ConfigParser.SafeConfigParser(server_defaults)
1815
server_config = configparser.SafeConfigParser(server_defaults)
693
1816
del server_defaults
694
server_config.read(os.path.join(options.configdir, "server.conf"))
695
server_section = "server"
1817
server_config.read(os.path.join(options.configdir,
696
1819
# Convert the SafeConfigParser object to a dict
697
server_settings = dict(server_config.items(server_section))
698
# Use getboolean on the boolean config option
699
server_settings["debug"] = server_config.getboolean\
700
(server_section, "debug")
1820
server_settings = server_config.defaults()
1821
# Use the appropriate methods on the non-string config options
1822
for option in ("debug", "use_dbus", "use_ipv6"):
1823
server_settings[option] = server_config.getboolean("DEFAULT",
1825
if server_settings["port"]:
1826
server_settings["port"] = server_config.getint("DEFAULT",
701
1828
del server_config
702
if not server_settings["interface"]:
703
server_settings["interface"] = avahi.IF_UNSPEC
705
1830
# Override the settings from the config file with command line
706
1831
# options, if set.
707
1832
for option in ("interface", "address", "port", "debug",
708
"priority", "servicename", "configdir"):
1833
"priority", "servicename", "configdir",
1834
"use_dbus", "use_ipv6", "debuglevel"):
709
1835
value = getattr(options, option)
710
1836
if value is not None:
711
1837
server_settings[option] = value
1839
# Force all strings to be unicode
1840
for option in server_settings.keys():
1841
if type(server_settings[option]) is str:
1842
server_settings[option] = unicode(server_settings[option])
713
1843
# Now we have our good server settings in "server_settings"
1845
##################################################################
1848
debug = server_settings["debug"]
1849
debuglevel = server_settings["debuglevel"]
1850
use_dbus = server_settings["use_dbus"]
1851
use_ipv6 = server_settings["use_ipv6"]
1853
if server_settings["servicename"] != "Mandos":
1854
syslogger.setFormatter(logging.Formatter
1855
('Mandos (%s) [%%(process)d]:'
1856
' %%(levelname)s: %%(message)s'
1857
% server_settings["servicename"]))
715
1859
# Parse config file with clients
716
client_defaults = { "timeout": "1h",
718
"checker": "fping -q -- %%(fqdn)s",
1860
client_defaults = { "timeout": "5m",
1861
"extended_timeout": "15m",
1863
"checker": "fping -q -- %%(host)s",
1865
"approval_delay": "0s",
1866
"approval_duration": "1s",
720
client_config = ConfigParser.SafeConfigParser(client_defaults)
1868
client_config = configparser.SafeConfigParser(client_defaults)
721
1869
client_config.read(os.path.join(server_settings["configdir"],
722
1870
"clients.conf"))
725
service = AvahiService(name = server_settings["servicename"],
726
type = "_mandos._tcp", );
1872
global mandos_dbus_service
1873
mandos_dbus_service = None
1875
tcp_server = MandosServer((server_settings["address"],
1876
server_settings["port"]),
1878
interface=(server_settings["interface"]
1882
server_settings["priority"],
1885
pidfilename = "/var/run/mandos.pid"
1887
pidfile = open(pidfilename, "w")
1889
logger.error("Could not open file %r", pidfilename)
1892
uid = pwd.getpwnam("_mandos").pw_uid
1893
gid = pwd.getpwnam("_mandos").pw_gid
1896
uid = pwd.getpwnam("mandos").pw_uid
1897
gid = pwd.getpwnam("mandos").pw_gid
1900
uid = pwd.getpwnam("nobody").pw_uid
1901
gid = pwd.getpwnam("nobody").pw_gid
1908
except OSError as error:
1909
if error[0] != errno.EPERM:
1912
if not debug and not debuglevel:
1913
syslogger.setLevel(logging.WARNING)
1914
console.setLevel(logging.WARNING)
1916
level = getattr(logging, debuglevel.upper())
1917
syslogger.setLevel(level)
1918
console.setLevel(level)
1921
# Enable all possible GnuTLS debugging
1923
# "Use a log level over 10 to enable all debugging options."
1925
gnutls.library.functions.gnutls_global_set_log_level(11)
1927
@gnutls.library.types.gnutls_log_func
1928
def debug_gnutls(level, string):
1929
logger.debug("GnuTLS: %s", string[:-1])
1931
(gnutls.library.functions
1932
.gnutls_global_set_log_function(debug_gnutls))
1934
# Redirect stdin so all checkers get /dev/null
1935
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1936
os.dup2(null, sys.stdin.fileno())
1940
# No console logging
1941
logger.removeHandler(console)
1943
# Need to fork before connecting to D-Bus
1945
# Close all input and output, do double fork, etc.
728
1948
global main_loop
731
1949
# From the Avahi example code
732
1950
DBusGMainLoop(set_as_default=True )
733
1951
main_loop = gobject.MainLoop()
734
1952
bus = dbus.SystemBus()
735
server = dbus.Interface(
736
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
737
avahi.DBUS_INTERFACE_SERVER )
738
1953
# End of Avahi example code
740
debug = server_settings["debug"]
743
console = logging.StreamHandler()
744
# console.setLevel(logging.DEBUG)
745
console.setFormatter(logging.Formatter\
746
('%(levelname)s: %(message)s'))
747
logger.addHandler(console)
751
def remove_from_clients(client):
752
clients.remove(client)
754
logger.debug(u"No clients left, exiting")
757
clients.update(Set(Client(name=section,
758
stop_hook = remove_from_clients,
759
**(dict(client_config\
761
for section in client_config.sections()))
1956
bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",
1957
bus, do_not_queue=True)
1958
bus_name2 = dbus.service.BusName("se.recompile.Mandos",
1959
bus, do_not_queue=True)
1960
except dbus.exceptions.NameExistsException as e:
1961
logger.error(unicode(e) + ", disabling D-Bus")
1963
server_settings["use_dbus"] = False
1964
tcp_server.use_dbus = False
1965
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1966
service = AvahiService(name = server_settings["servicename"],
1967
servicetype = "_mandos._tcp",
1968
protocol = protocol, bus = bus)
1969
if server_settings["interface"]:
1970
service.interface = (if_nametoindex
1971
(str(server_settings["interface"])))
1973
global multiprocessing_manager
1974
multiprocessing_manager = multiprocessing.Manager()
1976
client_class = Client
1978
client_class = functools.partial(ClientDBus, bus = bus)
1979
def client_config_items(config, section):
1980
special_settings = {
1981
"approved_by_default":
1982
lambda: config.getboolean(section,
1983
"approved_by_default"),
1985
for name, value in config.items(section):
1987
yield (name, special_settings[name]())
1991
tcp_server.clients.update(set(
1992
client_class(name = section,
1993
config= dict(client_config_items(
1994
client_config, section)))
1995
for section in client_config.sections()))
1996
if not tcp_server.clients:
1997
logger.warning("No clients defined")
2003
pidfile.write(str(pid) + "\n".encode("utf-8"))
2006
logger.error("Could not write to file %r with PID %d",
2009
# "pidfile" was never created
2013
signal.signal(signal.SIGINT, signal.SIG_IGN)
2015
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2016
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2019
class MandosDBusService(dbus.service.Object):
2020
"""A D-Bus proxy object"""
2022
dbus.service.Object.__init__(self, bus, "/")
2023
_interface = "se.bsnet.fukt.Mandos"
2025
@dbus.service.signal(_interface, signature="o")
2026
def ClientAdded(self, objpath):
2030
@dbus.service.signal(_interface, signature="ss")
2031
def ClientNotFound(self, fingerprint, address):
2035
@dbus.service.signal(_interface, signature="os")
2036
def ClientRemoved(self, objpath, name):
2040
@dbus.service.method(_interface, out_signature="ao")
2041
def GetAllClients(self):
2043
return dbus.Array(c.dbus_object_path
2044
for c in tcp_server.clients)
2046
@dbus.service.method(_interface,
2047
out_signature="a{oa{sv}}")
2048
def GetAllClientsWithProperties(self):
2050
return dbus.Dictionary(
2051
((c.dbus_object_path, c.GetAll(""))
2052
for c in tcp_server.clients),
2055
@dbus.service.method(_interface, in_signature="o")
2056
def RemoveClient(self, object_path):
2058
for c in tcp_server.clients:
2059
if c.dbus_object_path == object_path:
2060
tcp_server.clients.remove(c)
2061
c.remove_from_connection()
2062
# Don't signal anything except ClientRemoved
2063
c.disable(quiet=True)
2065
self.ClientRemoved(object_path, c.name)
2067
raise KeyError(object_path)
2071
mandos_dbus_service = MandosDBusService()
767
2074
"Cleanup function; run on exit"
769
# From the Avahi example code
770
if not group is None:
773
# End of Avahi example code
776
client = clients.pop()
777
client.stop_hook = None
2077
while tcp_server.clients:
2078
client = tcp_server.clients.pop()
2080
client.remove_from_connection()
2081
client.disable_hook = None
2082
# Don't signal anything except ClientRemoved
2083
client.disable(quiet=True)
2086
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
780
2089
atexit.register(cleanup)
783
signal.signal(signal.SIGINT, signal.SIG_IGN)
784
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
785
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
787
for client in clients:
790
tcp_server = IPv6_TCPServer((server_settings["address"],
791
server_settings["port"]),
793
settings=server_settings,
2091
for client in tcp_server.clients:
2094
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2098
tcp_server.server_activate()
795
2100
# Find out what port we got
796
2101
service.port = tcp_server.socket.getsockname()[1]
797
logger.debug(u"Now listening on port %d", service.port)
2103
logger.info("Now listening on address %r, port %d,"
2104
" flowinfo %d, scope_id %d"
2105
% tcp_server.socket.getsockname())
2107
logger.info("Now listening on address %r, port %d"
2108
% tcp_server.socket.getsockname())
799
if not server_settings["interface"]:
800
service.interface = if_nametoindex\
801
(server_settings["interface"])
2110
#service.interface = tcp_server.socket.getsockname()[3]
804
2113
# From the Avahi example code
805
server.connect_to_signal("StateChanged", server_state_changed)
807
server_state_changed(server.GetState())
808
except dbus.exceptions.DBusException, error:
809
logger.critical(u"DBusException: %s", error)
2116
except dbus.exceptions.DBusException as error:
2117
logger.critical("DBusException: %s", error)
811
2120
# End of Avahi example code
813
2122
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
814
2123
lambda *args, **kwargs:
815
tcp_server.handle_request\
816
(*args[2:], **kwargs) or True)
2124
(tcp_server.handle_request
2125
(*args[2:], **kwargs) or True))
818
2127
logger.debug("Starting main loop")
819
main_loop_started = True
821
except AvahiError, error:
822
logger.critical(u"AvahiError: %s" + unicode(error))
2129
except AvahiError as error:
2130
logger.critical("AvahiError: %s", error)
824
2133
except KeyboardInterrupt:
2135
print("", file=sys.stderr)
2136
logger.debug("Server received KeyboardInterrupt")
2137
logger.debug("Server exiting")
2138
# Must run before the D-Bus bus name gets deregistered
828
2142
if __name__ == '__main__':