104
131
max_renames: integer; maximum number of renames
105
132
rename_count: integer; counter so we only rename after collisions
106
133
a sensible number of times
134
group: D-Bus Entry Group
136
bus: dbus.SystemBus()
108
138
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
109
type = None, port = None, TXT = None, domain = "",
110
host = "", max_renames = 32768):
139
servicetype = None, port = None, TXT = None,
140
domain = "", host = "", max_renames = 32768,
141
protocol = avahi.PROTO_UNSPEC, bus = None):
111
142
self.interface = interface
144
self.type = servicetype
146
self.TXT = TXT if TXT is not None else []
119
147
self.domain = domain
121
149
self.rename_count = 0
122
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
123
156
def rename(self):
124
157
"""Derived from the Avahi example code"""
125
158
if self.rename_count >= self.max_renames:
126
logger.critical(u"No suitable service name found after %i"
127
u" retries, exiting.", rename_count)
159
logger.critical("No suitable Zeroconf service name found"
160
" after %i retries, exiting.",
128
162
raise AvahiServiceError("Too many renames")
129
self.name = server.GetAlternativeServiceName(self.name)
130
logger.info(u"Changing name to %r ...", str(self.name))
131
syslogger.setFormatter(logging.Formatter\
132
('Mandos (%s): %%(levelname)s:'
133
' %%(message)s' % self.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)
136
177
self.rename_count += 1
137
178
def remove(self):
138
179
"""Derived from the Avahi example code"""
139
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:
142
186
"""Derived from the Avahi example code"""
145
group = dbus.Interface\
146
(bus.get_object(avahi.DBUS_NAME,
147
server.EntryGroupNew()),
148
avahi.DBUS_INTERFACE_ENTRY_GROUP)
149
group.connect_to_signal('StateChanged',
150
entry_group_state_changed)
151
logger.debug(u"Adding service '%s' of type '%s' ...",
152
service.name, service.type)
154
self.interface, # interface
155
avahi.PROTO_INET6, # protocol
156
dbus.UInt32(0), # flags
157
self.name, self.type,
158
self.domain, self.host,
159
dbus.UInt16(self.port),
160
avahi.string_array_to_txt_array(self.TXT))
163
# From the Avahi example code:
164
group = None # our entry group
165
# 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))
168
274
class Client(object):
169
275
"""A representation of a client host served by this server.
171
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
172
295
fingerprint: string (40 or 32 hexadecimal digits); used to
173
296
uniquely identify the client
174
secret: bytestring; sent verbatim (over TLS) to client
175
host: string; available for use by the checker command
176
created: datetime.datetime(); object creation, not client host
177
last_checked_ok: datetime.datetime() or None if not yet checked OK
178
timeout: datetime.timedelta(); How long from last_checked_ok
179
until this client is invalid
180
interval: datetime.timedelta(); How often to start a new checker
181
stop_hook: If set, called by stop() as stop_hook(self)
182
checker: subprocess.Popen(); a running checker process used
183
to see if the client lives.
184
'None' if no process is running.
185
checker_initiator_tag: a gobject event source tag, or None
186
stop_initiator_tag: - '' -
187
checker_callback_tag: - '' -
188
checker_command: string; External command which is run to check if
189
client lives. %() expansions are done at
190
runtime with vars(self) as dict, so that for
191
instance %(name)s can be used in the command.
193
_timeout: Real variable for 'timeout'
194
_interval: Real variable for 'interval'
195
_timeout_milliseconds: Used when calling gobject.timeout_add()
196
_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
198
def _set_timeout(self, timeout):
199
"Setter function for 'timeout' attribute"
200
self._timeout = timeout
201
self._timeout_milliseconds = ((self.timeout.days
202
* 24 * 60 * 60 * 1000)
203
+ (self.timeout.seconds * 1000)
204
+ (self.timeout.microseconds
206
timeout = property(lambda self: self._timeout,
209
def _set_interval(self, interval):
210
"Setter function for 'interval' attribute"
211
self._interval = interval
212
self._interval_milliseconds = ((self.interval.days
213
* 24 * 60 * 60 * 1000)
214
+ (self.interval.seconds
216
+ (self.interval.microseconds
218
interval = property(lambda self: self._interval,
221
def __init__(self, name = None, stop_hook=None, config={}):
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):
222
334
"""Note: the 'checker' key in 'config' sets the
223
335
'checker_command' attribute and *not* the 'checker'
226
logger.debug(u"Creating client %r", self.name)
340
logger.debug("Creating client %r", self.name)
227
341
# Uppercase and remove spaces from fingerprint for later
228
342
# comparison purposes with return value from the fingerprint()
230
self.fingerprint = config["fingerprint"].upper()\
232
logger.debug(u" Fingerprint: %s", self.fingerprint)
344
self.fingerprint = (config["fingerprint"].upper()
346
logger.debug(" Fingerprint: %s", self.fingerprint)
233
347
if "secret" in config:
234
self.secret = config["secret"].decode(u"base64")
348
self.secret = config["secret"].decode("base64")
235
349
elif "secfile" in config:
236
sf = open(config["secfile"])
237
self.secret = sf.read()
350
with open(os.path.expanduser(os.path.expandvars
351
(config["secfile"])),
353
self.secret = secfile.read()
240
raise TypeError(u"No secret or secfile for client %s"
355
raise TypeError("No secret or secfile for client %s"
242
357
self.host = config.get("host", "")
243
self.created = datetime.datetime.now()
358
self.created = datetime.datetime.utcnow()
360
self.last_approval_request = None
361
self.last_enabled = None
244
362
self.last_checked_ok = None
245
363
self.timeout = string_to_delta(config["timeout"])
364
self.extended_timeout = string_to_delta(config["extended_timeout"])
246
365
self.interval = string_to_delta(config["interval"])
247
self.stop_hook = stop_hook
366
self.disable_hook = disable_hook
248
367
self.checker = None
249
368
self.checker_initiator_tag = None
250
self.stop_initiator_tag = None
369
self.disable_initiator_tag = None
251
371
self.checker_callback_tag = None
252
self.check_command = config["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()
254
391
"""Start this client's checker and timeout hooks"""
392
if getattr(self, "enabled", False):
395
self.send_changedstate()
255
396
# Schedule a new checker to be started an 'interval' from now,
256
397
# and every interval from then on.
257
self.checker_initiator_tag = gobject.timeout_add\
258
(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()
260
408
# Also start a new checker *right now*.
261
409
self.start_checker()
262
# Schedule a stop() when 'timeout' has passed
263
self.stop_initiator_tag = gobject.timeout_add\
264
(self._timeout_milliseconds,
268
The possibility that a client might be restarted is left open,
269
but not currently used."""
270
# If this client doesn't have a secret, it is already stopped.
271
if hasattr(self, "secret") and self.secret:
272
logger.info(u"Stopping client %s", self.name)
411
def disable(self, quiet=True):
412
"""Disable this client."""
413
if not getattr(self, "enabled", False):
276
if getattr(self, "stop_initiator_tag", False):
277
gobject.source_remove(self.stop_initiator_tag)
278
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
279
423
if getattr(self, "checker_initiator_tag", False):
280
424
gobject.source_remove(self.checker_initiator_tag)
281
425
self.checker_initiator_tag = None
282
426
self.stop_checker()
427
if self.disable_hook:
428
self.disable_hook(self)
285
430
# Do not run this again if called by a gobject.timeout_add
287
433
def __del__(self):
288
self.stop_hook = None
290
def checker_callback(self, pid, condition):
434
self.disable_hook = None
437
def checker_callback(self, pid, condition, command):
291
438
"""The checker has completed, so take appropriate actions."""
292
now = datetime.datetime.now()
293
439
self.checker_callback_tag = None
294
440
self.checker = None
295
if os.WIFEXITED(condition) \
296
and (os.WEXITSTATUS(condition) == 0):
297
logger.info(u"Checker for %(name)s succeeded",
299
self.last_checked_ok = now
300
gobject.source_remove(self.stop_initiator_tag)
301
self.stop_initiator_tag = gobject.timeout_add\
302
(self._timeout_milliseconds,
304
elif not os.WIFEXITED(condition):
305
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?",
308
logger.info(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()
310
472
def start_checker(self):
311
473
"""Start a new checker subprocess if one is not running.
312
475
If a checker already exists, leave it running and do
314
477
# The reason for not killing a running checker is that if we
359
551
self.checker_callback_tag = None
360
552
if getattr(self, "checker", None) is None:
362
logger.debug(u"Stopping checker for %(name)s", vars(self))
554
logger.debug("Stopping checker for %(name)s", vars(self))
364
556
os.kill(self.checker.pid, signal.SIGTERM)
366
558
#if self.checker.poll() is None:
367
559
# os.kill(self.checker.pid, signal.SIGKILL)
368
except OSError, error:
560
except OSError as error:
369
561
if error.errno != errno.ESRCH: # No such process
371
563
self.checker = None
372
def still_valid(self):
373
"""Has the timeout not yet passed for this client?"""
374
now = datetime.datetime.now()
375
if self.last_checked_ok is None:
376
return now < (self.created + self.timeout)
378
return now < (self.last_checked_ok + self.timeout)
381
def peer_certificate(session):
382
"Return the peer's OpenPGP certificate as a bytestring"
383
# If not an OpenPGP certificate...
384
if gnutls.library.functions.gnutls_certificate_type_get\
385
(session._c_object) \
386
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
387
# ...do the normal thing
388
return session.peer_certificate
389
list_size = ctypes.c_uint()
390
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
391
(session._c_object, ctypes.byref(list_size))
392
if list_size.value == 0:
395
return ctypes.string_at(cert.data, cert.size)
398
def fingerprint(openpgp):
399
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
400
# New GnuTLS "datum" with the OpenPGP public key
401
datum = gnutls.library.types.gnutls_datum_t\
402
(ctypes.cast(ctypes.c_char_p(openpgp),
403
ctypes.POINTER(ctypes.c_ubyte)),
404
ctypes.c_uint(len(openpgp)))
405
# New empty GnuTLS certificate
406
crt = gnutls.library.types.gnutls_openpgp_crt_t()
407
gnutls.library.functions.gnutls_openpgp_crt_init\
409
# Import the OpenPGP public key into the certificate
410
gnutls.library.functions.gnutls_openpgp_crt_import\
411
(crt, ctypes.byref(datum),
412
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
413
# Verify the self signature in the key
414
crtverify = ctypes.c_uint();
415
gnutls.library.functions.gnutls_openpgp_crt_verify_self\
416
(crt, ctypes.c_uint(0), ctypes.byref(crtverify))
417
if crtverify.value != 0:
418
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
419
raise gnutls.errors.CertificateSecurityError("Verify failed")
420
# New buffer for the fingerprint
421
buffer = ctypes.create_string_buffer(20)
422
buffer_length = ctypes.c_size_t()
423
# Get the fingerprint from the certificate into the buffer
424
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
425
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
426
# Deinit the certificate
427
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
428
# Convert the buffer to a Python bytestring
429
fpr = ctypes.string_at(buffer, buffer_length.value)
430
# Convert the bytestring to hexadecimal notation
431
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
435
class tcp_handler(SocketServer.BaseRequestHandler, object):
436
"""A TCP request handler class.
437
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.
438
1254
Note: This will run in its own forked process."""
440
1256
def handle(self):
441
logger.info(u"TCP connection from: %s",
442
unicode(self.client_address))
443
session = gnutls.connection.ClientSession\
444
(self.request, gnutls.connection.X509Credentials())
446
line = self.request.makefile().readline()
447
logger.debug(u"Protocol version: %r", line)
449
if int(line.strip().split()[0]) > 1:
451
except (ValueError, IndexError, RuntimeError), error:
452
logger.error(u"Unknown protocol version: %s", error)
455
# Note: gnutls.connection.X509Credentials is really a generic
456
# GnuTLS certificate credentials object so long as no X.509
457
# keys are added to it. Therefore, we can use it here despite
458
# using OpenPGP certificates.
460
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
461
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
463
priority = "NORMAL" # Fallback default, since this
465
if self.server.settings["priority"]:
466
priority = self.server.settings["priority"]
467
gnutls.library.functions.gnutls_priority_set_direct\
468
(session._c_object, priority, None);
472
except gnutls.errors.GNUTLSError, error:
473
logger.warning(u"Handshake failed: %s", error)
474
# Do not run session.bye() here: the session is not
475
# established. Just abandon the request.
478
fpr = fingerprint(peer_certificate(session))
479
except (TypeError, gnutls.errors.GNUTLSError), error:
480
logger.warning(u"Bad certificate: %s", error)
483
logger.debug(u"Fingerprint: %s", fpr)
485
for c in self.server.clients:
486
if c.fingerprint == fpr:
490
logger.warning(u"Client not found for fingerprint: %s",
494
# Have to check if client.still_valid(), since it is possible
495
# that the client timed out while establishing the GnuTLS
497
if not client.still_valid():
498
logger.warning(u"Client %(name)s is invalid",
503
while sent_size < len(client.secret):
504
sent = session.send(client.secret[sent_size:])
505
logger.debug(u"Sent: %d, remaining: %d",
506
sent, len(client.secret)
507
- (sent_size + sent))
512
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
513
"""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
515
settings: Server settings
516
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
518
address_family = socket.AF_INET6
519
def __init__(self, *args, **kwargs):
520
if "settings" in kwargs:
521
self.settings = kwargs["settings"]
522
del kwargs["settings"]
523
if "clients" in kwargs:
524
self.clients = kwargs["clients"]
525
del kwargs["clients"]
526
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)
527
1518
def server_bind(self):
528
1519
"""This overrides the normal server_bind() function
529
1520
to bind to an interface if one was specified, and also NOT to
530
1521
bind to an address or port if they were not specified."""
531
if self.settings["interface"]:
532
# 25 is from /usr/include/asm-i486/socket.h
533
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
535
self.socket.setsockopt(socket.SOL_SOCKET,
537
self.settings["interface"])
538
except socket.error, error:
539
if error[0] == errno.EPERM:
540
logger.error(u"No permission to"
541
u" bind to interface %s",
542
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",
545
1544
# Only bind(2) the socket if we really need to.
546
1545
if self.server_address[0] or self.server_address[1]:
547
1546
if not self.server_address[0]:
549
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,
550
1552
self.server_address[1])
551
1553
elif not self.server_address[1]:
552
1554
self.server_address = (self.server_address[0],
554
# if self.settings["interface"]:
1556
# if self.interface:
555
1557
# self.server_address = (self.server_address[0],
558
1560
# if_nametoindex
561
return super(type(self), self).server_bind()
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)
564
1671
def string_to_delta(interval):
565
1672
"""Parse a string and return a datetime.timedelta
567
1674
>>> string_to_delta('7d')
568
1675
datetime.timedelta(7)
569
1676
>>> string_to_delta('60s')