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