131
104
max_renames: integer; maximum number of renames
132
105
rename_count: integer; counter so we only rename after collisions
133
106
a sensible number of times
134
group: D-Bus Entry Group
136
bus: dbus.SystemBus()
138
108
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
139
servicetype = None, port = None, TXT = None,
140
domain = "", host = "", max_renames = 32768,
141
protocol = avahi.PROTO_UNSPEC, bus = None):
109
type = None, port = None, TXT = None, domain = "",
110
host = "", max_renames = 32768):
142
111
self.interface = interface
144
self.type = servicetype
146
self.TXT = TXT if TXT is not None else []
147
119
self.domain = domain
149
121
self.rename_count = 0
150
122
self.max_renames = max_renames
151
self.protocol = protocol
152
self.group = None # our entry group
155
self.entry_group_state_changed_match = None
156
123
def rename(self):
157
124
"""Derived from the Avahi example code"""
158
125
if self.rename_count >= self.max_renames:
159
logger.critical("No suitable Zeroconf service name found"
160
" after %i retries, exiting.",
126
logger.critical(u"No suitable service name found after %i"
127
u" retries, exiting.", rename_count)
162
128
raise AvahiServiceError("Too many renames")
163
self.name = unicode(self.server
164
.GetAlternativeServiceName(self.name))
165
logger.info("Changing Zeroconf service name to %r ...",
167
syslogger.setFormatter(logging.Formatter
168
('Mandos (%s) [%%(process)d]:'
169
' %%(levelname)s: %%(message)s'
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))
174
except dbus.exceptions.DBusException as error:
175
logger.critical("DBusException: %s", error)
178
136
self.rename_count += 1
179
137
def remove(self):
180
138
"""Derived from the Avahi example code"""
181
if self.entry_group_state_changed_match is not None:
182
self.entry_group_state_changed_match.remove()
183
self.entry_group_state_changed_match = None
184
if self.group is not None:
139
if group is not None:
187
142
"""Derived from the Avahi example code"""
189
if self.group is None:
190
self.group = dbus.Interface(
191
self.bus.get_object(avahi.DBUS_NAME,
192
self.server.EntryGroupNew()),
193
avahi.DBUS_INTERFACE_ENTRY_GROUP)
194
self.entry_group_state_changed_match = (
195
self.group.connect_to_signal(
196
'StateChanged', self .entry_group_state_changed))
197
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
198
self.name, self.type)
199
self.group.AddService(
202
dbus.UInt32(0), # flags
203
self.name, self.type,
204
self.domain, self.host,
205
dbus.UInt16(self.port),
206
avahi.string_array_to_txt_array(self.TXT))
208
def entry_group_state_changed(self, state, error):
209
"""Derived from the Avahi example code"""
210
logger.debug("Avahi entry group state change: %i", state)
212
if state == avahi.ENTRY_GROUP_ESTABLISHED:
213
logger.debug("Zeroconf service established.")
214
elif state == avahi.ENTRY_GROUP_COLLISION:
215
logger.info("Zeroconf service name collision.")
217
elif state == avahi.ENTRY_GROUP_FAILURE:
218
logger.critical("Avahi: Error in group state changed %s",
220
raise AvahiGroupError("State changed: %s"
223
"""Derived from the Avahi example code"""
224
if self.group is not None:
227
except (dbus.exceptions.UnknownMethodException,
228
dbus.exceptions.DBusException) as e:
232
def server_state_changed(self, state, error=None):
233
"""Derived from the Avahi example code"""
234
logger.debug("Avahi server state change: %i", state)
235
bad_states = { avahi.SERVER_INVALID:
236
"Zeroconf server invalid",
237
avahi.SERVER_REGISTERING: None,
238
avahi.SERVER_COLLISION:
239
"Zeroconf server name collision",
240
avahi.SERVER_FAILURE:
241
"Zeroconf server failure" }
242
if state in bad_states:
243
if bad_states[state] is not None:
245
logger.error(bad_states[state])
247
logger.error(bad_states[state] + ": %r", error)
249
elif state == avahi.SERVER_RUNNING:
253
logger.debug("Unknown state: %r", state)
255
logger.debug("Unknown state: %r: %r", state, error)
257
"""Derived from the Avahi example code"""
258
if self.server is None:
259
self.server = dbus.Interface(
260
self.bus.get_object(avahi.DBUS_NAME,
261
avahi.DBUS_PATH_SERVER,
262
follow_name_owner_changes=True),
263
avahi.DBUS_INTERFACE_SERVER)
264
self.server.connect_to_signal("StateChanged",
265
self.server_state_changed)
266
self.server_state_changed(self.server.GetState())
269
def _timedelta_to_milliseconds(td):
270
"Convert a datetime.timedelta() to milliseconds"
271
return ((td.days * 24 * 60 * 60 * 1000)
272
+ (td.seconds * 1000)
273
+ (td.microseconds // 1000))
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
275
168
class Client(object):
276
169
"""A representation of a client host served by this server.
279
_approved: bool(); 'None' if not yet approved/disapproved
280
approval_delay: datetime.timedelta(); Time to wait for approval
281
approval_duration: datetime.timedelta(); Duration of one approval
282
checker: subprocess.Popen(); a running checker process used
283
to see if the client lives.
284
'None' if no process is running.
285
checker_callback_tag: a gobject event source tag, or None
286
checker_command: string; External command which is run to check
287
if client lives. %() expansions are done at
171
name: string; from the config file, used in log messages
172
fingerprint: string (40 or 32 hexadecimal digits); used to
173
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
288
190
runtime with vars(self) as dict, so that for
289
191
instance %(name)s can be used in the command.
290
checker_initiator_tag: a gobject event source tag, or None
291
created: datetime.datetime(); (UTC) object creation
292
current_checker_command: string; current running checker_command
293
disable_hook: If set, called by disable() as disable_hook(self)
294
disable_initiator_tag: a gobject event source tag, or None
296
fingerprint: string (40 or 32 hexadecimal digits); used to
297
uniquely identify the client
298
host: string; available for use by the checker command
299
interval: datetime.timedelta(); How often to start a new checker
300
last_approval_request: datetime.datetime(); (UTC) or None
301
last_checked_ok: datetime.datetime(); (UTC) or None
302
last_enabled: datetime.datetime(); (UTC)
303
name: string; from the config file, used in log messages and
305
secret: bytestring; sent verbatim (over TLS) to client
306
timeout: datetime.timedelta(); How long from last_checked_ok
307
until this client is disabled
308
extended_timeout: extra long timeout when password has been sent
309
runtime_expansions: Allowed attributes for runtime expansion.
310
expires: datetime.datetime(); time (UTC) when a client will be
193
_timeout: Real variable for 'timeout'
194
_interval: Real variable for 'interval'
195
_timeout_milliseconds: Used when calling gobject.timeout_add()
196
_interval_milliseconds: - '' -
314
runtime_expansions = ("approval_delay", "approval_duration",
315
"created", "enabled", "fingerprint",
316
"host", "interval", "last_checked_ok",
317
"last_enabled", "name", "timeout")
319
def timeout_milliseconds(self):
320
"Return the 'timeout' attribute in milliseconds"
321
return _timedelta_to_milliseconds(self.timeout)
323
def extended_timeout_milliseconds(self):
324
"Return the 'extended_timeout' attribute in milliseconds"
325
return _timedelta_to_milliseconds(self.extended_timeout)
327
def interval_milliseconds(self):
328
"Return the 'interval' attribute in milliseconds"
329
return _timedelta_to_milliseconds(self.interval)
331
def approval_delay_milliseconds(self):
332
return _timedelta_to_milliseconds(self.approval_delay)
334
def __init__(self, name = None, disable_hook=None, config=None):
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={}):
335
222
"""Note: the 'checker' key in 'config' sets the
336
223
'checker_command' attribute and *not* the 'checker'
341
logger.debug("Creating client %r", self.name)
226
logger.debug(u"Creating client %r", self.name)
342
227
# Uppercase and remove spaces from fingerprint for later
343
228
# comparison purposes with return value from the fingerprint()
345
self.fingerprint = (config["fingerprint"].upper()
347
logger.debug(" Fingerprint: %s", self.fingerprint)
230
self.fingerprint = config["fingerprint"].upper()\
232
logger.debug(u" Fingerprint: %s", self.fingerprint)
348
233
if "secret" in config:
349
self.secret = config["secret"].decode("base64")
234
self.secret = config["secret"].decode(u"base64")
350
235
elif "secfile" in config:
351
with open(os.path.expanduser(os.path.expandvars
352
(config["secfile"])),
354
self.secret = secfile.read()
236
sf = open(config["secfile"])
237
self.secret = sf.read()
356
raise TypeError("No secret or secfile for client %s"
240
raise TypeError(u"No secret or secfile for client %s"
358
242
self.host = config.get("host", "")
359
self.created = datetime.datetime.utcnow()
361
self.last_approval_request = None
362
self.last_enabled = None
243
self.created = datetime.datetime.now()
363
244
self.last_checked_ok = None
364
245
self.timeout = string_to_delta(config["timeout"])
365
self.extended_timeout = string_to_delta(config
366
["extended_timeout"])
367
246
self.interval = string_to_delta(config["interval"])
368
self.disable_hook = disable_hook
247
self.stop_hook = stop_hook
369
248
self.checker = None
370
249
self.checker_initiator_tag = None
371
self.disable_initiator_tag = None
250
self.stop_initiator_tag = None
373
251
self.checker_callback_tag = None
374
self.checker_command = config["checker"]
375
self.current_checker_command = None
376
self.last_connect = None
377
self._approved = None
378
self.approved_by_default = config.get("approved_by_default",
380
self.approvals_pending = 0
381
self.approval_delay = string_to_delta(
382
config["approval_delay"])
383
self.approval_duration = string_to_delta(
384
config["approval_duration"])
385
self.changedstate = (multiprocessing_manager
386
.Condition(multiprocessing_manager
389
def send_changedstate(self):
390
self.changedstate.acquire()
391
self.changedstate.notify_all()
392
self.changedstate.release()
252
self.check_command = config["checker"]
395
254
"""Start this client's checker and timeout hooks"""
396
if getattr(self, "enabled", False):
399
self.send_changedstate()
400
255
# Schedule a new checker to be started an 'interval' from now,
401
256
# and every interval from then on.
402
self.checker_initiator_tag = (gobject.timeout_add
403
(self.interval_milliseconds(),
405
# Schedule a disable() when 'timeout' has passed
406
self.expires = datetime.datetime.utcnow() + self.timeout
407
self.disable_initiator_tag = (gobject.timeout_add
408
(self.timeout_milliseconds(),
411
self.last_enabled = datetime.datetime.utcnow()
257
self.checker_initiator_tag = gobject.timeout_add\
258
(self._interval_milliseconds,
412
260
# Also start a new checker *right now*.
413
261
self.start_checker()
415
def disable(self, quiet=True):
416
"""Disable this client."""
417
if not getattr(self, "enabled", False):
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)
420
self.send_changedstate()
422
logger.info("Disabling client %s", self.name)
423
if getattr(self, "disable_initiator_tag", False):
424
gobject.source_remove(self.disable_initiator_tag)
425
self.disable_initiator_tag = None
276
if getattr(self, "stop_initiator_tag", False):
277
gobject.source_remove(self.stop_initiator_tag)
278
self.stop_initiator_tag = None
427
279
if getattr(self, "checker_initiator_tag", False):
428
280
gobject.source_remove(self.checker_initiator_tag)
429
281
self.checker_initiator_tag = None
430
282
self.stop_checker()
431
if self.disable_hook:
432
self.disable_hook(self)
434
285
# Do not run this again if called by a gobject.timeout_add
437
287
def __del__(self):
438
self.disable_hook = None
441
def checker_callback(self, pid, condition, command):
288
self.stop_hook = None
290
def checker_callback(self, pid, condition):
442
291
"""The checker has completed, so take appropriate actions."""
292
now = datetime.datetime.now()
443
293
self.checker_callback_tag = None
444
294
self.checker = None
445
if os.WIFEXITED(condition):
446
exitstatus = os.WEXITSTATUS(condition)
448
logger.info("Checker for %(name)s succeeded",
452
logger.info("Checker for %(name)s failed",
455
logger.warning("Checker for %(name)s crashed?",
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?",
458
def checked_ok(self, timeout=None):
459
"""Bump up the timeout for this client.
461
This should only be called when the client has been seen,
465
timeout = self.timeout
466
self.last_checked_ok = datetime.datetime.utcnow()
467
gobject.source_remove(self.disable_initiator_tag)
468
self.expires = datetime.datetime.utcnow() + timeout
469
self.disable_initiator_tag = (gobject.timeout_add
470
(_timedelta_to_milliseconds
471
(timeout), self.disable))
473
def need_approval(self):
474
self.last_approval_request = datetime.datetime.utcnow()
308
logger.info(u"Checker for %(name)s failed",
476
310
def start_checker(self):
477
311
"""Start a new checker subprocess if one is not running.
479
312
If a checker already exists, leave it running and do
481
314
# The reason for not killing a running checker is that if we
555
359
self.checker_callback_tag = None
556
360
if getattr(self, "checker", None) is None:
558
logger.debug("Stopping checker for %(name)s", vars(self))
362
logger.debug(u"Stopping checker for %(name)s", vars(self))
560
364
os.kill(self.checker.pid, signal.SIGTERM)
562
366
#if self.checker.poll() is None:
563
367
# os.kill(self.checker.pid, signal.SIGKILL)
564
except OSError as error:
368
except OSError, error:
565
369
if error.errno != errno.ESRCH: # No such process
567
371
self.checker = None
570
def dbus_service_property(dbus_interface, signature="v",
571
access="readwrite", byte_arrays=False):
572
"""Decorators for marking methods of a DBusObjectWithProperties to
573
become properties on the D-Bus.
575
The decorated method will be called with no arguments by "Get"
576
and with one argument by "Set".
578
The parameters, where they are supported, are the same as
579
dbus.service.method, except there is only "signature", since the
580
type from Get() and the type sent to Set() is the same.
582
# Encoding deeply encoded byte arrays is not supported yet by the
583
# "Set" method, so we fail early here:
584
if byte_arrays and signature != "ay":
585
raise ValueError("Byte arrays not supported for non-'ay'"
586
" signature %r" % signature)
588
func._dbus_is_property = True
589
func._dbus_interface = dbus_interface
590
func._dbus_signature = signature
591
func._dbus_access = access
592
func._dbus_name = func.__name__
593
if func._dbus_name.endswith("_dbus_property"):
594
func._dbus_name = func._dbus_name[:-14]
595
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
600
class DBusPropertyException(dbus.exceptions.DBusException):
601
"""A base class for D-Bus property-related exceptions
603
def __unicode__(self):
604
return unicode(str(self))
607
class DBusPropertyAccessException(DBusPropertyException):
608
"""A property's access permissions disallows an operation.
613
class DBusPropertyNotFound(DBusPropertyException):
614
"""An attempt was made to access a non-existing property.
619
class DBusObjectWithProperties(dbus.service.Object):
620
"""A D-Bus object with properties.
622
Classes inheriting from this can use the dbus_service_property
623
decorator to expose methods as D-Bus properties. It exposes the
624
standard Get(), Set(), and GetAll() methods on the D-Bus.
628
def _is_dbus_property(obj):
629
return getattr(obj, "_dbus_is_property", False)
631
def _get_all_dbus_properties(self):
632
"""Returns a generator of (name, attribute) pairs
634
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
635
for cls in self.__class__.__mro__
637
inspect.getmembers(cls, self._is_dbus_property))
639
def _get_dbus_property(self, interface_name, property_name):
640
"""Returns a bound method if one exists which is a D-Bus
641
property with the specified name and interface.
643
for cls in self.__class__.__mro__:
644
for name, value in (inspect.getmembers
645
(cls, self._is_dbus_property)):
646
if (value._dbus_name == property_name
647
and value._dbus_interface == interface_name):
648
return value.__get__(self)
651
raise DBusPropertyNotFound(self.dbus_object_path + ":"
652
+ interface_name + "."
655
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
657
def Get(self, interface_name, property_name):
658
"""Standard D-Bus property Get() method, see D-Bus standard.
660
prop = self._get_dbus_property(interface_name, property_name)
661
if prop._dbus_access == "write":
662
raise DBusPropertyAccessException(property_name)
664
if not hasattr(value, "variant_level"):
666
return type(value)(value, variant_level=value.variant_level+1)
668
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
669
def Set(self, interface_name, property_name, value):
670
"""Standard D-Bus property Set() method, see D-Bus standard.
672
prop = self._get_dbus_property(interface_name, property_name)
673
if prop._dbus_access == "read":
674
raise DBusPropertyAccessException(property_name)
675
if prop._dbus_get_args_options["byte_arrays"]:
676
# The byte_arrays option is not supported yet on
677
# signatures other than "ay".
678
if prop._dbus_signature != "ay":
680
value = dbus.ByteArray(''.join(unichr(byte)
684
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
685
out_signature="a{sv}")
686
def GetAll(self, interface_name):
687
"""Standard D-Bus property GetAll() method, see D-Bus
690
Note: Will not include properties with access="write".
693
for name, prop in self._get_all_dbus_properties():
695
and interface_name != prop._dbus_interface):
696
# Interface non-empty but did not match
698
# Ignore write-only properties
699
if prop._dbus_access == "write":
702
if not hasattr(value, "variant_level"):
705
all[name] = type(value)(value, variant_level=
706
value.variant_level+1)
707
return dbus.Dictionary(all, signature="sv")
709
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
711
path_keyword='object_path',
712
connection_keyword='connection')
713
def Introspect(self, object_path, connection):
714
"""Standard D-Bus method, overloaded to insert property tags.
716
xmlstring = dbus.service.Object.Introspect(self, object_path,
719
document = xml.dom.minidom.parseString(xmlstring)
720
def make_tag(document, name, prop):
721
e = document.createElement("property")
722
e.setAttribute("name", name)
723
e.setAttribute("type", prop._dbus_signature)
724
e.setAttribute("access", prop._dbus_access)
726
for if_tag in document.getElementsByTagName("interface"):
727
for tag in (make_tag(document, name, prop)
729
in self._get_all_dbus_properties()
730
if prop._dbus_interface
731
== if_tag.getAttribute("name")):
732
if_tag.appendChild(tag)
733
# Add the names to the return values for the
734
# "org.freedesktop.DBus.Properties" methods
735
if (if_tag.getAttribute("name")
736
== "org.freedesktop.DBus.Properties"):
737
for cn in if_tag.getElementsByTagName("method"):
738
if cn.getAttribute("name") == "Get":
739
for arg in cn.getElementsByTagName("arg"):
740
if (arg.getAttribute("direction")
742
arg.setAttribute("name", "value")
743
elif cn.getAttribute("name") == "GetAll":
744
for arg in cn.getElementsByTagName("arg"):
745
if (arg.getAttribute("direction")
747
arg.setAttribute("name", "props")
748
xmlstring = document.toxml("utf-8")
750
except (AttributeError, xml.dom.DOMException,
751
xml.parsers.expat.ExpatError) as error:
752
logger.error("Failed to override Introspection method",
757
def datetime_to_dbus (dt, variant_level=0):
758
"""Convert a UTC datetime.datetime() to a D-Bus type."""
760
return dbus.String("", variant_level = variant_level)
761
return dbus.String(dt.isoformat(),
762
variant_level=variant_level)
764
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
766
"""Applied to an empty subclass of a D-Bus object, this metaclass
767
will add additional D-Bus attributes matching a certain pattern.
769
def __new__(mcs, name, bases, attr):
770
# Go through all the base classes which could have D-Bus
771
# methods, signals, or properties in them
772
for base in (b for b in bases
773
if issubclass(b, dbus.service.Object)):
774
# Go though all attributes of the base class
775
for attrname, attribute in inspect.getmembers(base):
776
# Ignore non-D-Bus attributes, and D-Bus attributes
777
# with the wrong interface name
778
if (not hasattr(attribute, "_dbus_interface")
779
or not attribute._dbus_interface
780
.startswith("se.recompile.Mandos")):
782
# Create an alternate D-Bus interface name based on
784
alt_interface = (attribute._dbus_interface
785
.replace("se.recompile.Mandos",
786
"se.bsnet.fukt.Mandos"))
787
# Is this a D-Bus signal?
788
if getattr(attribute, "_dbus_is_signal", False):
789
# Extract the original non-method function by
791
nonmethod_func = (dict(
792
zip(attribute.func_code.co_freevars,
793
attribute.__closure__))["func"]
795
# Create a new, but exactly alike, function
796
# object, and decorate it to be a new D-Bus signal
797
# with the alternate D-Bus interface name
798
new_function = (dbus.service.signal
800
attribute._dbus_signature)
802
nonmethod_func.func_code,
803
nonmethod_func.func_globals,
804
nonmethod_func.func_name,
805
nonmethod_func.func_defaults,
806
nonmethod_func.func_closure)))
807
# Define a creator of a function to call both the
808
# old and new functions, so both the old and new
809
# signals gets sent when the function is called
810
def fixscope(func1, func2):
811
"""This function is a scope container to pass
812
func1 and func2 to the "call_both" function
813
outside of its arguments"""
814
def call_both(*args, **kwargs):
815
"""This function will emit two D-Bus
816
signals by calling func1 and func2"""
817
func1(*args, **kwargs)
818
func2(*args, **kwargs)
820
# Create the "call_both" function and add it to
822
attr[attrname] = fixscope(attribute,
824
# Is this a D-Bus method?
825
elif getattr(attribute, "_dbus_is_method", False):
826
# Create a new, but exactly alike, function
827
# object. Decorate it to be a new D-Bus method
828
# with the alternate D-Bus interface name. Add it
830
attr[attrname] = (dbus.service.method
832
attribute._dbus_in_signature,
833
attribute._dbus_out_signature)
835
(attribute.func_code,
836
attribute.func_globals,
838
attribute.func_defaults,
839
attribute.func_closure)))
840
# Is this a D-Bus property?
841
elif getattr(attribute, "_dbus_is_property", False):
842
# Create a new, but exactly alike, function
843
# object, and decorate it to be a new D-Bus
844
# property with the alternate D-Bus interface
845
# name. Add it to the class.
846
attr[attrname] = (dbus_service_property
848
attribute._dbus_signature,
849
attribute._dbus_access,
851
._dbus_get_args_options
854
(attribute.func_code,
855
attribute.func_globals,
857
attribute.func_defaults,
858
attribute.func_closure)))
859
return type.__new__(mcs, name, bases, attr)
861
class ClientDBus(Client, DBusObjectWithProperties):
862
"""A Client class using D-Bus
865
dbus_object_path: dbus.ObjectPath
866
bus: dbus.SystemBus()
869
runtime_expansions = (Client.runtime_expansions
870
+ ("dbus_object_path",))
872
# dbus.service.Object doesn't use super(), so we can't either.
874
def __init__(self, bus = None, *args, **kwargs):
875
self._approvals_pending = 0
877
Client.__init__(self, *args, **kwargs)
878
# Only now, when this client is initialized, can it show up on
880
client_object_name = unicode(self.name).translate(
883
self.dbus_object_path = (dbus.ObjectPath
884
("/clients/" + client_object_name))
885
DBusObjectWithProperties.__init__(self, self.bus,
886
self.dbus_object_path)
888
def notifychangeproperty(transform_func,
889
dbus_name, type_func=lambda x: x,
891
""" Modify a variable so that it's a property which announces
894
transform_fun: Function that takes a value and transforms it
896
dbus_name: D-Bus name of the variable
897
type_func: Function that transform the value before sending it
898
to the D-Bus. Default: no transform
899
variant_level: D-Bus variant level. Default: 1
902
def setter(self, value):
903
old_value = real_value[0]
904
real_value[0] = value
905
if hasattr(self, "dbus_object_path"):
906
if type_func(old_value) != type_func(real_value[0]):
907
dbus_value = transform_func(type_func
910
self.PropertyChanged(dbus.String(dbus_name),
913
return property(lambda self: real_value[0], setter)
916
expires = notifychangeproperty(datetime_to_dbus, "Expires")
917
approvals_pending = notifychangeproperty(dbus.Boolean,
920
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
921
last_enabled = notifychangeproperty(datetime_to_dbus,
923
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
924
type_func = lambda checker:
926
last_checked_ok = notifychangeproperty(datetime_to_dbus,
928
last_approval_request = notifychangeproperty(
929
datetime_to_dbus, "LastApprovalRequest")
930
approved_by_default = notifychangeproperty(dbus.Boolean,
932
approval_delay = notifychangeproperty(dbus.UInt16,
935
_timedelta_to_milliseconds)
936
approval_duration = notifychangeproperty(
937
dbus.UInt16, "ApprovalDuration",
938
type_func = _timedelta_to_milliseconds)
939
host = notifychangeproperty(dbus.String, "Host")
940
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
942
_timedelta_to_milliseconds)
943
extended_timeout = notifychangeproperty(
944
dbus.UInt16, "ExtendedTimeout",
945
type_func = _timedelta_to_milliseconds)
946
interval = notifychangeproperty(dbus.UInt16,
949
_timedelta_to_milliseconds)
950
checker_command = notifychangeproperty(dbus.String, "Checker")
952
del notifychangeproperty
954
def __del__(self, *args, **kwargs):
956
self.remove_from_connection()
959
if hasattr(DBusObjectWithProperties, "__del__"):
960
DBusObjectWithProperties.__del__(self, *args, **kwargs)
961
Client.__del__(self, *args, **kwargs)
963
def checker_callback(self, pid, condition, command,
965
self.checker_callback_tag = None
967
if os.WIFEXITED(condition):
968
exitstatus = os.WEXITSTATUS(condition)
970
self.CheckerCompleted(dbus.Int16(exitstatus),
971
dbus.Int64(condition),
972
dbus.String(command))
975
self.CheckerCompleted(dbus.Int16(-1),
976
dbus.Int64(condition),
977
dbus.String(command))
979
return Client.checker_callback(self, pid, condition, command,
982
def start_checker(self, *args, **kwargs):
983
old_checker = self.checker
984
if self.checker is not None:
985
old_checker_pid = self.checker.pid
987
old_checker_pid = None
988
r = Client.start_checker(self, *args, **kwargs)
989
# Only if new checker process was started
990
if (self.checker is not None
991
and old_checker_pid != self.checker.pid):
993
self.CheckerStarted(self.current_checker_command)
996
def _reset_approved(self):
997
self._approved = None
1000
def approve(self, value=True):
1001
self.send_changedstate()
1002
self._approved = value
1003
gobject.timeout_add(_timedelta_to_milliseconds
1004
(self.approval_duration),
1005
self._reset_approved)
1008
## D-Bus methods, signals & properties
1009
_interface = "se.recompile.Mandos.Client"
1013
# CheckerCompleted - signal
1014
@dbus.service.signal(_interface, signature="nxs")
1015
def CheckerCompleted(self, exitcode, waitstatus, command):
1019
# CheckerStarted - signal
1020
@dbus.service.signal(_interface, signature="s")
1021
def CheckerStarted(self, command):
1025
# PropertyChanged - signal
1026
@dbus.service.signal(_interface, signature="sv")
1027
def PropertyChanged(self, property, value):
1031
# GotSecret - signal
1032
@dbus.service.signal(_interface)
1033
def GotSecret(self):
1035
Is sent after a successful transfer of secret from the Mandos
1036
server to mandos-client
1041
@dbus.service.signal(_interface, signature="s")
1042
def Rejected(self, reason):
1046
# NeedApproval - signal
1047
@dbus.service.signal(_interface, signature="tb")
1048
def NeedApproval(self, timeout, default):
1050
return self.need_approval()
1055
@dbus.service.method(_interface, in_signature="b")
1056
def Approve(self, value):
1059
# CheckedOK - method
1060
@dbus.service.method(_interface)
1061
def CheckedOK(self):
1065
@dbus.service.method(_interface)
1070
# StartChecker - method
1071
@dbus.service.method(_interface)
1072
def StartChecker(self):
1074
self.start_checker()
1077
@dbus.service.method(_interface)
1082
# StopChecker - method
1083
@dbus.service.method(_interface)
1084
def StopChecker(self):
1089
# ApprovalPending - property
1090
@dbus_service_property(_interface, signature="b", access="read")
1091
def ApprovalPending_dbus_property(self):
1092
return dbus.Boolean(bool(self.approvals_pending))
1094
# ApprovedByDefault - property
1095
@dbus_service_property(_interface, signature="b",
1097
def ApprovedByDefault_dbus_property(self, value=None):
1098
if value is None: # get
1099
return dbus.Boolean(self.approved_by_default)
1100
self.approved_by_default = bool(value)
1102
# ApprovalDelay - property
1103
@dbus_service_property(_interface, signature="t",
1105
def ApprovalDelay_dbus_property(self, value=None):
1106
if value is None: # get
1107
return dbus.UInt64(self.approval_delay_milliseconds())
1108
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1110
# ApprovalDuration - property
1111
@dbus_service_property(_interface, signature="t",
1113
def ApprovalDuration_dbus_property(self, value=None):
1114
if value is None: # get
1115
return dbus.UInt64(_timedelta_to_milliseconds(
1116
self.approval_duration))
1117
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1120
@dbus_service_property(_interface, signature="s", access="read")
1121
def Name_dbus_property(self):
1122
return dbus.String(self.name)
1124
# Fingerprint - property
1125
@dbus_service_property(_interface, signature="s", access="read")
1126
def Fingerprint_dbus_property(self):
1127
return dbus.String(self.fingerprint)
1130
@dbus_service_property(_interface, signature="s",
1132
def Host_dbus_property(self, value=None):
1133
if value is None: # get
1134
return dbus.String(self.host)
1137
# Created - property
1138
@dbus_service_property(_interface, signature="s", access="read")
1139
def Created_dbus_property(self):
1140
return dbus.String(datetime_to_dbus(self.created))
1142
# LastEnabled - property
1143
@dbus_service_property(_interface, signature="s", access="read")
1144
def LastEnabled_dbus_property(self):
1145
return datetime_to_dbus(self.last_enabled)
1147
# Enabled - property
1148
@dbus_service_property(_interface, signature="b",
1150
def Enabled_dbus_property(self, value=None):
1151
if value is None: # get
1152
return dbus.Boolean(self.enabled)
1158
# LastCheckedOK - property
1159
@dbus_service_property(_interface, signature="s",
1161
def LastCheckedOK_dbus_property(self, value=None):
1162
if value is not None:
1165
return datetime_to_dbus(self.last_checked_ok)
1167
# Expires - property
1168
@dbus_service_property(_interface, signature="s", access="read")
1169
def Expires_dbus_property(self):
1170
return datetime_to_dbus(self.expires)
1172
# LastApprovalRequest - property
1173
@dbus_service_property(_interface, signature="s", access="read")
1174
def LastApprovalRequest_dbus_property(self):
1175
return datetime_to_dbus(self.last_approval_request)
1177
# Timeout - property
1178
@dbus_service_property(_interface, signature="t",
1180
def Timeout_dbus_property(self, value=None):
1181
if value is None: # get
1182
return dbus.UInt64(self.timeout_milliseconds())
1183
self.timeout = datetime.timedelta(0, 0, 0, value)
1184
if getattr(self, "disable_initiator_tag", None) is None:
1186
# Reschedule timeout
1187
gobject.source_remove(self.disable_initiator_tag)
1188
self.disable_initiator_tag = None
1190
time_to_die = (self.
1191
_timedelta_to_milliseconds((self
1196
if time_to_die <= 0:
1197
# The timeout has passed
1200
self.expires = (datetime.datetime.utcnow()
1201
+ datetime.timedelta(milliseconds =
1203
self.disable_initiator_tag = (gobject.timeout_add
1204
(time_to_die, self.disable))
1206
# ExtendedTimeout - property
1207
@dbus_service_property(_interface, signature="t",
1209
def ExtendedTimeout_dbus_property(self, value=None):
1210
if value is None: # get
1211
return dbus.UInt64(self.extended_timeout_milliseconds())
1212
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1214
# Interval - property
1215
@dbus_service_property(_interface, signature="t",
1217
def Interval_dbus_property(self, value=None):
1218
if value is None: # get
1219
return dbus.UInt64(self.interval_milliseconds())
1220
self.interval = datetime.timedelta(0, 0, 0, value)
1221
if getattr(self, "checker_initiator_tag", None) is None:
1223
# Reschedule checker run
1224
gobject.source_remove(self.checker_initiator_tag)
1225
self.checker_initiator_tag = (gobject.timeout_add
1226
(value, self.start_checker))
1227
self.start_checker() # Start one now, too
1229
# Checker - property
1230
@dbus_service_property(_interface, signature="s",
1232
def Checker_dbus_property(self, value=None):
1233
if value is None: # get
1234
return dbus.String(self.checker_command)
1235
self.checker_command = value
1237
# CheckerRunning - property
1238
@dbus_service_property(_interface, signature="b",
1240
def CheckerRunning_dbus_property(self, value=None):
1241
if value is None: # get
1242
return dbus.Boolean(self.checker is not None)
1244
self.start_checker()
1248
# ObjectPath - property
1249
@dbus_service_property(_interface, signature="o", access="read")
1250
def ObjectPath_dbus_property(self):
1251
return self.dbus_object_path # is already a dbus.ObjectPath
1254
@dbus_service_property(_interface, signature="ay",
1255
access="write", byte_arrays=True)
1256
def Secret_dbus_property(self, value):
1257
self.secret = str(value)
1262
class ProxyClient(object):
1263
def __init__(self, child_pipe, fpr, address):
1264
self._pipe = child_pipe
1265
self._pipe.send(('init', fpr, address))
1266
if not self._pipe.recv():
1269
def __getattribute__(self, name):
1270
if(name == '_pipe'):
1271
return super(ProxyClient, self).__getattribute__(name)
1272
self._pipe.send(('getattr', name))
1273
data = self._pipe.recv()
1274
if data[0] == 'data':
1276
if data[0] == 'function':
1277
def func(*args, **kwargs):
1278
self._pipe.send(('funcall', name, args, kwargs))
1279
return self._pipe.recv()[1]
1282
def __setattr__(self, name, value):
1283
if(name == '_pipe'):
1284
return super(ProxyClient, self).__setattr__(name, value)
1285
self._pipe.send(('setattr', name, value))
1287
class ClientDBusTransitional(ClientDBus):
1288
__metaclass__ = AlternateDBusNamesMetaclass
1290
class ClientHandler(socketserver.BaseRequestHandler, object):
1291
"""A class to handle client connections.
1293
Instantiated once for each connection to handle it.
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.
1294
438
Note: This will run in its own forked process."""
1296
440
def handle(self):
1297
with contextlib.closing(self.server.child_pipe) as child_pipe:
1298
logger.info("TCP connection from: %s",
1299
unicode(self.client_address))
1300
logger.debug("Pipe FD: %d",
1301
self.server.child_pipe.fileno())
1303
session = (gnutls.connection
1304
.ClientSession(self.request,
1306
.X509Credentials()))
1308
# Note: gnutls.connection.X509Credentials is really a
1309
# generic GnuTLS certificate credentials object so long as
1310
# no X.509 keys are added to it. Therefore, we can use it
1311
# here despite using OpenPGP certificates.
1313
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1314
# "+AES-256-CBC", "+SHA1",
1315
# "+COMP-NULL", "+CTYPE-OPENPGP",
1317
# Use a fallback default, since this MUST be set.
1318
priority = self.server.gnutls_priority
1319
if priority is None:
1321
(gnutls.library.functions
1322
.gnutls_priority_set_direct(session._c_object,
1325
# Start communication using the Mandos protocol
1326
# Get protocol number
1327
line = self.request.makefile().readline()
1328
logger.debug("Protocol version: %r", line)
1330
if int(line.strip().split()[0]) > 1:
1332
except (ValueError, IndexError, RuntimeError) as error:
1333
logger.error("Unknown protocol version: %s", error)
1336
# Start GnuTLS connection
1339
except gnutls.errors.GNUTLSError as error:
1340
logger.warning("Handshake failed: %s", error)
1341
# Do not run session.bye() here: the session is not
1342
# established. Just abandon the request.
1344
logger.debug("Handshake succeeded")
1346
approval_required = False
1349
fpr = self.fingerprint(self.peer_certificate
1352
gnutls.errors.GNUTLSError) as error:
1353
logger.warning("Bad certificate: %s", error)
1355
logger.debug("Fingerprint: %s", fpr)
1358
client = ProxyClient(child_pipe, fpr,
1359
self.client_address)
1363
if client.approval_delay:
1364
delay = client.approval_delay
1365
client.approvals_pending += 1
1366
approval_required = True
1369
if not client.enabled:
1370
logger.info("Client %s is disabled",
1372
if self.server.use_dbus:
1374
client.Rejected("Disabled")
1377
if client._approved or not client.approval_delay:
1378
#We are approved or approval is disabled
1380
elif client._approved is None:
1381
logger.info("Client %s needs approval",
1383
if self.server.use_dbus:
1385
client.NeedApproval(
1386
client.approval_delay_milliseconds(),
1387
client.approved_by_default)
1389
logger.warning("Client %s was not approved",
1391
if self.server.use_dbus:
1393
client.Rejected("Denied")
1396
#wait until timeout or approved
1398
# ._timedelta_to_milliseconds(delay))
1399
time = datetime.datetime.now()
1400
client.changedstate.acquire()
1401
(client.changedstate.wait
1402
(float(client._timedelta_to_milliseconds(delay)
1404
client.changedstate.release()
1405
time2 = datetime.datetime.now()
1406
if (time2 - time) >= delay:
1407
if not client.approved_by_default:
1408
logger.warning("Client %s timed out while"
1409
" waiting for approval",
1411
if self.server.use_dbus:
1413
client.Rejected("Approval timed out")
1418
delay -= time2 - time
1421
while sent_size < len(client.secret):
1423
sent = session.send(client.secret[sent_size:])
1424
except gnutls.errors.GNUTLSError as error:
1425
logger.warning("gnutls send failed")
1427
logger.debug("Sent: %d, remaining: %d",
1428
sent, len(client.secret)
1429
- (sent_size + sent))
1432
logger.info("Sending secret to %s", client.name)
1433
# bump the timeout as if seen
1434
client.checked_ok(client.extended_timeout)
1435
if self.server.use_dbus:
1440
if approval_required:
1441
client.approvals_pending -= 1
1444
except gnutls.errors.GNUTLSError as error:
1445
logger.warning("GnuTLS bye failed")
1448
def peer_certificate(session):
1449
"Return the peer's OpenPGP certificate as a bytestring"
1450
# If not an OpenPGP certificate...
1451
if (gnutls.library.functions
1452
.gnutls_certificate_type_get(session._c_object)
1453
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1454
# ...do the normal thing
1455
return session.peer_certificate
1456
list_size = ctypes.c_uint(1)
1457
cert_list = (gnutls.library.functions
1458
.gnutls_certificate_get_peers
1459
(session._c_object, ctypes.byref(list_size)))
1460
if not bool(cert_list) and list_size.value != 0:
1461
raise gnutls.errors.GNUTLSError("error getting peer"
1463
if list_size.value == 0:
1466
return ctypes.string_at(cert.data, cert.size)
1469
def fingerprint(openpgp):
1470
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1471
# New GnuTLS "datum" with the OpenPGP public key
1472
datum = (gnutls.library.types
1473
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1476
ctypes.c_uint(len(openpgp))))
1477
# New empty GnuTLS certificate
1478
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1479
(gnutls.library.functions
1480
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1481
# Import the OpenPGP public key into the certificate
1482
(gnutls.library.functions
1483
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1484
gnutls.library.constants
1485
.GNUTLS_OPENPGP_FMT_RAW))
1486
# Verify the self signature in the key
1487
crtverify = ctypes.c_uint()
1488
(gnutls.library.functions
1489
.gnutls_openpgp_crt_verify_self(crt, 0,
1490
ctypes.byref(crtverify)))
1491
if crtverify.value != 0:
1492
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1493
raise (gnutls.errors.CertificateSecurityError
1495
# New buffer for the fingerprint
1496
buf = ctypes.create_string_buffer(20)
1497
buf_len = ctypes.c_size_t()
1498
# Get the fingerprint from the certificate into the buffer
1499
(gnutls.library.functions
1500
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1501
ctypes.byref(buf_len)))
1502
# Deinit the certificate
1503
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1504
# Convert the buffer to a Python bytestring
1505
fpr = ctypes.string_at(buf, buf_len.value)
1506
# Convert the bytestring to hexadecimal notation
1507
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
1511
class MultiprocessingMixIn(object):
1512
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1513
def sub_process_main(self, request, address):
1515
self.finish_request(request, address)
1517
self.handle_error(request, address)
1518
self.close_request(request)
1520
def process_request(self, request, address):
1521
"""Start a new process to process the request."""
1522
multiprocessing.Process(target = self.sub_process_main,
1523
args = (request, address)).start()
1526
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1527
""" adds a pipe to the MixIn """
1528
def process_request(self, request, client_address):
1529
"""Overrides and wraps the original process_request().
1531
This function creates a new pipe in self.pipe
1533
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1535
super(MultiprocessingMixInWithPipe,
1536
self).process_request(request, client_address)
1537
self.child_pipe.close()
1538
self.add_pipe(parent_pipe)
1540
def add_pipe(self, parent_pipe):
1541
"""Dummy function; override as necessary"""
1542
raise NotImplementedError
1545
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1546
socketserver.TCPServer, object):
1547
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
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.
1550
enabled: Boolean; whether this server is activated yet
1551
interface: None or a network interface name (string)
1552
use_ipv6: Boolean; to use IPv6 or not
515
settings: Server settings
516
clients: Set() of Client objects
1554
def __init__(self, server_address, RequestHandlerClass,
1555
interface=None, use_ipv6=True):
1556
self.interface = interface
1558
self.address_family = socket.AF_INET6
1559
socketserver.TCPServer.__init__(self, server_address,
1560
RequestHandlerClass)
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)
1561
527
def server_bind(self):
1562
528
"""This overrides the normal server_bind() function
1563
529
to bind to an interface if one was specified, and also NOT to
1564
530
bind to an address or port if they were not specified."""
1565
if self.interface is not None:
1566
if SO_BINDTODEVICE is None:
1567
logger.error("SO_BINDTODEVICE does not exist;"
1568
" cannot bind to interface %s",
1572
self.socket.setsockopt(socket.SOL_SOCKET,
1576
except socket.error as error:
1577
if error[0] == errno.EPERM:
1578
logger.error("No permission to"
1579
" bind to interface %s",
1581
elif error[0] == errno.ENOPROTOOPT:
1582
logger.error("SO_BINDTODEVICE not available;"
1583
" cannot bind to interface %s",
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"])
1587
545
# Only bind(2) the socket if we really need to.
1588
546
if self.server_address[0] or self.server_address[1]:
1589
547
if not self.server_address[0]:
1590
if self.address_family == socket.AF_INET6:
1591
any_address = "::" # in6addr_any
1593
any_address = socket.INADDR_ANY
1594
self.server_address = (any_address,
549
self.server_address = (in6addr_any,
1595
550
self.server_address[1])
1596
551
elif not self.server_address[1]:
1597
552
self.server_address = (self.server_address[0],
1599
# if self.interface:
554
# if self.settings["interface"]:
1600
555
# self.server_address = (self.server_address[0],
1603
558
# if_nametoindex
1605
return socketserver.TCPServer.server_bind(self)
1608
class MandosServer(IPv6_TCPServer):
1612
clients: set of Client objects
1613
gnutls_priority GnuTLS priority string
1614
use_dbus: Boolean; to emit D-Bus signals or not
1616
Assumes a gobject.MainLoop event loop.
1618
def __init__(self, server_address, RequestHandlerClass,
1619
interface=None, use_ipv6=True, clients=None,
1620
gnutls_priority=None, use_dbus=True):
1621
self.enabled = False
1622
self.clients = clients
1623
if self.clients is None:
1624
self.clients = set()
1625
self.use_dbus = use_dbus
1626
self.gnutls_priority = gnutls_priority
1627
IPv6_TCPServer.__init__(self, server_address,
1628
RequestHandlerClass,
1629
interface = interface,
1630
use_ipv6 = use_ipv6)
1631
def server_activate(self):
1633
return socketserver.TCPServer.server_activate(self)
1636
def add_pipe(self, parent_pipe):
1637
# Call "handle_ipc" for both data and EOF events
1638
gobject.io_add_watch(parent_pipe.fileno(),
1639
gobject.IO_IN | gobject.IO_HUP,
1640
functools.partial(self.handle_ipc,
1644
def handle_ipc(self, source, condition, parent_pipe=None,
1645
client_object=None):
1647
gobject.IO_IN: "IN", # There is data to read.
1648
gobject.IO_OUT: "OUT", # Data can be written (without
1650
gobject.IO_PRI: "PRI", # There is urgent data to read.
1651
gobject.IO_ERR: "ERR", # Error condition.
1652
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1653
# broken, usually for pipes and
1656
conditions_string = ' | '.join(name
1658
condition_names.iteritems()
1659
if cond & condition)
1660
# error or the other end of multiprocessing.Pipe has closed
1661
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1664
# Read a request from the child
1665
request = parent_pipe.recv()
1666
command = request[0]
1668
if command == 'init':
1670
address = request[2]
1672
for c in self.clients:
1673
if c.fingerprint == fpr:
1677
logger.info("Client not found for fingerprint: %s, ad"
1678
"dress: %s", fpr, address)
1681
mandos_dbus_service.ClientNotFound(fpr,
1683
parent_pipe.send(False)
1686
gobject.io_add_watch(parent_pipe.fileno(),
1687
gobject.IO_IN | gobject.IO_HUP,
1688
functools.partial(self.handle_ipc,
1693
parent_pipe.send(True)
1694
# remove the old hook in favor of the new above hook on
1697
if command == 'funcall':
1698
funcname = request[1]
1702
parent_pipe.send(('data', getattr(client_object,
1706
if command == 'getattr':
1707
attrname = request[1]
1708
if callable(client_object.__getattribute__(attrname)):
1709
parent_pipe.send(('function',))
1711
parent_pipe.send(('data', client_object
1712
.__getattribute__(attrname)))
1714
if command == 'setattr':
1715
attrname = request[1]
1717
setattr(client_object, attrname, value)
561
return super(type(self), self).server_bind()
1722
564
def string_to_delta(interval):
1723
565
"""Parse a string and return a datetime.timedelta
1725
567
>>> string_to_delta('7d')
1726
568
datetime.timedelta(7)
1727
569
>>> string_to_delta('60s')