99
131
max_renames: integer; maximum number of renames
100
132
rename_count: integer; counter so we only rename after collisions
101
133
a sensible number of times
134
group: D-Bus Entry Group
136
bus: dbus.SystemBus()
103
138
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
104
type = None, port = None, TXT = None, domain = "",
105
host = "", max_renames = 32768):
139
servicetype = None, port = None, TXT = None,
140
domain = "", host = "", max_renames = 32768,
141
protocol = avahi.PROTO_UNSPEC, bus = None):
106
142
self.interface = interface
144
self.type = servicetype
146
self.TXT = TXT if TXT is not None else []
114
147
self.domain = domain
116
149
self.rename_count = 0
150
self.max_renames = max_renames
151
self.protocol = protocol
152
self.group = None # our entry group
155
self.entry_group_state_changed_match = None
117
156
def rename(self):
118
157
"""Derived from the Avahi example code"""
119
158
if self.rename_count >= self.max_renames:
120
logger.critical(u"No suitable service name found after %i"
121
u" retries, exiting.", rename_count)
159
logger.critical("No suitable Zeroconf service name found"
160
" after %i retries, exiting.",
122
162
raise AvahiServiceError("Too many renames")
123
name = server.GetAlternativeServiceName(name)
124
logger.error(u"Changing name to %r ...", name)
125
syslogger.setFormatter(logging.Formatter\
126
('Mandos (%s): %%(levelname)s:'
127
' %%(message)s' % name))
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'
174
except dbus.exceptions.DBusException as error:
175
logger.critical("DBusException: %s", error)
130
178
self.rename_count += 1
131
179
def remove(self):
132
180
"""Derived from the Avahi example code"""
133
if group is not None:
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:
136
187
"""Derived from the Avahi example code"""
139
group = dbus.Interface\
140
(bus.get_object(avahi.DBUS_NAME,
141
server.EntryGroupNew()),
142
avahi.DBUS_INTERFACE_ENTRY_GROUP)
143
group.connect_to_signal('StateChanged',
144
entry_group_state_changed)
145
logger.debug(u"Adding service '%s' of type '%s' ...",
146
service.name, service.type)
148
self.interface, # interface
149
avahi.PROTO_INET6, # protocol
150
dbus.UInt32(0), # flags
151
self.name, self.type,
152
self.domain, self.host,
153
dbus.UInt16(self.port),
154
avahi.string_array_to_txt_array(self.TXT))
157
# From the Avahi example code:
158
group = None # our entry group
159
# End of 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))
162
275
class Client(object):
163
276
"""A representation of a client host served by this server.
165
name: string; from the config file, used in log messages
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
288
runtime with vars(self) as dict, so that for
289
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
166
296
fingerprint: string (40 or 32 hexadecimal digits); used to
167
297
uniquely identify the client
168
secret: bytestring; sent verbatim (over TLS) to client
169
host: string; available for use by the checker command
170
created: datetime.datetime(); object creation, not client host
171
last_checked_ok: datetime.datetime() or None if not yet checked OK
172
timeout: datetime.timedelta(); How long from last_checked_ok
173
until this client is invalid
174
interval: datetime.timedelta(); How often to start a new checker
175
stop_hook: If set, called by stop() as stop_hook(self)
176
checker: subprocess.Popen(); a running checker process used
177
to see if the client lives.
178
'None' if no process is running.
179
checker_initiator_tag: a gobject event source tag, or None
180
stop_initiator_tag: - '' -
181
checker_callback_tag: - '' -
182
checker_command: string; External command which is run to check if
183
client lives. %() expansions are done at
184
runtime with vars(self) as dict, so that for
185
instance %(name)s can be used in the command.
187
_timeout: Real variable for 'timeout'
188
_interval: Real variable for 'interval'
189
_timeout_milliseconds: Used when calling gobject.timeout_add()
190
_interval_milliseconds: - '' -
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
192
def _set_timeout(self, timeout):
193
"Setter function for 'timeout' attribute"
194
self._timeout = timeout
195
self._timeout_milliseconds = ((self.timeout.days
196
* 24 * 60 * 60 * 1000)
197
+ (self.timeout.seconds * 1000)
198
+ (self.timeout.microseconds
200
timeout = property(lambda self: self._timeout,
203
def _set_interval(self, interval):
204
"Setter function for 'interval' attribute"
205
self._interval = interval
206
self._interval_milliseconds = ((self.interval.days
207
* 24 * 60 * 60 * 1000)
208
+ (self.interval.seconds
210
+ (self.interval.microseconds
212
interval = property(lambda self: self._interval,
215
def __init__(self, name = None, stop_hook=None, config={}):
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):
216
335
"""Note: the 'checker' key in 'config' sets the
217
336
'checker_command' attribute and *not* the 'checker'
220
logger.debug(u"Creating client %r", self.name)
341
logger.debug("Creating client %r", self.name)
221
342
# Uppercase and remove spaces from fingerprint for later
222
343
# comparison purposes with return value from the fingerprint()
224
self.fingerprint = config["fingerprint"].upper()\
226
logger.debug(u" Fingerprint: %s", self.fingerprint)
345
self.fingerprint = (config["fingerprint"].upper()
347
logger.debug(" Fingerprint: %s", self.fingerprint)
227
348
if "secret" in config:
228
self.secret = config["secret"].decode(u"base64")
349
self.secret = config["secret"].decode("base64")
229
350
elif "secfile" in config:
230
sf = open(config["secfile"])
231
self.secret = sf.read()
351
with open(os.path.expanduser(os.path.expandvars
352
(config["secfile"])),
354
self.secret = secfile.read()
234
raise TypeError(u"No secret or secfile for client %s"
356
raise TypeError("No secret or secfile for client %s"
236
358
self.host = config.get("host", "")
237
self.created = datetime.datetime.now()
359
self.created = datetime.datetime.utcnow()
361
self.last_approval_request = None
362
self.last_enabled = None
238
363
self.last_checked_ok = None
239
364
self.timeout = string_to_delta(config["timeout"])
365
self.extended_timeout = string_to_delta(config
366
["extended_timeout"])
240
367
self.interval = string_to_delta(config["interval"])
241
self.stop_hook = stop_hook
368
self.disable_hook = disable_hook
242
369
self.checker = None
243
370
self.checker_initiator_tag = None
244
self.stop_initiator_tag = None
371
self.disable_initiator_tag = None
245
373
self.checker_callback_tag = None
246
self.check_command = config["checker"]
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()
248
395
"""Start this client's checker and timeout hooks"""
396
if getattr(self, "enabled", False):
399
self.send_changedstate()
249
400
# Schedule a new checker to be started an 'interval' from now,
250
401
# and every interval from then on.
251
self.checker_initiator_tag = gobject.timeout_add\
252
(self._interval_milliseconds,
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()
254
412
# Also start a new checker *right now*.
255
413
self.start_checker()
256
# Schedule a stop() when 'timeout' has passed
257
self.stop_initiator_tag = gobject.timeout_add\
258
(self._timeout_milliseconds,
262
The possibility that a client might be restarted is left open,
263
but not currently used."""
264
# If this client doesn't have a secret, it is already stopped.
265
if hasattr(self, "secret") and self.secret:
266
logger.info(u"Stopping client %s", self.name)
415
def disable(self, quiet=True):
416
"""Disable this client."""
417
if not getattr(self, "enabled", False):
270
if getattr(self, "stop_initiator_tag", False):
271
gobject.source_remove(self.stop_initiator_tag)
272
self.stop_initiator_tag = None
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
273
427
if getattr(self, "checker_initiator_tag", False):
274
428
gobject.source_remove(self.checker_initiator_tag)
275
429
self.checker_initiator_tag = None
276
430
self.stop_checker()
431
if self.disable_hook:
432
self.disable_hook(self)
279
434
# Do not run this again if called by a gobject.timeout_add
281
437
def __del__(self):
282
self.stop_hook = None
284
def checker_callback(self, pid, condition):
438
self.disable_hook = None
441
def checker_callback(self, pid, condition, command):
285
442
"""The checker has completed, so take appropriate actions."""
286
now = datetime.datetime.now()
287
443
self.checker_callback_tag = None
288
444
self.checker = None
289
if os.WIFEXITED(condition) \
290
and (os.WEXITSTATUS(condition) == 0):
291
logger.info(u"Checker for %(name)s succeeded",
293
self.last_checked_ok = now
294
gobject.source_remove(self.stop_initiator_tag)
295
self.stop_initiator_tag = gobject.timeout_add\
296
(self._timeout_milliseconds,
298
elif not os.WIFEXITED(condition):
299
logger.warning(u"Checker for %(name)s crashed?",
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?",
302
logger.info(u"Checker for %(name)s failed",
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.disable_initiator_tag = (gobject.timeout_add
469
(_timedelta_to_milliseconds
470
(timeout), self.disable))
471
self.expires = datetime.datetime.utcnow() + timeout
473
def need_approval(self):
474
self.last_approval_request = datetime.datetime.utcnow()
304
476
def start_checker(self):
305
477
"""Start a new checker subprocess if one is not running.
306
479
If a checker already exists, leave it running and do
308
481
# The reason for not killing a running checker is that if we
349
555
self.checker_callback_tag = None
350
556
if getattr(self, "checker", None) is None:
352
logger.debug(u"Stopping checker for %(name)s", vars(self))
558
logger.debug("Stopping checker for %(name)s", vars(self))
354
560
os.kill(self.checker.pid, signal.SIGTERM)
356
562
#if self.checker.poll() is None:
357
563
# os.kill(self.checker.pid, signal.SIGKILL)
358
except OSError, error:
564
except OSError as error:
359
565
if error.errno != errno.ESRCH: # No such process
361
567
self.checker = None
362
def still_valid(self):
363
"""Has the timeout not yet passed for this client?"""
364
now = datetime.datetime.now()
365
if self.last_checked_ok is None:
366
return now < (self.created + self.timeout)
368
return now < (self.last_checked_ok + self.timeout)
371
def peer_certificate(session):
372
"Return the peer's OpenPGP certificate as a bytestring"
373
# If not an OpenPGP certificate...
374
if gnutls.library.functions.gnutls_certificate_type_get\
375
(session._c_object) \
376
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
377
# ...do the normal thing
378
return session.peer_certificate
379
list_size = ctypes.c_uint()
380
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
381
(session._c_object, ctypes.byref(list_size))
382
if list_size.value == 0:
385
return ctypes.string_at(cert.data, cert.size)
388
def fingerprint(openpgp):
389
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
390
# New GnuTLS "datum" with the OpenPGP public key
391
datum = gnutls.library.types.gnutls_datum_t\
392
(ctypes.cast(ctypes.c_char_p(openpgp),
393
ctypes.POINTER(ctypes.c_ubyte)),
394
ctypes.c_uint(len(openpgp)))
395
# New empty GnuTLS certificate
396
crt = gnutls.library.types.gnutls_openpgp_crt_t()
397
gnutls.library.functions.gnutls_openpgp_crt_init\
399
# Import the OpenPGP public key into the certificate
400
gnutls.library.functions.gnutls_openpgp_crt_import\
401
(crt, ctypes.byref(datum),
402
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
403
# New buffer for the fingerprint
404
buffer = ctypes.create_string_buffer(20)
405
buffer_length = ctypes.c_size_t()
406
# Get the fingerprint from the certificate into the buffer
407
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
408
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
409
# Deinit the certificate
410
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
411
# Convert the buffer to a Python bytestring
412
fpr = ctypes.string_at(buffer, buffer_length.value)
413
# Convert the bytestring to hexadecimal notation
414
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
418
class tcp_handler(SocketServer.BaseRequestHandler, object):
419
"""A TCP request handler class.
420
Instantiated by IPv6_TCPServer for each request to handle it.
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
901
attrname = "_{0}".format(dbus_name)
902
def setter(self, value):
903
if hasattr(self, "dbus_object_path"):
904
if (not hasattr(self, attrname) or
905
type_func(getattr(self, attrname, None))
906
!= type_func(value)):
907
dbus_value = transform_func(type_func(value),
909
self.PropertyChanged(dbus.String(dbus_name),
911
setattr(self, attrname, value)
913
return property(lambda self: getattr(self, attrname), 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.
421
1294
Note: This will run in its own forked process."""
423
1296
def handle(self):
424
logger.info(u"TCP connection from: %s",
425
unicode(self.client_address))
426
session = gnutls.connection.ClientSession\
427
(self.request, gnutls.connection.X509Credentials())
429
line = self.request.makefile().readline()
430
logger.debug(u"Protocol version: %r", line)
432
if int(line.strip().split()[0]) > 1:
434
except (ValueError, IndexError, RuntimeError), error:
435
logger.error(u"Unknown protocol version: %s", error)
438
# Note: gnutls.connection.X509Credentials is really a generic
439
# GnuTLS certificate credentials object so long as no X.509
440
# keys are added to it. Therefore, we can use it here despite
441
# using OpenPGP certificates.
443
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
444
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
446
priority = "NORMAL" # Fallback default, since this
448
if self.server.settings["priority"]:
449
priority = self.server.settings["priority"]
450
gnutls.library.functions.gnutls_priority_set_direct\
451
(session._c_object, priority, None);
455
except gnutls.errors.GNUTLSError, error:
456
logger.warning(u"Handshake failed: %s", error)
457
# Do not run session.bye() here: the session is not
458
# established. Just abandon the request.
461
fpr = fingerprint(peer_certificate(session))
462
except (TypeError, gnutls.errors.GNUTLSError), error:
463
logger.warning(u"Bad certificate: %s", error)
466
logger.debug(u"Fingerprint: %s", fpr)
468
for c in self.server.clients:
469
if c.fingerprint == fpr:
473
logger.warning(u"Client not found for fingerprint: %s",
477
# Have to check if client.still_valid(), since it is possible
478
# that the client timed out while establishing the GnuTLS
480
if not client.still_valid():
481
logger.warning(u"Client %(name)s is invalid",
486
while sent_size < len(client.secret):
487
sent = session.send(client.secret[sent_size:])
488
logger.debug(u"Sent: %d, remaining: %d",
489
sent, len(client.secret)
490
- (sent_size + sent))
495
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
496
"""IPv6 TCP server. Accepts 'None' as address and/or port.
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
1397
time = datetime.datetime.now()
1398
client.changedstate.acquire()
1399
(client.changedstate.wait
1400
(float(client._timedelta_to_milliseconds(delay)
1402
client.changedstate.release()
1403
time2 = datetime.datetime.now()
1404
if (time2 - time) >= delay:
1405
if not client.approved_by_default:
1406
logger.warning("Client %s timed out while"
1407
" waiting for approval",
1409
if self.server.use_dbus:
1411
client.Rejected("Approval timed out")
1416
delay -= time2 - time
1419
while sent_size < len(client.secret):
1421
sent = session.send(client.secret[sent_size:])
1422
except gnutls.errors.GNUTLSError as error:
1423
logger.warning("gnutls send failed")
1425
logger.debug("Sent: %d, remaining: %d",
1426
sent, len(client.secret)
1427
- (sent_size + sent))
1430
logger.info("Sending secret to %s", client.name)
1431
# bump the timeout as if seen
1432
client.checked_ok(client.extended_timeout)
1433
if self.server.use_dbus:
1438
if approval_required:
1439
client.approvals_pending -= 1
1442
except gnutls.errors.GNUTLSError as error:
1443
logger.warning("GnuTLS bye failed")
1446
def peer_certificate(session):
1447
"Return the peer's OpenPGP certificate as a bytestring"
1448
# If not an OpenPGP certificate...
1449
if (gnutls.library.functions
1450
.gnutls_certificate_type_get(session._c_object)
1451
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1452
# ...do the normal thing
1453
return session.peer_certificate
1454
list_size = ctypes.c_uint(1)
1455
cert_list = (gnutls.library.functions
1456
.gnutls_certificate_get_peers
1457
(session._c_object, ctypes.byref(list_size)))
1458
if not bool(cert_list) and list_size.value != 0:
1459
raise gnutls.errors.GNUTLSError("error getting peer"
1461
if list_size.value == 0:
1464
return ctypes.string_at(cert.data, cert.size)
1467
def fingerprint(openpgp):
1468
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1469
# New GnuTLS "datum" with the OpenPGP public key
1470
datum = (gnutls.library.types
1471
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1474
ctypes.c_uint(len(openpgp))))
1475
# New empty GnuTLS certificate
1476
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1477
(gnutls.library.functions
1478
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1479
# Import the OpenPGP public key into the certificate
1480
(gnutls.library.functions
1481
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1482
gnutls.library.constants
1483
.GNUTLS_OPENPGP_FMT_RAW))
1484
# Verify the self signature in the key
1485
crtverify = ctypes.c_uint()
1486
(gnutls.library.functions
1487
.gnutls_openpgp_crt_verify_self(crt, 0,
1488
ctypes.byref(crtverify)))
1489
if crtverify.value != 0:
1490
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1491
raise (gnutls.errors.CertificateSecurityError
1493
# New buffer for the fingerprint
1494
buf = ctypes.create_string_buffer(20)
1495
buf_len = ctypes.c_size_t()
1496
# Get the fingerprint from the certificate into the buffer
1497
(gnutls.library.functions
1498
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1499
ctypes.byref(buf_len)))
1500
# Deinit the certificate
1501
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1502
# Convert the buffer to a Python bytestring
1503
fpr = ctypes.string_at(buf, buf_len.value)
1504
# Convert the bytestring to hexadecimal notation
1505
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
1509
class MultiprocessingMixIn(object):
1510
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1511
def sub_process_main(self, request, address):
1513
self.finish_request(request, address)
1515
self.handle_error(request, address)
1516
self.close_request(request)
1518
def process_request(self, request, address):
1519
"""Start a new process to process the request."""
1520
proc = multiprocessing.Process(target = self.sub_process_main,
1527
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1528
""" adds a pipe to the MixIn """
1529
def process_request(self, request, client_address):
1530
"""Overrides and wraps the original process_request().
1532
This function creates a new pipe in self.pipe
1534
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1536
proc = MultiprocessingMixIn.process_request(self, request,
1538
self.child_pipe.close()
1539
self.add_pipe(parent_pipe, proc)
1541
def add_pipe(self, parent_pipe, proc):
1542
"""Dummy function; override as necessary"""
1543
raise NotImplementedError
1546
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1547
socketserver.TCPServer, object):
1548
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
498
settings: Server settings
499
clients: Set() of Client objects
1551
enabled: Boolean; whether this server is activated yet
1552
interface: None or a network interface name (string)
1553
use_ipv6: Boolean; to use IPv6 or not
501
address_family = socket.AF_INET6
502
def __init__(self, *args, **kwargs):
503
if "settings" in kwargs:
504
self.settings = kwargs["settings"]
505
del kwargs["settings"]
506
if "clients" in kwargs:
507
self.clients = kwargs["clients"]
508
del kwargs["clients"]
509
return super(type(self), self).__init__(*args, **kwargs)
1555
def __init__(self, server_address, RequestHandlerClass,
1556
interface=None, use_ipv6=True):
1557
self.interface = interface
1559
self.address_family = socket.AF_INET6
1560
socketserver.TCPServer.__init__(self, server_address,
1561
RequestHandlerClass)
510
1562
def server_bind(self):
511
1563
"""This overrides the normal server_bind() function
512
1564
to bind to an interface if one was specified, and also NOT to
513
1565
bind to an address or port if they were not specified."""
514
if self.settings["interface"]:
515
# 25 is from /usr/include/asm-i486/socket.h
516
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
518
self.socket.setsockopt(socket.SOL_SOCKET,
520
self.settings["interface"])
521
except socket.error, error:
522
if error[0] == errno.EPERM:
523
logger.error(u"No permission to"
524
u" bind to interface %s",
525
self.settings["interface"])
1566
if self.interface is not None:
1567
if SO_BINDTODEVICE is None:
1568
logger.error("SO_BINDTODEVICE does not exist;"
1569
" cannot bind to interface %s",
1573
self.socket.setsockopt(socket.SOL_SOCKET,
1577
except socket.error as error:
1578
if error[0] == errno.EPERM:
1579
logger.error("No permission to"
1580
" bind to interface %s",
1582
elif error[0] == errno.ENOPROTOOPT:
1583
logger.error("SO_BINDTODEVICE not available;"
1584
" cannot bind to interface %s",
528
1588
# Only bind(2) the socket if we really need to.
529
1589
if self.server_address[0] or self.server_address[1]:
530
1590
if not self.server_address[0]:
532
self.server_address = (in6addr_any,
1591
if self.address_family == socket.AF_INET6:
1592
any_address = "::" # in6addr_any
1594
any_address = socket.INADDR_ANY
1595
self.server_address = (any_address,
533
1596
self.server_address[1])
534
1597
elif not self.server_address[1]:
535
1598
self.server_address = (self.server_address[0],
537
# if self.settings["interface"]:
1600
# if self.interface:
538
1601
# self.server_address = (self.server_address[0],
541
1604
# if_nametoindex
544
return super(type(self), self).server_bind()
1606
return socketserver.TCPServer.server_bind(self)
1609
class MandosServer(IPv6_TCPServer):
1613
clients: set of Client objects
1614
gnutls_priority GnuTLS priority string
1615
use_dbus: Boolean; to emit D-Bus signals or not
1617
Assumes a gobject.MainLoop event loop.
1619
def __init__(self, server_address, RequestHandlerClass,
1620
interface=None, use_ipv6=True, clients=None,
1621
gnutls_priority=None, use_dbus=True):
1622
self.enabled = False
1623
self.clients = clients
1624
if self.clients is None:
1625
self.clients = set()
1626
self.use_dbus = use_dbus
1627
self.gnutls_priority = gnutls_priority
1628
IPv6_TCPServer.__init__(self, server_address,
1629
RequestHandlerClass,
1630
interface = interface,
1631
use_ipv6 = use_ipv6)
1632
def server_activate(self):
1634
return socketserver.TCPServer.server_activate(self)
1639
def add_pipe(self, parent_pipe, proc):
1640
# Call "handle_ipc" for both data and EOF events
1641
gobject.io_add_watch(parent_pipe.fileno(),
1642
gobject.IO_IN | gobject.IO_HUP,
1643
functools.partial(self.handle_ipc,
1648
def handle_ipc(self, source, condition, parent_pipe=None,
1649
proc = None, client_object=None):
1651
gobject.IO_IN: "IN", # There is data to read.
1652
gobject.IO_OUT: "OUT", # Data can be written (without
1654
gobject.IO_PRI: "PRI", # There is urgent data to read.
1655
gobject.IO_ERR: "ERR", # Error condition.
1656
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1657
# broken, usually for pipes and
1660
conditions_string = ' | '.join(name
1662
condition_names.iteritems()
1663
if cond & condition)
1664
# error or the other end of multiprocessing.Pipe has closed
1665
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1669
# Read a request from the child
1670
request = parent_pipe.recv()
1671
command = request[0]
1673
if command == 'init':
1675
address = request[2]
1677
for c in self.clients:
1678
if c.fingerprint == fpr:
1682
logger.info("Client not found for fingerprint: %s, ad"
1683
"dress: %s", fpr, address)
1686
mandos_dbus_service.ClientNotFound(fpr,
1688
parent_pipe.send(False)
1691
gobject.io_add_watch(parent_pipe.fileno(),
1692
gobject.IO_IN | gobject.IO_HUP,
1693
functools.partial(self.handle_ipc,
1699
parent_pipe.send(True)
1700
# remove the old hook in favor of the new above hook on
1703
if command == 'funcall':
1704
funcname = request[1]
1708
parent_pipe.send(('data', getattr(client_object,
1712
if command == 'getattr':
1713
attrname = request[1]
1714
if callable(client_object.__getattribute__(attrname)):
1715
parent_pipe.send(('function',))
1717
parent_pipe.send(('data', client_object
1718
.__getattribute__(attrname)))
1720
if command == 'setattr':
1721
attrname = request[1]
1723
setattr(client_object, attrname, value)
547
1728
def string_to_delta(interval):
548
1729
"""Parse a string and return a datetime.timedelta
550
1731
>>> string_to_delta('7d')
551
1732
datetime.timedelta(7)
552
1733
>>> string_to_delta('60s')
689
1864
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
690
1865
"servicename": "Mandos",
693
1871
# Parse config file for server-global settings
694
server_config = ConfigParser.SafeConfigParser(server_defaults)
1872
server_config = configparser.SafeConfigParser(server_defaults)
695
1873
del server_defaults
696
server_config.read(os.path.join(options.configdir, "mandos.conf"))
697
server_section = "server"
1874
server_config.read(os.path.join(options.configdir,
698
1876
# Convert the SafeConfigParser object to a dict
699
server_settings = dict(server_config.items(server_section))
700
# Use getboolean on the boolean config option
701
server_settings["debug"] = server_config.getboolean\
702
(server_section, "debug")
1877
server_settings = server_config.defaults()
1878
# Use the appropriate methods on the non-string config options
1879
for option in ("debug", "use_dbus", "use_ipv6"):
1880
server_settings[option] = server_config.getboolean("DEFAULT",
1882
if server_settings["port"]:
1883
server_settings["port"] = server_config.getint("DEFAULT",
703
1885
del server_config
705
1887
# Override the settings from the config file with command line
706
1888
# options, if set.
707
1889
for option in ("interface", "address", "port", "debug",
708
"priority", "servicename", "configdir"):
1890
"priority", "servicename", "configdir",
1891
"use_dbus", "use_ipv6", "debuglevel"):
709
1892
value = getattr(options, option)
710
1893
if value is not None:
711
1894
server_settings[option] = value
1896
# Force all strings to be unicode
1897
for option in server_settings.keys():
1898
if type(server_settings[option]) is str:
1899
server_settings[option] = unicode(server_settings[option])
713
1900
# Now we have our good server settings in "server_settings"
1902
##################################################################
715
1905
debug = server_settings["debug"]
718
syslogger.setLevel(logging.WARNING)
1906
debuglevel = server_settings["debuglevel"]
1907
use_dbus = server_settings["use_dbus"]
1908
use_ipv6 = server_settings["use_ipv6"]
720
1910
if server_settings["servicename"] != "Mandos":
721
syslogger.setFormatter(logging.Formatter\
722
('Mandos (%s): %%(levelname)s:'
1911
syslogger.setFormatter(logging.Formatter
1912
('Mandos (%s) [%%(process)d]:'
1913
' %%(levelname)s: %%(message)s'
724
1914
% server_settings["servicename"]))
726
1916
# Parse config file with clients
727
client_defaults = { "timeout": "1h",
1917
client_defaults = { "timeout": "5m",
1918
"extended_timeout": "15m",
729
1920
"checker": "fping -q -- %%(host)s",
1922
"approval_delay": "0s",
1923
"approval_duration": "1s",
731
client_config = ConfigParser.SafeConfigParser(client_defaults)
1925
client_config = configparser.SafeConfigParser(client_defaults)
732
1926
client_config.read(os.path.join(server_settings["configdir"],
733
1927
"clients.conf"))
736
service = AvahiService(name = server_settings["servicename"],
737
type = "_mandos._tcp", );
738
if server_settings["interface"]:
739
service.interface = if_nametoindex(server_settings["interface"])
1929
global mandos_dbus_service
1930
mandos_dbus_service = None
1932
tcp_server = MandosServer((server_settings["address"],
1933
server_settings["port"]),
1935
interface=(server_settings["interface"]
1939
server_settings["priority"],
1942
pidfilename = "/var/run/mandos.pid"
1944
pidfile = open(pidfilename, "w")
1946
logger.error("Could not open file %r", pidfilename)
1949
uid = pwd.getpwnam("_mandos").pw_uid
1950
gid = pwd.getpwnam("_mandos").pw_gid
1953
uid = pwd.getpwnam("mandos").pw_uid
1954
gid = pwd.getpwnam("mandos").pw_gid
1957
uid = pwd.getpwnam("nobody").pw_uid
1958
gid = pwd.getpwnam("nobody").pw_gid
1965
except OSError as error:
1966
if error[0] != errno.EPERM:
1969
if not debug and not debuglevel:
1970
syslogger.setLevel(logging.WARNING)
1971
console.setLevel(logging.WARNING)
1973
level = getattr(logging, debuglevel.upper())
1974
syslogger.setLevel(level)
1975
console.setLevel(level)
1978
# Enable all possible GnuTLS debugging
1980
# "Use a log level over 10 to enable all debugging options."
1982
gnutls.library.functions.gnutls_global_set_log_level(11)
1984
@gnutls.library.types.gnutls_log_func
1985
def debug_gnutls(level, string):
1986
logger.debug("GnuTLS: %s", string[:-1])
1988
(gnutls.library.functions
1989
.gnutls_global_set_log_function(debug_gnutls))
1991
# Redirect stdin so all checkers get /dev/null
1992
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1993
os.dup2(null, sys.stdin.fileno())
1997
# No console logging
1998
logger.removeHandler(console)
2000
# Need to fork before connecting to D-Bus
2002
# Close all input and output, do double fork, etc.
741
2005
global main_loop
744
2006
# From the Avahi example code
745
2007
DBusGMainLoop(set_as_default=True )
746
2008
main_loop = gobject.MainLoop()
747
2009
bus = dbus.SystemBus()
748
server = dbus.Interface(
749
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
750
avahi.DBUS_INTERFACE_SERVER )
751
2010
# End of Avahi example code
754
console = logging.StreamHandler()
755
# console.setLevel(logging.DEBUG)
756
console.setFormatter(logging.Formatter\
757
('%(levelname)s: %(message)s'))
758
logger.addHandler(console)
762
def remove_from_clients(client):
763
clients.remove(client)
765
logger.critical(u"No clients left, exiting")
768
clients.update(Set(Client(name = section,
769
stop_hook = remove_from_clients,
771
= dict(client_config.items(section)))
772
for section in client_config.sections()))
774
logger.critical(u"No clients defined")
2013
bus_name = dbus.service.BusName("se.recompile.Mandos",
2014
bus, do_not_queue=True)
2015
old_bus_name = (dbus.service.BusName
2016
("se.bsnet.fukt.Mandos", bus,
2018
except dbus.exceptions.NameExistsException as e:
2019
logger.error(unicode(e) + ", disabling D-Bus")
2021
server_settings["use_dbus"] = False
2022
tcp_server.use_dbus = False
2023
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2024
service = AvahiService(name = server_settings["servicename"],
2025
servicetype = "_mandos._tcp",
2026
protocol = protocol, bus = bus)
2027
if server_settings["interface"]:
2028
service.interface = (if_nametoindex
2029
(str(server_settings["interface"])))
2031
global multiprocessing_manager
2032
multiprocessing_manager = multiprocessing.Manager()
2034
client_class = Client
2036
client_class = functools.partial(ClientDBusTransitional,
2038
def client_config_items(config, section):
2039
special_settings = {
2040
"approved_by_default":
2041
lambda: config.getboolean(section,
2042
"approved_by_default"),
2044
for name, value in config.items(section):
2046
yield (name, special_settings[name]())
2050
tcp_server.clients.update(set(
2051
client_class(name = section,
2052
config= dict(client_config_items(
2053
client_config, section)))
2054
for section in client_config.sections()))
2055
if not tcp_server.clients:
2056
logger.warning("No clients defined")
780
pidfilename = "/var/run/mandos/mandos.pid"
783
pidfile = open(pidfilename, "w")
784
pidfile.write(str(pid) + "\n")
788
logger.error(u"Could not write %s file with PID %d",
789
pidfilename, os.getpid())
2062
pidfile.write(str(pid) + "\n".encode("utf-8"))
2065
logger.error("Could not write to file %r with PID %d",
2068
# "pidfile" was never created
2072
signal.signal(signal.SIGINT, signal.SIG_IGN)
2074
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2075
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2078
class MandosDBusService(dbus.service.Object):
2079
"""A D-Bus proxy object"""
2081
dbus.service.Object.__init__(self, bus, "/")
2082
_interface = "se.recompile.Mandos"
2084
@dbus.service.signal(_interface, signature="o")
2085
def ClientAdded(self, objpath):
2089
@dbus.service.signal(_interface, signature="ss")
2090
def ClientNotFound(self, fingerprint, address):
2094
@dbus.service.signal(_interface, signature="os")
2095
def ClientRemoved(self, objpath, name):
2099
@dbus.service.method(_interface, out_signature="ao")
2100
def GetAllClients(self):
2102
return dbus.Array(c.dbus_object_path
2103
for c in tcp_server.clients)
2105
@dbus.service.method(_interface,
2106
out_signature="a{oa{sv}}")
2107
def GetAllClientsWithProperties(self):
2109
return dbus.Dictionary(
2110
((c.dbus_object_path, c.GetAll(""))
2111
for c in tcp_server.clients),
2114
@dbus.service.method(_interface, in_signature="o")
2115
def RemoveClient(self, object_path):
2117
for c in tcp_server.clients:
2118
if c.dbus_object_path == object_path:
2119
tcp_server.clients.remove(c)
2120
c.remove_from_connection()
2121
# Don't signal anything except ClientRemoved
2122
c.disable(quiet=True)
2124
self.ClientRemoved(object_path, c.name)
2126
raise KeyError(object_path)
2130
class MandosDBusServiceTransitional(MandosDBusService):
2131
__metaclass__ = AlternateDBusNamesMetaclass
2132
mandos_dbus_service = MandosDBusServiceTransitional()
792
2135
"Cleanup function; run on exit"
794
# From the Avahi example code
795
if not group is None:
798
# End of Avahi example code
801
client = clients.pop()
802
client.stop_hook = None
2138
multiprocessing.active_children()
2139
while tcp_server.clients:
2140
client = tcp_server.clients.pop()
2142
client.remove_from_connection()
2143
client.disable_hook = None
2144
# Don't signal anything except ClientRemoved
2145
client.disable(quiet=True)
2148
mandos_dbus_service.ClientRemoved(client
805
2152
atexit.register(cleanup)
808
signal.signal(signal.SIGINT, signal.SIG_IGN)
809
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
810
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
812
for client in clients:
815
tcp_server = IPv6_TCPServer((server_settings["address"],
816
server_settings["port"]),
818
settings=server_settings,
2154
for client in tcp_server.clients:
2157
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2161
tcp_server.server_activate()
820
2163
# Find out what port we got
821
2164
service.port = tcp_server.socket.getsockname()[1]
822
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
823
u" scope_id %d" % tcp_server.socket.getsockname())
2166
logger.info("Now listening on address %r, port %d,"
2167
" flowinfo %d, scope_id %d"
2168
% tcp_server.socket.getsockname())
2170
logger.info("Now listening on address %r, port %d"
2171
% tcp_server.socket.getsockname())
825
2173
#service.interface = tcp_server.socket.getsockname()[3]
828
2176
# From the Avahi example code
829
server.connect_to_signal("StateChanged", server_state_changed)
831
server_state_changed(server.GetState())
832
except dbus.exceptions.DBusException, error:
833
logger.critical(u"DBusException: %s", error)
2179
except dbus.exceptions.DBusException as error:
2180
logger.critical("DBusException: %s", error)
835
2183
# End of Avahi example code
837
2185
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
838
2186
lambda *args, **kwargs:
839
tcp_server.handle_request\
840
(*args[2:], **kwargs) or True)
2187
(tcp_server.handle_request
2188
(*args[2:], **kwargs) or True))
842
logger.debug(u"Starting main loop")
843
main_loop_started = True
2190
logger.debug("Starting main loop")
845
except AvahiError, error:
846
logger.critical(u"AvahiError: %s" + unicode(error))
2192
except AvahiError as error:
2193
logger.critical("AvahiError: %s", error)
848
2196
except KeyboardInterrupt:
2198
print("", file=sys.stderr)
2199
logger.debug("Server received KeyboardInterrupt")
2200
logger.debug("Server exiting")
2201
# Must run before the D-Bus bus name gets deregistered
852
2205
if __name__ == '__main__':