104
130
max_renames: integer; maximum number of renames
105
131
rename_count: integer; counter so we only rename after collisions
106
132
a sensible number of times
133
group: D-Bus Entry Group
135
bus: dbus.SystemBus()
108
137
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
109
type = None, port = None, TXT = None, domain = "",
110
host = "", max_renames = 32768):
138
servicetype = None, port = None, TXT = None,
139
domain = u"", host = u"", max_renames = 32768,
140
protocol = avahi.PROTO_UNSPEC, bus = None):
111
141
self.interface = interface
143
self.type = servicetype
145
self.TXT = TXT if TXT is not None else []
119
146
self.domain = domain
121
148
self.rename_count = 0
149
self.max_renames = max_renames
150
self.protocol = protocol
151
self.group = None # our entry group
122
154
def rename(self):
123
155
"""Derived from the Avahi example code"""
124
156
if self.rename_count >= self.max_renames:
125
logger.critical(u"No suitable service name found after %i"
126
u" retries, exiting.", rename_count)
127
raise AvahiServiceError("Too many renames")
128
name = server.GetAlternativeServiceName(name)
129
logger.error(u"Changing name to %r ...", name)
130
syslogger.setFormatter(logging.Formatter\
131
('Mandos (%s): %%(levelname)s:'
132
' %%(message)s' % name))
157
logger.critical(u"No suitable Zeroconf service name found"
158
u" after %i retries, exiting.",
160
raise AvahiServiceError(u"Too many renames")
161
self.name = self.server.GetAlternativeServiceName(self.name)
162
logger.info(u"Changing Zeroconf service name to %r ...",
164
syslogger.setFormatter(logging.Formatter
165
(u'Mandos (%s) [%%(process)d]:'
166
u' %%(levelname)s: %%(message)s'
135
170
self.rename_count += 1
136
171
def remove(self):
137
172
"""Derived from the Avahi example code"""
138
if group is not None:
173
if self.group is not None:
141
176
"""Derived from the Avahi example code"""
144
group = dbus.Interface\
145
(bus.get_object(avahi.DBUS_NAME,
146
server.EntryGroupNew()),
147
avahi.DBUS_INTERFACE_ENTRY_GROUP)
148
group.connect_to_signal('StateChanged',
149
entry_group_state_changed)
150
logger.debug(u"Adding service '%s' of type '%s' ...",
151
service.name, service.type)
153
self.interface, # interface
154
avahi.PROTO_INET6, # protocol
155
dbus.UInt32(0), # flags
156
self.name, self.type,
157
self.domain, self.host,
158
dbus.UInt16(self.port),
159
avahi.string_array_to_txt_array(self.TXT))
162
# From the Avahi example code:
163
group = None # our entry group
164
# End of Avahi example code
177
if self.group is None:
178
self.group = dbus.Interface(
179
self.bus.get_object(avahi.DBUS_NAME,
180
self.server.EntryGroupNew()),
181
avahi.DBUS_INTERFACE_ENTRY_GROUP)
182
self.group.connect_to_signal('StateChanged',
184
.entry_group_state_changed)
185
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
186
self.name, self.type)
187
self.group.AddService(
190
dbus.UInt32(0), # flags
191
self.name, self.type,
192
self.domain, self.host,
193
dbus.UInt16(self.port),
194
avahi.string_array_to_txt_array(self.TXT))
196
def entry_group_state_changed(self, state, error):
197
"""Derived from the Avahi example code"""
198
logger.debug(u"Avahi state change: %i", state)
200
if state == avahi.ENTRY_GROUP_ESTABLISHED:
201
logger.debug(u"Zeroconf service established.")
202
elif state == avahi.ENTRY_GROUP_COLLISION:
203
logger.warning(u"Zeroconf service name collision.")
205
elif state == avahi.ENTRY_GROUP_FAILURE:
206
logger.critical(u"Avahi: Error in group state changed %s",
208
raise AvahiGroupError(u"State changed: %s"
211
"""Derived from the Avahi example code"""
212
if self.group is not None:
215
def server_state_changed(self, state):
216
"""Derived from the Avahi example code"""
217
if state == avahi.SERVER_COLLISION:
218
logger.error(u"Zeroconf server name collision")
220
elif state == avahi.SERVER_RUNNING:
223
"""Derived from the Avahi example code"""
224
if self.server is None:
225
self.server = dbus.Interface(
226
self.bus.get_object(avahi.DBUS_NAME,
227
avahi.DBUS_PATH_SERVER),
228
avahi.DBUS_INTERFACE_SERVER)
229
self.server.connect_to_signal(u"StateChanged",
230
self.server_state_changed)
231
self.server_state_changed(self.server.GetState())
167
234
class Client(object):
168
235
"""A representation of a client host served by this server.
170
name: string; from the config file, used in log messages
238
name: string; from the config file, used in log messages and
171
240
fingerprint: string (40 or 32 hexadecimal digits); used to
172
241
uniquely identify the client
173
secret: bytestring; sent verbatim (over TLS) to client
174
host: string; available for use by the checker command
175
created: datetime.datetime(); object creation, not client host
176
last_checked_ok: datetime.datetime() or None if not yet checked OK
177
timeout: datetime.timedelta(); How long from last_checked_ok
178
until this client is invalid
179
interval: datetime.timedelta(); How often to start a new checker
180
stop_hook: If set, called by stop() as stop_hook(self)
181
checker: subprocess.Popen(); a running checker process used
182
to see if the client lives.
183
'None' if no process is running.
242
secret: bytestring; sent verbatim (over TLS) to client
243
host: string; available for use by the checker command
244
created: datetime.datetime(); (UTC) object creation
245
last_enabled: datetime.datetime(); (UTC)
247
last_checked_ok: datetime.datetime(); (UTC) or None
248
timeout: datetime.timedelta(); How long from last_checked_ok
249
until this client is disabled
250
interval: datetime.timedelta(); How often to start a new checker
251
disable_hook: If set, called by disable() as disable_hook(self)
252
checker: subprocess.Popen(); a running checker process used
253
to see if the client lives.
254
'None' if no process is running.
184
255
checker_initiator_tag: a gobject event source tag, or None
185
stop_initiator_tag: - '' -
256
disable_initiator_tag: - '' -
186
257
checker_callback_tag: - '' -
187
258
checker_command: string; External command which is run to check if
188
259
client lives. %() expansions are done at
189
260
runtime with vars(self) as dict, so that for
190
261
instance %(name)s can be used in the command.
192
_timeout: Real variable for 'timeout'
193
_interval: Real variable for 'interval'
194
_timeout_milliseconds: Used when calling gobject.timeout_add()
195
_interval_milliseconds: - '' -
262
current_checker_command: string; current running checker_command
263
approved_delay: datetime.timedelta(); Time to wait for approval
264
_approved: bool(); 'None' if not yet approved/disapproved
265
approved_duration: datetime.timedelta(); Duration of one approval
197
def _set_timeout(self, timeout):
198
"Setter function for 'timeout' attribute"
199
self._timeout = timeout
200
self._timeout_milliseconds = ((self.timeout.days
201
* 24 * 60 * 60 * 1000)
202
+ (self.timeout.seconds * 1000)
203
+ (self.timeout.microseconds
205
timeout = property(lambda self: self._timeout,
208
def _set_interval(self, interval):
209
"Setter function for 'interval' attribute"
210
self._interval = interval
211
self._interval_milliseconds = ((self.interval.days
212
* 24 * 60 * 60 * 1000)
213
+ (self.interval.seconds
215
+ (self.interval.microseconds
217
interval = property(lambda self: self._interval,
220
def __init__(self, name = None, stop_hook=None, config={}):
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))
275
def timeout_milliseconds(self):
276
"Return the 'timeout' attribute in milliseconds"
277
return self._timedelta_to_milliseconds(self.timeout)
279
def interval_milliseconds(self):
280
"Return the 'interval' attribute in milliseconds"
281
return self._timedelta_to_milliseconds(self.interval)
283
def approved_delay_milliseconds(self):
284
return self._timedelta_to_milliseconds(self.approved_delay)
286
def __init__(self, name = None, disable_hook=None, config=None):
221
287
"""Note: the 'checker' key in 'config' sets the
222
288
'checker_command' attribute and *not* the 'checker'
225
293
logger.debug(u"Creating client %r", self.name)
226
294
# Uppercase and remove spaces from fingerprint for later
227
295
# comparison purposes with return value from the fingerprint()
229
self.fingerprint = config["fingerprint"].upper()\
297
self.fingerprint = (config[u"fingerprint"].upper()
231
299
logger.debug(u" Fingerprint: %s", self.fingerprint)
232
if "secret" in config:
233
self.secret = config["secret"].decode(u"base64")
234
elif "secfile" in config:
235
sf = open(config["secfile"])
236
self.secret = sf.read()
300
if u"secret" in config:
301
self.secret = config[u"secret"].decode(u"base64")
302
elif u"secfile" in config:
303
with open(os.path.expanduser(os.path.expandvars
304
(config[u"secfile"])),
306
self.secret = secfile.read()
308
#XXX Need to allow secret on demand!
239
309
raise TypeError(u"No secret or secfile for client %s"
241
self.host = config.get("host", "")
242
self.created = datetime.datetime.now()
311
self.host = config.get(u"host", u"")
312
self.created = datetime.datetime.utcnow()
314
self.last_enabled = None
243
315
self.last_checked_ok = None
244
self.timeout = string_to_delta(config["timeout"])
245
self.interval = string_to_delta(config["interval"])
246
self.stop_hook = stop_hook
316
self.timeout = string_to_delta(config[u"timeout"])
317
self.interval = string_to_delta(config[u"interval"])
318
self.disable_hook = disable_hook
247
319
self.checker = None
248
320
self.checker_initiator_tag = None
249
self.stop_initiator_tag = None
321
self.disable_initiator_tag = None
250
322
self.checker_callback_tag = None
251
self.check_command = config["checker"]
323
self.checker_command = config[u"checker"]
324
self.current_checker_command = None
325
self.last_connect = None
326
self.approvals_pending = 0
327
self._approved = None
328
self.approved_by_default = config.get(u"approved_by_default",
330
self.approved_delay = string_to_delta(
331
config[u"approved_delay"])
332
self.approved_duration = string_to_delta(
333
config[u"approved_duration"])
334
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
336
def send_changedstate(self):
337
self.changedstate.acquire()
338
self.changedstate.notify_all()
339
self.changedstate.release()
253
342
"""Start this client's checker and timeout hooks"""
343
if getattr(self, u"enabled", False):
346
self.send_changedstate()
347
self.last_enabled = datetime.datetime.utcnow()
254
348
# Schedule a new checker to be started an 'interval' from now,
255
349
# and every interval from then on.
256
self.checker_initiator_tag = gobject.timeout_add\
257
(self._interval_milliseconds,
350
self.checker_initiator_tag = (gobject.timeout_add
351
(self.interval_milliseconds(),
353
# Schedule a disable() when 'timeout' has passed
354
self.disable_initiator_tag = (gobject.timeout_add
355
(self.timeout_milliseconds(),
259
358
# Also start a new checker *right now*.
260
359
self.start_checker()
261
# Schedule a stop() when 'timeout' has passed
262
self.stop_initiator_tag = gobject.timeout_add\
263
(self._timeout_milliseconds,
267
The possibility that a client might be restarted is left open,
268
but not currently used."""
269
# If this client doesn't have a secret, it is already stopped.
270
if hasattr(self, "secret") and self.secret:
271
logger.info(u"Stopping client %s", self.name)
361
def disable(self, quiet=True):
362
"""Disable this client."""
363
if not getattr(self, "enabled", False):
275
if getattr(self, "stop_initiator_tag", False):
276
gobject.source_remove(self.stop_initiator_tag)
277
self.stop_initiator_tag = None
278
if getattr(self, "checker_initiator_tag", False):
366
self.send_changedstate()
368
logger.info(u"Disabling client %s", self.name)
369
if getattr(self, u"disable_initiator_tag", False):
370
gobject.source_remove(self.disable_initiator_tag)
371
self.disable_initiator_tag = None
372
if getattr(self, u"checker_initiator_tag", False):
279
373
gobject.source_remove(self.checker_initiator_tag)
280
374
self.checker_initiator_tag = None
281
375
self.stop_checker()
376
if self.disable_hook:
377
self.disable_hook(self)
284
379
# Do not run this again if called by a gobject.timeout_add
286
382
def __del__(self):
287
self.stop_hook = None
289
def checker_callback(self, pid, condition):
383
self.disable_hook = None
386
def checker_callback(self, pid, condition, command):
290
387
"""The checker has completed, so take appropriate actions."""
291
now = datetime.datetime.now()
292
388
self.checker_callback_tag = None
293
389
self.checker = None
294
if os.WIFEXITED(condition) \
295
and (os.WEXITSTATUS(condition) == 0):
296
logger.info(u"Checker for %(name)s succeeded",
298
self.last_checked_ok = now
299
gobject.source_remove(self.stop_initiator_tag)
300
self.stop_initiator_tag = gobject.timeout_add\
301
(self._timeout_milliseconds,
303
elif not os.WIFEXITED(condition):
390
if os.WIFEXITED(condition):
391
exitstatus = os.WEXITSTATUS(condition)
393
logger.info(u"Checker for %(name)s succeeded",
397
logger.info(u"Checker for %(name)s failed",
304
400
logger.warning(u"Checker for %(name)s crashed?",
307
logger.info(u"Checker for %(name)s failed",
403
def checked_ok(self):
404
"""Bump up the timeout for this client.
406
This should only be called when the client has been seen,
409
self.last_checked_ok = datetime.datetime.utcnow()
410
gobject.source_remove(self.disable_initiator_tag)
411
self.disable_initiator_tag = (gobject.timeout_add
412
(self.timeout_milliseconds(),
309
415
def start_checker(self):
310
416
"""Start a new checker subprocess if one is not running.
311
418
If a checker already exists, leave it running and do
313
420
# The reason for not killing a running checker is that if we
316
423
# client would inevitably timeout, since no checker would get
317
424
# a chance to run to completion. If we instead leave running
318
425
# checkers alone, the checker would have to take more time
319
# than 'timeout' for the client to be declared invalid, which
320
# is as it should be.
426
# than 'timeout' for the client to be disabled, which is as it
429
# If a checker exists, make sure it is not a zombie
431
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
432
except (AttributeError, OSError), error:
433
if (isinstance(error, OSError)
434
and error.errno != errno.ECHILD):
438
logger.warning(u"Checker was a zombie")
439
gobject.source_remove(self.checker_callback_tag)
440
self.checker_callback(pid, status,
441
self.current_checker_command)
442
# Start a new checker if needed
321
443
if self.checker is None:
323
# In case check_command has exactly one % operator
324
command = self.check_command % self.host
445
# In case checker_command has exactly one % operator
446
command = self.checker_command % self.host
325
447
except TypeError:
326
448
# Escape attributes for the shell
327
escaped_attrs = dict((key, re.escape(str(val)))
449
escaped_attrs = dict((key,
450
re.escape(unicode(str(val),
329
454
vars(self).iteritems())
331
command = self.check_command % escaped_attrs
456
command = self.checker_command % escaped_attrs
332
457
except TypeError, error:
333
458
logger.error(u'Could not format string "%s":'
334
u' %s', self.check_command, error)
459
u' %s', self.checker_command, error)
335
460
return True # Try again later
461
self.current_checker_command = command
337
463
logger.info(u"Starting checker %r for %s",
338
464
command, self.name)
465
# We don't need to redirect stdout and stderr, since
466
# in normal mode, that is already done by daemon(),
467
# and in debug mode we don't want to. (Stdin is
468
# always replaced by /dev/null.)
339
469
self.checker = subprocess.Popen(command,
342
self.checker_callback_tag = gobject.child_watch_add\
344
self.checker_callback)
345
except subprocess.OSError, error:
471
shell=True, cwd=u"/")
472
self.checker_callback_tag = (gobject.child_watch_add
474
self.checker_callback,
476
# The checker may have completed before the gobject
477
# watch was added. Check for this.
478
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
480
gobject.source_remove(self.checker_callback_tag)
481
self.checker_callback(pid, status, command)
482
except OSError, error:
346
483
logger.error(u"Failed to start subprocess: %s",
348
485
# Re-run this periodically if run by gobject.timeout_add
350
488
def stop_checker(self):
351
489
"""Force the checker process, if any, to stop."""
352
490
if self.checker_callback_tag:
353
491
gobject.source_remove(self.checker_callback_tag)
354
492
self.checker_callback_tag = None
355
if getattr(self, "checker", None) is None:
493
if getattr(self, u"checker", None) is None:
357
495
logger.debug(u"Stopping checker for %(name)s", vars(self))
359
497
os.kill(self.checker.pid, signal.SIGTERM)
361
499
#if self.checker.poll() is None:
362
500
# os.kill(self.checker.pid, signal.SIGKILL)
363
501
except OSError, error:
364
502
if error.errno != errno.ESRCH: # No such process
366
504
self.checker = None
367
def still_valid(self):
368
"""Has the timeout not yet passed for this client?"""
369
now = datetime.datetime.now()
506
def dbus_service_property(dbus_interface, signature=u"v",
507
access=u"readwrite", byte_arrays=False):
508
"""Decorators for marking methods of a DBusObjectWithProperties to
509
become properties on the D-Bus.
511
The decorated method will be called with no arguments by "Get"
512
and with one argument by "Set".
514
The parameters, where they are supported, are the same as
515
dbus.service.method, except there is only "signature", since the
516
type from Get() and the type sent to Set() is the same.
518
# Encoding deeply encoded byte arrays is not supported yet by the
519
# "Set" method, so we fail early here:
520
if byte_arrays and signature != u"ay":
521
raise ValueError(u"Byte arrays not supported for non-'ay'"
522
u" signature %r" % signature)
524
func._dbus_is_property = True
525
func._dbus_interface = dbus_interface
526
func._dbus_signature = signature
527
func._dbus_access = access
528
func._dbus_name = func.__name__
529
if func._dbus_name.endswith(u"_dbus_property"):
530
func._dbus_name = func._dbus_name[:-14]
531
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
536
class DBusPropertyException(dbus.exceptions.DBusException):
537
"""A base class for D-Bus property-related exceptions
539
def __unicode__(self):
540
return unicode(str(self))
543
class DBusPropertyAccessException(DBusPropertyException):
544
"""A property's access permissions disallows an operation.
549
class DBusPropertyNotFound(DBusPropertyException):
550
"""An attempt was made to access a non-existing property.
555
class DBusObjectWithProperties(dbus.service.Object):
556
"""A D-Bus object with properties.
558
Classes inheriting from this can use the dbus_service_property
559
decorator to expose methods as D-Bus properties. It exposes the
560
standard Get(), Set(), and GetAll() methods on the D-Bus.
564
def _is_dbus_property(obj):
565
return getattr(obj, u"_dbus_is_property", False)
567
def _get_all_dbus_properties(self):
568
"""Returns a generator of (name, attribute) pairs
570
return ((prop._dbus_name, prop)
572
inspect.getmembers(self, self._is_dbus_property))
574
def _get_dbus_property(self, interface_name, property_name):
575
"""Returns a bound method if one exists which is a D-Bus
576
property with the specified name and interface.
578
for name in (property_name,
579
property_name + u"_dbus_property"):
580
prop = getattr(self, name, None)
582
or not self._is_dbus_property(prop)
583
or prop._dbus_name != property_name
584
or (interface_name and prop._dbus_interface
585
and interface_name != prop._dbus_interface)):
589
raise DBusPropertyNotFound(self.dbus_object_path + u":"
590
+ interface_name + u"."
593
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
595
def Get(self, interface_name, property_name):
596
"""Standard D-Bus property Get() method, see D-Bus standard.
598
prop = self._get_dbus_property(interface_name, property_name)
599
if prop._dbus_access == u"write":
600
raise DBusPropertyAccessException(property_name)
602
if not hasattr(value, u"variant_level"):
604
return type(value)(value, variant_level=value.variant_level+1)
606
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
607
def Set(self, interface_name, property_name, value):
608
"""Standard D-Bus property Set() method, see D-Bus standard.
610
prop = self._get_dbus_property(interface_name, property_name)
611
if prop._dbus_access == u"read":
612
raise DBusPropertyAccessException(property_name)
613
if prop._dbus_get_args_options[u"byte_arrays"]:
614
# The byte_arrays option is not supported yet on
615
# signatures other than "ay".
616
if prop._dbus_signature != u"ay":
618
value = dbus.ByteArray(''.join(unichr(byte)
622
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
623
out_signature=u"a{sv}")
624
def GetAll(self, interface_name):
625
"""Standard D-Bus property GetAll() method, see D-Bus
628
Note: Will not include properties with access="write".
631
for name, prop in self._get_all_dbus_properties():
633
and interface_name != prop._dbus_interface):
634
# Interface non-empty but did not match
636
# Ignore write-only properties
637
if prop._dbus_access == u"write":
640
if not hasattr(value, u"variant_level"):
643
all[name] = type(value)(value, variant_level=
644
value.variant_level+1)
645
return dbus.Dictionary(all, signature=u"sv")
647
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
649
path_keyword='object_path',
650
connection_keyword='connection')
651
def Introspect(self, object_path, connection):
652
"""Standard D-Bus method, overloaded to insert property tags.
654
xmlstring = dbus.service.Object.Introspect(self, object_path,
657
document = xml.dom.minidom.parseString(xmlstring)
658
def make_tag(document, name, prop):
659
e = document.createElement(u"property")
660
e.setAttribute(u"name", name)
661
e.setAttribute(u"type", prop._dbus_signature)
662
e.setAttribute(u"access", prop._dbus_access)
664
for if_tag in document.getElementsByTagName(u"interface"):
665
for tag in (make_tag(document, name, prop)
667
in self._get_all_dbus_properties()
668
if prop._dbus_interface
669
== if_tag.getAttribute(u"name")):
670
if_tag.appendChild(tag)
671
# Add the names to the return values for the
672
# "org.freedesktop.DBus.Properties" methods
673
if (if_tag.getAttribute(u"name")
674
== u"org.freedesktop.DBus.Properties"):
675
for cn in if_tag.getElementsByTagName(u"method"):
676
if cn.getAttribute(u"name") == u"Get":
677
for arg in cn.getElementsByTagName(u"arg"):
678
if (arg.getAttribute(u"direction")
680
arg.setAttribute(u"name", u"value")
681
elif cn.getAttribute(u"name") == u"GetAll":
682
for arg in cn.getElementsByTagName(u"arg"):
683
if (arg.getAttribute(u"direction")
685
arg.setAttribute(u"name", u"props")
686
xmlstring = document.toxml(u"utf-8")
688
except (AttributeError, xml.dom.DOMException,
689
xml.parsers.expat.ExpatError), error:
690
logger.error(u"Failed to override Introspection method",
695
class ClientDBus(Client, DBusObjectWithProperties):
696
"""A Client class using D-Bus
699
dbus_object_path: dbus.ObjectPath
700
bus: dbus.SystemBus()
702
# dbus.service.Object doesn't use super(), so we can't either.
704
def __init__(self, bus = None, *args, **kwargs):
705
self._approvals_pending = 0
707
Client.__init__(self, *args, **kwargs)
708
# Only now, when this client is initialized, can it show up on
710
self.dbus_object_path = (dbus.ObjectPath
712
+ self.name.replace(u".", u"_")))
713
DBusObjectWithProperties.__init__(self, self.bus,
714
self.dbus_object_path)
716
def _get_approvals_pending(self, value):
717
return self._approvals_pending
718
def _set_approvals_pending(self, value):
719
old_value = self._approvals_pending
720
self._approvals_pending = value
722
if (hasattr(self, "dbus_object_path")
723
and bval is bool(old_value)):
724
dbus_bool = dbus.Boolean(bval, variant_level=1)
725
self.PropertyChanged(dbus.String(u"approved_pending"),
728
approvals_pending = property(_get_approvals_pending,
729
_set_approvals_pending)
730
del _get_approvals_pending, _set_approvals_pending
733
def _datetime_to_dbus(dt, variant_level=0):
734
"""Convert a UTC datetime.datetime() to a D-Bus type."""
735
return dbus.String(dt.isoformat(),
736
variant_level=variant_level)
739
oldstate = getattr(self, u"enabled", False)
740
r = Client.enable(self)
741
if oldstate != self.enabled:
743
self.PropertyChanged(dbus.String(u"enabled"),
744
dbus.Boolean(True, variant_level=1))
745
self.PropertyChanged(
746
dbus.String(u"last_enabled"),
747
self._datetime_to_dbus(self.last_enabled,
751
def disable(self, quiet = False):
752
oldstate = getattr(self, u"enabled", False)
753
r = Client.disable(self, quiet=quiet)
754
if not quiet and oldstate != self.enabled:
756
self.PropertyChanged(dbus.String(u"enabled"),
757
dbus.Boolean(False, variant_level=1))
760
def __del__(self, *args, **kwargs):
762
self.remove_from_connection()
765
if hasattr(DBusObjectWithProperties, u"__del__"):
766
DBusObjectWithProperties.__del__(self, *args, **kwargs)
767
Client.__del__(self, *args, **kwargs)
769
def checker_callback(self, pid, condition, command,
771
self.checker_callback_tag = None
774
self.PropertyChanged(dbus.String(u"checker_running"),
775
dbus.Boolean(False, variant_level=1))
776
if os.WIFEXITED(condition):
777
exitstatus = os.WEXITSTATUS(condition)
779
self.CheckerCompleted(dbus.Int16(exitstatus),
780
dbus.Int64(condition),
781
dbus.String(command))
784
self.CheckerCompleted(dbus.Int16(-1),
785
dbus.Int64(condition),
786
dbus.String(command))
788
return Client.checker_callback(self, pid, condition, command,
791
def checked_ok(self, *args, **kwargs):
792
r = Client.checked_ok(self, *args, **kwargs)
794
self.PropertyChanged(
795
dbus.String(u"last_checked_ok"),
796
(self._datetime_to_dbus(self.last_checked_ok,
800
def start_checker(self, *args, **kwargs):
801
old_checker = self.checker
802
if self.checker is not None:
803
old_checker_pid = self.checker.pid
805
old_checker_pid = None
806
r = Client.start_checker(self, *args, **kwargs)
807
# Only if new checker process was started
808
if (self.checker is not None
809
and old_checker_pid != self.checker.pid):
811
self.CheckerStarted(self.current_checker_command)
812
self.PropertyChanged(
813
dbus.String(u"checker_running"),
814
dbus.Boolean(True, variant_level=1))
817
def stop_checker(self, *args, **kwargs):
818
old_checker = getattr(self, u"checker", None)
819
r = Client.stop_checker(self, *args, **kwargs)
820
if (old_checker is not None
821
and getattr(self, u"checker", None) is None):
822
self.PropertyChanged(dbus.String(u"checker_running"),
823
dbus.Boolean(False, variant_level=1))
826
def _reset_approved(self):
827
self._approved = None
830
def approve(self, value=True):
831
self._approved = value
832
gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration, self._reset_approved))
835
## D-Bus methods, signals & properties
836
_interface = u"se.bsnet.fukt.Mandos.Client"
840
# CheckerCompleted - signal
841
@dbus.service.signal(_interface, signature=u"nxs")
842
def CheckerCompleted(self, exitcode, waitstatus, command):
846
# CheckerStarted - signal
847
@dbus.service.signal(_interface, signature=u"s")
848
def CheckerStarted(self, command):
852
# PropertyChanged - signal
853
@dbus.service.signal(_interface, signature=u"sv")
854
def PropertyChanged(self, property, value):
859
@dbus.service.signal(_interface)
865
@dbus.service.signal(_interface, signature=u"s")
866
def Rejected(self, reason):
870
# NeedApproval - signal
871
@dbus.service.signal(_interface, signature=u"db")
872
def NeedApproval(self, timeout, default):
879
@dbus.service.method(_interface, in_signature=u"b")
880
def Approve(self, value):
884
@dbus.service.method(_interface)
886
return self.checked_ok()
889
@dbus.service.method(_interface)
894
# StartChecker - method
895
@dbus.service.method(_interface)
896
def StartChecker(self):
901
@dbus.service.method(_interface)
906
# StopChecker - method
907
@dbus.service.method(_interface)
908
def StopChecker(self):
913
# approved_pending - property
914
@dbus_service_property(_interface, signature=u"b", access=u"read")
915
def approved_pending_dbus_property(self):
916
return dbus.Boolean(bool(self.approvals_pending))
918
# approved_by_default - property
919
@dbus_service_property(_interface, signature=u"b",
921
def approved_by_default_dbus_property(self):
922
return dbus.Boolean(self.approved_by_default)
924
# approved_delay - property
925
@dbus_service_property(_interface, signature=u"t",
927
def approved_delay_dbus_property(self):
928
return dbus.UInt64(self.approved_delay_milliseconds())
930
# approved_duration - property
931
@dbus_service_property(_interface, signature=u"t",
933
def approved_duration_dbus_property(self):
934
return dbus.UInt64(self._timedelta_to_milliseconds(
935
self.approved_duration))
938
@dbus_service_property(_interface, signature=u"s", access=u"read")
939
def name_dbus_property(self):
940
return dbus.String(self.name)
942
# fingerprint - property
943
@dbus_service_property(_interface, signature=u"s", access=u"read")
944
def fingerprint_dbus_property(self):
945
return dbus.String(self.fingerprint)
948
@dbus_service_property(_interface, signature=u"s",
950
def host_dbus_property(self, value=None):
951
if value is None: # get
952
return dbus.String(self.host)
955
self.PropertyChanged(dbus.String(u"host"),
956
dbus.String(value, variant_level=1))
959
@dbus_service_property(_interface, signature=u"s", access=u"read")
960
def created_dbus_property(self):
961
return dbus.String(self._datetime_to_dbus(self.created))
963
# last_enabled - property
964
@dbus_service_property(_interface, signature=u"s", access=u"read")
965
def last_enabled_dbus_property(self):
966
if self.last_enabled is None:
967
return dbus.String(u"")
968
return dbus.String(self._datetime_to_dbus(self.last_enabled))
971
@dbus_service_property(_interface, signature=u"b",
973
def enabled_dbus_property(self, value=None):
974
if value is None: # get
975
return dbus.Boolean(self.enabled)
981
# last_checked_ok - property
982
@dbus_service_property(_interface, signature=u"s",
984
def last_checked_ok_dbus_property(self, value=None):
985
if value is not None:
370
988
if self.last_checked_ok is None:
371
return now < (self.created + self.timeout)
373
return now < (self.last_checked_ok + self.timeout)
376
def peer_certificate(session):
377
"Return the peer's OpenPGP certificate as a bytestring"
378
# If not an OpenPGP certificate...
379
if gnutls.library.functions.gnutls_certificate_type_get\
380
(session._c_object) \
381
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
382
# ...do the normal thing
383
return session.peer_certificate
384
list_size = ctypes.c_uint()
385
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
386
(session._c_object, ctypes.byref(list_size))
387
if list_size.value == 0:
390
return ctypes.string_at(cert.data, cert.size)
393
def fingerprint(openpgp):
394
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
395
# New GnuTLS "datum" with the OpenPGP public key
396
datum = gnutls.library.types.gnutls_datum_t\
397
(ctypes.cast(ctypes.c_char_p(openpgp),
398
ctypes.POINTER(ctypes.c_ubyte)),
399
ctypes.c_uint(len(openpgp)))
400
# New empty GnuTLS certificate
401
crt = gnutls.library.types.gnutls_openpgp_crt_t()
402
gnutls.library.functions.gnutls_openpgp_crt_init\
404
# Import the OpenPGP public key into the certificate
405
gnutls.library.functions.gnutls_openpgp_crt_import\
406
(crt, ctypes.byref(datum),
407
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
408
# New buffer for the fingerprint
409
buffer = ctypes.create_string_buffer(20)
410
buffer_length = ctypes.c_size_t()
411
# Get the fingerprint from the certificate into the buffer
412
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
413
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
414
# Deinit the certificate
415
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
416
# Convert the buffer to a Python bytestring
417
fpr = ctypes.string_at(buffer, buffer_length.value)
418
# Convert the bytestring to hexadecimal notation
419
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
423
class tcp_handler(SocketServer.BaseRequestHandler, object):
424
"""A TCP request handler class.
425
Instantiated by IPv6_TCPServer for each request to handle it.
989
return dbus.String(u"")
990
return dbus.String(self._datetime_to_dbus(self
994
@dbus_service_property(_interface, signature=u"t",
996
def timeout_dbus_property(self, value=None):
997
if value is None: # get
998
return dbus.UInt64(self.timeout_milliseconds())
999
self.timeout = datetime.timedelta(0, 0, 0, value)
1001
self.PropertyChanged(dbus.String(u"timeout"),
1002
dbus.UInt64(value, variant_level=1))
1003
if getattr(self, u"disable_initiator_tag", None) is None:
1005
# Reschedule timeout
1006
gobject.source_remove(self.disable_initiator_tag)
1007
self.disable_initiator_tag = None
1008
time_to_die = (self.
1009
_timedelta_to_milliseconds((self
1014
if time_to_die <= 0:
1015
# The timeout has passed
1018
self.disable_initiator_tag = (gobject.timeout_add
1019
(time_to_die, self.disable))
1021
# interval - property
1022
@dbus_service_property(_interface, signature=u"t",
1023
access=u"readwrite")
1024
def interval_dbus_property(self, value=None):
1025
if value is None: # get
1026
return dbus.UInt64(self.interval_milliseconds())
1027
self.interval = datetime.timedelta(0, 0, 0, value)
1029
self.PropertyChanged(dbus.String(u"interval"),
1030
dbus.UInt64(value, variant_level=1))
1031
if getattr(self, u"checker_initiator_tag", None) is None:
1033
# Reschedule checker run
1034
gobject.source_remove(self.checker_initiator_tag)
1035
self.checker_initiator_tag = (gobject.timeout_add
1036
(value, self.start_checker))
1037
self.start_checker() # Start one now, too
1039
# checker - property
1040
@dbus_service_property(_interface, signature=u"s",
1041
access=u"readwrite")
1042
def checker_dbus_property(self, value=None):
1043
if value is None: # get
1044
return dbus.String(self.checker_command)
1045
self.checker_command = value
1047
self.PropertyChanged(dbus.String(u"checker"),
1048
dbus.String(self.checker_command,
1051
# checker_running - property
1052
@dbus_service_property(_interface, signature=u"b",
1053
access=u"readwrite")
1054
def checker_running_dbus_property(self, value=None):
1055
if value is None: # get
1056
return dbus.Boolean(self.checker is not None)
1058
self.start_checker()
1062
# object_path - property
1063
@dbus_service_property(_interface, signature=u"o", access=u"read")
1064
def object_path_dbus_property(self):
1065
return self.dbus_object_path # is already a dbus.ObjectPath
1068
@dbus_service_property(_interface, signature=u"ay",
1069
access=u"write", byte_arrays=True)
1070
def secret_dbus_property(self, value):
1071
self.secret = str(value)
1076
class ProxyClient(object):
1077
def __init__(self, child_pipe, fpr, address):
1078
self._pipe = child_pipe
1079
self._pipe.send(('init', fpr, address))
1080
if not self._pipe.recv():
1083
def __getattribute__(self, name):
1084
if(name == '_pipe'):
1085
return super(ProxyClient, self).__getattribute__(name)
1086
self._pipe.send(('getattr', name))
1087
data = self._pipe.recv()
1088
if data[0] == 'data':
1090
if data[0] == 'function':
1091
def func(*args, **kwargs):
1092
self._pipe.send(('funcall', name, args, kwargs))
1093
return self._pipe.recv()[1]
1096
def __setattr__(self, name, value):
1097
if(name == '_pipe'):
1098
return super(ProxyClient, self).__setattr__(name, value)
1099
self._pipe.send(('setattr', name, value))
1102
class ClientHandler(socketserver.BaseRequestHandler, object):
1103
"""A class to handle client connections.
1105
Instantiated once for each connection to handle it.
426
1106
Note: This will run in its own forked process."""
428
1108
def handle(self):
429
logger.info(u"TCP connection from: %s",
430
unicode(self.client_address))
431
session = gnutls.connection.ClientSession\
432
(self.request, gnutls.connection.X509Credentials())
434
line = self.request.makefile().readline()
435
logger.debug(u"Protocol version: %r", line)
437
if int(line.strip().split()[0]) > 1:
439
except (ValueError, IndexError, RuntimeError), error:
440
logger.error(u"Unknown protocol version: %s", error)
443
# Note: gnutls.connection.X509Credentials is really a generic
444
# GnuTLS certificate credentials object so long as no X.509
445
# keys are added to it. Therefore, we can use it here despite
446
# using OpenPGP certificates.
448
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
449
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
451
priority = "NORMAL" # Fallback default, since this
453
if self.server.settings["priority"]:
454
priority = self.server.settings["priority"]
455
gnutls.library.functions.gnutls_priority_set_direct\
456
(session._c_object, priority, None);
460
except gnutls.errors.GNUTLSError, error:
461
logger.warning(u"Handshake failed: %s", error)
462
# Do not run session.bye() here: the session is not
463
# established. Just abandon the request.
466
fpr = fingerprint(peer_certificate(session))
467
except (TypeError, gnutls.errors.GNUTLSError), error:
468
logger.warning(u"Bad certificate: %s", error)
471
logger.debug(u"Fingerprint: %s", fpr)
473
for c in self.server.clients:
474
if c.fingerprint == fpr:
478
logger.warning(u"Client not found for fingerprint: %s",
482
# Have to check if client.still_valid(), since it is possible
483
# that the client timed out while establishing the GnuTLS
485
if not client.still_valid():
486
logger.warning(u"Client %(name)s is invalid",
491
while sent_size < len(client.secret):
492
sent = session.send(client.secret[sent_size:])
493
logger.debug(u"Sent: %d, remaining: %d",
494
sent, len(client.secret)
495
- (sent_size + sent))
500
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
501
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1109
with contextlib.closing(self.server.child_pipe) as child_pipe:
1110
logger.info(u"TCP connection from: %s",
1111
unicode(self.client_address))
1112
logger.debug(u"Pipe FD: %d",
1113
self.server.child_pipe.fileno())
1115
session = (gnutls.connection
1116
.ClientSession(self.request,
1118
.X509Credentials()))
1120
# Note: gnutls.connection.X509Credentials is really a
1121
# generic GnuTLS certificate credentials object so long as
1122
# no X.509 keys are added to it. Therefore, we can use it
1123
# here despite using OpenPGP certificates.
1125
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1126
# u"+AES-256-CBC", u"+SHA1",
1127
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1129
# Use a fallback default, since this MUST be set.
1130
priority = self.server.gnutls_priority
1131
if priority is None:
1132
priority = u"NORMAL"
1133
(gnutls.library.functions
1134
.gnutls_priority_set_direct(session._c_object,
1137
# Start communication using the Mandos protocol
1138
# Get protocol number
1139
line = self.request.makefile().readline()
1140
logger.debug(u"Protocol version: %r", line)
1142
if int(line.strip().split()[0]) > 1:
1144
except (ValueError, IndexError, RuntimeError), error:
1145
logger.error(u"Unknown protocol version: %s", error)
1148
# Start GnuTLS connection
1151
except gnutls.errors.GNUTLSError, error:
1152
logger.warning(u"Handshake failed: %s", error)
1153
# Do not run session.bye() here: the session is not
1154
# established. Just abandon the request.
1156
logger.debug(u"Handshake succeeded")
1158
approval_required = False
1161
fpr = self.fingerprint(self.peer_certificate
1163
except (TypeError, gnutls.errors.GNUTLSError), error:
1164
logger.warning(u"Bad certificate: %s", error)
1166
logger.debug(u"Fingerprint: %s", fpr)
1169
client = ProxyClient(child_pipe, fpr,
1170
self.client_address)
1174
if client.approved_delay:
1175
delay = client.approved_delay
1176
client.approvals_pending += 1
1177
approval_required = True
1180
if not client.enabled:
1181
logger.warning(u"Client %s is disabled",
1183
if self.server.use_dbus:
1185
client.Rejected("Disabled")
1188
if client._approved or not client.approved_delay:
1189
#We are approved or approval is disabled
1191
elif client._approved is None:
1192
logger.info(u"Client %s need approval",
1194
if self.server.use_dbus:
1196
client.NeedApproval(
1197
client.approved_delay_milliseconds(),
1198
client.approved_by_default)
1200
logger.warning(u"Client %s was not approved",
1202
if self.server.use_dbus:
1204
client.Rejected("Disapproved")
1207
#wait until timeout or approved
1208
#x = float(client._timedelta_to_milliseconds(delay))
1209
time = datetime.datetime.now()
1210
client.changedstate.acquire()
1211
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
1212
client.changedstate.release()
1213
time2 = datetime.datetime.now()
1214
if (time2 - time) >= delay:
1215
if not client.approved_by_default:
1216
logger.warning("Client %s timed out while"
1217
" waiting for approval",
1219
if self.server.use_dbus:
1221
client.Rejected("Time out")
1226
delay -= time2 - time
1229
while sent_size < len(client.secret):
1230
# XXX handle session exception
1231
sent = session.send(client.secret[sent_size:])
1232
logger.debug(u"Sent: %d, remaining: %d",
1233
sent, len(client.secret)
1234
- (sent_size + sent))
1237
logger.info(u"Sending secret to %s", client.name)
1238
# bump the timeout as if seen
1240
if self.server.use_dbus:
1245
if approval_required:
1246
client.approvals_pending -= 1
1250
def peer_certificate(session):
1251
"Return the peer's OpenPGP certificate as a bytestring"
1252
# If not an OpenPGP certificate...
1253
if (gnutls.library.functions
1254
.gnutls_certificate_type_get(session._c_object)
1255
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1256
# ...do the normal thing
1257
return session.peer_certificate
1258
list_size = ctypes.c_uint(1)
1259
cert_list = (gnutls.library.functions
1260
.gnutls_certificate_get_peers
1261
(session._c_object, ctypes.byref(list_size)))
1262
if not bool(cert_list) and list_size.value != 0:
1263
raise gnutls.errors.GNUTLSError(u"error getting peer"
1265
if list_size.value == 0:
1268
return ctypes.string_at(cert.data, cert.size)
1271
def fingerprint(openpgp):
1272
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1273
# New GnuTLS "datum" with the OpenPGP public key
1274
datum = (gnutls.library.types
1275
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1278
ctypes.c_uint(len(openpgp))))
1279
# New empty GnuTLS certificate
1280
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1281
(gnutls.library.functions
1282
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1283
# Import the OpenPGP public key into the certificate
1284
(gnutls.library.functions
1285
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1286
gnutls.library.constants
1287
.GNUTLS_OPENPGP_FMT_RAW))
1288
# Verify the self signature in the key
1289
crtverify = ctypes.c_uint()
1290
(gnutls.library.functions
1291
.gnutls_openpgp_crt_verify_self(crt, 0,
1292
ctypes.byref(crtverify)))
1293
if crtverify.value != 0:
1294
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1295
raise (gnutls.errors.CertificateSecurityError
1297
# New buffer for the fingerprint
1298
buf = ctypes.create_string_buffer(20)
1299
buf_len = ctypes.c_size_t()
1300
# Get the fingerprint from the certificate into the buffer
1301
(gnutls.library.functions
1302
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1303
ctypes.byref(buf_len)))
1304
# Deinit the certificate
1305
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1306
# Convert the buffer to a Python bytestring
1307
fpr = ctypes.string_at(buf, buf_len.value)
1308
# Convert the bytestring to hexadecimal notation
1309
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1313
class MultiprocessingMixIn(object):
1314
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1315
def sub_process_main(self, request, address):
1317
self.finish_request(request, address)
1319
self.handle_error(request, address)
1320
self.close_request(request)
1322
def process_request(self, request, address):
1323
"""Start a new process to process the request."""
1324
multiprocessing.Process(target = self.sub_process_main,
1325
args = (request, address)).start()
1327
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1328
""" adds a pipe to the MixIn """
1329
def process_request(self, request, client_address):
1330
"""Overrides and wraps the original process_request().
1332
This function creates a new pipe in self.pipe
1334
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1336
super(MultiprocessingMixInWithPipe,
1337
self).process_request(request, client_address)
1338
self.add_pipe(parent_pipe)
1339
def add_pipe(self, parent_pipe):
1340
"""Dummy function; override as necessary"""
1343
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1344
socketserver.TCPServer, object):
1345
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
503
settings: Server settings
504
clients: Set() of Client objects
1348
enabled: Boolean; whether this server is activated yet
1349
interface: None or a network interface name (string)
1350
use_ipv6: Boolean; to use IPv6 or not
506
address_family = socket.AF_INET6
507
def __init__(self, *args, **kwargs):
508
if "settings" in kwargs:
509
self.settings = kwargs["settings"]
510
del kwargs["settings"]
511
if "clients" in kwargs:
512
self.clients = kwargs["clients"]
513
del kwargs["clients"]
514
return super(type(self), self).__init__(*args, **kwargs)
1352
def __init__(self, server_address, RequestHandlerClass,
1353
interface=None, use_ipv6=True):
1354
self.interface = interface
1356
self.address_family = socket.AF_INET6
1357
socketserver.TCPServer.__init__(self, server_address,
1358
RequestHandlerClass)
515
1359
def server_bind(self):
516
1360
"""This overrides the normal server_bind() function
517
1361
to bind to an interface if one was specified, and also NOT to
518
1362
bind to an address or port if they were not specified."""
519
if self.settings["interface"]:
520
# 25 is from /usr/include/asm-i486/socket.h
521
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
523
self.socket.setsockopt(socket.SOL_SOCKET,
525
self.settings["interface"])
526
except socket.error, error:
527
if error[0] == errno.EPERM:
528
logger.error(u"No permission to"
529
u" bind to interface %s",
530
self.settings["interface"])
1363
if self.interface is not None:
1364
if SO_BINDTODEVICE is None:
1365
logger.error(u"SO_BINDTODEVICE does not exist;"
1366
u" cannot bind to interface %s",
1370
self.socket.setsockopt(socket.SOL_SOCKET,
1374
except socket.error, error:
1375
if error[0] == errno.EPERM:
1376
logger.error(u"No permission to"
1377
u" bind to interface %s",
1379
elif error[0] == errno.ENOPROTOOPT:
1380
logger.error(u"SO_BINDTODEVICE not available;"
1381
u" cannot bind to interface %s",
533
1385
# Only bind(2) the socket if we really need to.
534
1386
if self.server_address[0] or self.server_address[1]:
535
1387
if not self.server_address[0]:
537
self.server_address = (in6addr_any,
1388
if self.address_family == socket.AF_INET6:
1389
any_address = u"::" # in6addr_any
1391
any_address = socket.INADDR_ANY
1392
self.server_address = (any_address,
538
1393
self.server_address[1])
539
1394
elif not self.server_address[1]:
540
1395
self.server_address = (self.server_address[0],
542
# if self.settings["interface"]:
1397
# if self.interface:
543
1398
# self.server_address = (self.server_address[0],
546
1401
# if_nametoindex
549
return super(type(self), self).server_bind()
1403
return socketserver.TCPServer.server_bind(self)
1406
class MandosServer(IPv6_TCPServer):
1410
clients: set of Client objects
1411
gnutls_priority GnuTLS priority string
1412
use_dbus: Boolean; to emit D-Bus signals or not
1414
Assumes a gobject.MainLoop event loop.
1416
def __init__(self, server_address, RequestHandlerClass,
1417
interface=None, use_ipv6=True, clients=None,
1418
gnutls_priority=None, use_dbus=True):
1419
self.enabled = False
1420
self.clients = clients
1421
if self.clients is None:
1422
self.clients = set()
1423
self.use_dbus = use_dbus
1424
self.gnutls_priority = gnutls_priority
1425
IPv6_TCPServer.__init__(self, server_address,
1426
RequestHandlerClass,
1427
interface = interface,
1428
use_ipv6 = use_ipv6)
1429
def server_activate(self):
1431
return socketserver.TCPServer.server_activate(self)
1434
def add_pipe(self, parent_pipe):
1435
# Call "handle_ipc" for both data and EOF events
1436
gobject.io_add_watch(parent_pipe.fileno(),
1437
gobject.IO_IN | gobject.IO_HUP,
1438
functools.partial(self.handle_ipc,
1439
parent_pipe = parent_pipe))
1441
def handle_ipc(self, source, condition, parent_pipe=None,
1442
client_object=None):
1444
gobject.IO_IN: u"IN", # There is data to read.
1445
gobject.IO_OUT: u"OUT", # Data can be written (without
1447
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1448
gobject.IO_ERR: u"ERR", # Error condition.
1449
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1450
# broken, usually for pipes and
1453
conditions_string = ' | '.join(name
1455
condition_names.iteritems()
1456
if cond & condition)
1457
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1460
# Read a request from the child
1461
request = parent_pipe.recv()
1462
command = request[0]
1464
if command == 'init':
1466
address = request[2]
1468
for c in self.clients:
1469
if c.fingerprint == fpr:
1473
logger.warning(u"Client not found for fingerprint: %s, ad"
1474
u"dress: %s", fpr, address)
1477
mandos_dbus_service.ClientNotFound(fpr, address)
1478
parent_pipe.send(False)
1481
gobject.io_add_watch(parent_pipe.fileno(),
1482
gobject.IO_IN | gobject.IO_HUP,
1483
functools.partial(self.handle_ipc,
1484
parent_pipe = parent_pipe,
1485
client_object = client))
1486
parent_pipe.send(True)
1487
# remove the old hook in favor of the new above hook on same fileno
1489
if command == 'funcall':
1490
funcname = request[1]
1494
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1496
if command == 'getattr':
1497
attrname = request[1]
1498
if callable(client_object.__getattribute__(attrname)):
1499
parent_pipe.send(('function',))
1501
parent_pipe.send(('data', client_object.__getattribute__(attrname)))
1503
if command == 'setattr':
1504
attrname = request[1]
1506
setattr(client_object, attrname, value)
552
1511
def string_to_delta(interval):
553
1512
"""Parse a string and return a datetime.timedelta
555
>>> string_to_delta('7d')
1514
>>> string_to_delta(u'7d')
556
1515
datetime.timedelta(7)
557
>>> string_to_delta('60s')
1516
>>> string_to_delta(u'60s')
558
1517
datetime.timedelta(0, 60)
559
>>> string_to_delta('60m')
1518
>>> string_to_delta(u'60m')
560
1519
datetime.timedelta(0, 3600)
561
>>> string_to_delta('24h')
1520
>>> string_to_delta(u'24h')
562
1521
datetime.timedelta(1)
563
1522
>>> string_to_delta(u'1w')
564
1523
datetime.timedelta(7)
1524
>>> string_to_delta(u'5m 30s')
1525
datetime.timedelta(0, 330)
567
suffix=unicode(interval[-1])
568
value=int(interval[:-1])
570
delta = datetime.timedelta(value)
572
delta = datetime.timedelta(0, value)
574
delta = datetime.timedelta(0, 0, 0, 0, value)
576
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
578
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
581
except (ValueError, IndexError):
586
def server_state_changed(state):
587
"""Derived from the Avahi example code"""
588
if state == avahi.SERVER_COLLISION:
589
logger.error(u"Server name collision")
591
elif state == avahi.SERVER_RUNNING:
595
def entry_group_state_changed(state, error):
596
"""Derived from the Avahi example code"""
597
logger.debug(u"state change: %i", state)
599
if state == avahi.ENTRY_GROUP_ESTABLISHED:
600
logger.debug(u"Service established.")
601
elif state == avahi.ENTRY_GROUP_COLLISION:
602
logger.warning(u"Service name collision.")
604
elif state == avahi.ENTRY_GROUP_FAILURE:
605
logger.critical(u"Error in group state changed %s",
607
raise AvahiGroupError("State changed: %s", str(error))
1527
timevalue = datetime.timedelta(0)
1528
for s in interval.split():
1530
suffix = unicode(s[-1])
1533
delta = datetime.timedelta(value)
1534
elif suffix == u"s":
1535
delta = datetime.timedelta(0, value)
1536
elif suffix == u"m":
1537
delta = datetime.timedelta(0, 0, 0, 0, value)
1538
elif suffix == u"h":
1539
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1540
elif suffix == u"w":
1541
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1543
raise ValueError(u"Unknown suffix %r" % suffix)
1544
except (ValueError, IndexError), e:
1545
raise ValueError(e.message)
609
1550
def if_nametoindex(interface):
610
"""Call the C function if_nametoindex(), or equivalent"""
1551
"""Call the C function if_nametoindex(), or equivalent
1553
Note: This function cannot accept a unicode string."""
611
1554
global if_nametoindex
613
if "ctypes.util" not in sys.modules:
615
if_nametoindex = ctypes.cdll.LoadLibrary\
616
(ctypes.util.find_library("c")).if_nametoindex
1556
if_nametoindex = (ctypes.cdll.LoadLibrary
1557
(ctypes.util.find_library(u"c"))
617
1559
except (OSError, AttributeError):
618
if "struct" not in sys.modules:
620
if "fcntl" not in sys.modules:
1560
logger.warning(u"Doing if_nametoindex the hard way")
622
1561
def if_nametoindex(interface):
623
1562
"Get an interface index the hard way, i.e. using fcntl()"
624
1563
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
626
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
627
struct.pack("16s16x", interface))
629
interface_index = struct.unpack("I", ifreq[16:20])[0]
1564
with contextlib.closing(socket.socket()) as s:
1565
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1566
struct.pack(str(u"16s16x"),
1568
interface_index = struct.unpack(str(u"I"),
630
1570
return interface_index
631
1571
return if_nametoindex(interface)
634
1574
def daemon(nochdir = False, noclose = False):
635
1575
"""See daemon(3). Standard BSD Unix function.
636
1577
This should really exist as os.daemon, but it doesn't (yet)."""
688
1636
# Default values for config file for server-global settings
689
server_defaults = { "interface": "",
694
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
695
"servicename": "Mandos",
1637
server_defaults = { u"interface": u"",
1642
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1643
u"servicename": u"Mandos",
1644
u"use_dbus": u"True",
1645
u"use_ipv6": u"True",
698
1648
# Parse config file for server-global settings
699
server_config = ConfigParser.SafeConfigParser(server_defaults)
1649
server_config = configparser.SafeConfigParser(server_defaults)
700
1650
del server_defaults
701
server_config.read(os.path.join(options.configdir, "mandos.conf"))
702
server_section = "server"
1651
server_config.read(os.path.join(options.configdir,
703
1653
# Convert the SafeConfigParser object to a dict
704
server_settings = dict(server_config.items(server_section))
705
# Use getboolean on the boolean config option
706
server_settings["debug"] = server_config.getboolean\
707
(server_section, "debug")
1654
server_settings = server_config.defaults()
1655
# Use the appropriate methods on the non-string config options
1656
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1657
server_settings[option] = server_config.getboolean(u"DEFAULT",
1659
if server_settings["port"]:
1660
server_settings["port"] = server_config.getint(u"DEFAULT",
708
1662
del server_config
710
1664
# Override the settings from the config file with command line
711
1665
# options, if set.
712
for option in ("interface", "address", "port", "debug",
713
"priority", "servicename", "configdir"):
1666
for option in (u"interface", u"address", u"port", u"debug",
1667
u"priority", u"servicename", u"configdir",
1668
u"use_dbus", u"use_ipv6"):
714
1669
value = getattr(options, option)
715
1670
if value is not None:
716
1671
server_settings[option] = value
1673
# Force all strings to be unicode
1674
for option in server_settings.keys():
1675
if type(server_settings[option]) is str:
1676
server_settings[option] = unicode(server_settings[option])
718
1677
# Now we have our good server settings in "server_settings"
720
debug = server_settings["debug"]
1679
##################################################################
1682
debug = server_settings[u"debug"]
1683
use_dbus = server_settings[u"use_dbus"]
1684
use_ipv6 = server_settings[u"use_ipv6"]
723
1687
syslogger.setLevel(logging.WARNING)
724
1688
console.setLevel(logging.WARNING)
726
if server_settings["servicename"] != "Mandos":
727
syslogger.setFormatter(logging.Formatter\
728
('Mandos (%s): %%(levelname)s:'
730
% server_settings["servicename"]))
1690
if server_settings[u"servicename"] != u"Mandos":
1691
syslogger.setFormatter(logging.Formatter
1692
(u'Mandos (%s) [%%(process)d]:'
1693
u' %%(levelname)s: %%(message)s'
1694
% server_settings[u"servicename"]))
732
1696
# Parse config file with clients
733
client_defaults = { "timeout": "1h",
735
"checker": "fping -q -- %%(host)s",
1697
client_defaults = { u"timeout": u"1h",
1699
u"checker": u"fping -q -- %%(host)s",
1701
u"approved_delay": u"0s",
1702
u"approved_duration": u"1s",
737
client_config = ConfigParser.SafeConfigParser(client_defaults)
738
client_config.read(os.path.join(server_settings["configdir"],
742
service = AvahiService(name = server_settings["servicename"],
743
type = "_mandos._tcp", );
744
if server_settings["interface"]:
745
service.interface = if_nametoindex(server_settings["interface"])
1704
client_config = configparser.SafeConfigParser(client_defaults)
1705
client_config.read(os.path.join(server_settings[u"configdir"],
1708
global mandos_dbus_service
1709
mandos_dbus_service = None
1711
tcp_server = MandosServer((server_settings[u"address"],
1712
server_settings[u"port"]),
1714
interface=server_settings[u"interface"],
1717
server_settings[u"priority"],
1719
pidfilename = u"/var/run/mandos.pid"
1721
pidfile = open(pidfilename, u"w")
1723
logger.error(u"Could not open file %r", pidfilename)
1726
uid = pwd.getpwnam(u"_mandos").pw_uid
1727
gid = pwd.getpwnam(u"_mandos").pw_gid
1730
uid = pwd.getpwnam(u"mandos").pw_uid
1731
gid = pwd.getpwnam(u"mandos").pw_gid
1734
uid = pwd.getpwnam(u"nobody").pw_uid
1735
gid = pwd.getpwnam(u"nobody").pw_gid
1742
except OSError, error:
1743
if error[0] != errno.EPERM:
1746
# Enable all possible GnuTLS debugging
1748
# "Use a log level over 10 to enable all debugging options."
1750
gnutls.library.functions.gnutls_global_set_log_level(11)
1752
@gnutls.library.types.gnutls_log_func
1753
def debug_gnutls(level, string):
1754
logger.debug(u"GnuTLS: %s", string[:-1])
1756
(gnutls.library.functions
1757
.gnutls_global_set_log_function(debug_gnutls))
747
1759
global main_loop
750
1760
# From the Avahi example code
751
1761
DBusGMainLoop(set_as_default=True )
752
1762
main_loop = gobject.MainLoop()
753
1763
bus = dbus.SystemBus()
754
server = dbus.Interface(
755
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
756
avahi.DBUS_INTERFACE_SERVER )
757
1764
# End of Avahi example code
760
def remove_from_clients(client):
761
clients.remove(client)
763
logger.critical(u"No clients left, exiting")
766
clients.update(Set(Client(name = section,
767
stop_hook = remove_from_clients,
769
= dict(client_config.items(section)))
770
for section in client_config.sections()))
772
logger.critical(u"No clients defined")
1767
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1768
bus, do_not_queue=True)
1769
except dbus.exceptions.NameExistsException, e:
1770
logger.error(unicode(e) + u", disabling D-Bus")
1772
server_settings[u"use_dbus"] = False
1773
tcp_server.use_dbus = False
1774
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1775
service = AvahiService(name = server_settings[u"servicename"],
1776
servicetype = u"_mandos._tcp",
1777
protocol = protocol, bus = bus)
1778
if server_settings["interface"]:
1779
service.interface = (if_nametoindex
1780
(str(server_settings[u"interface"])))
1782
client_class = Client
1784
client_class = functools.partial(ClientDBus, bus = bus)
1785
def client_config_items(config, section):
1786
special_settings = {
1787
"approved_by_default":
1788
lambda: config.getboolean(section,
1789
"approved_by_default"),
1791
for name, value in config.items(section):
1793
yield (name, special_settings[name]())
1797
tcp_server.clients.update(set(
1798
client_class(name = section,
1799
config= dict(client_config_items(
1800
client_config, section)))
1801
for section in client_config.sections()))
1802
if not tcp_server.clients:
1803
logger.warning(u"No clients defined")
1806
# Redirect stdin so all checkers get /dev/null
1807
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1808
os.dup2(null, sys.stdin.fileno())
1812
# No console logging
776
1813
logger.removeHandler(console)
1814
# Close all input and output, do double fork, etc.
779
pidfilename = "/var/run/mandos/mandos.pid"
782
pidfile = open(pidfilename, "w")
783
pidfile.write(str(pid) + "\n")
1820
pidfile.write(str(pid) + "\n")
787
logger.error(u"Could not write %s file with PID %d",
788
pidfilename, os.getpid())
1823
logger.error(u"Could not write to file %r with PID %d",
1826
# "pidfile" was never created
1831
signal.signal(signal.SIGINT, signal.SIG_IGN)
1832
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1833
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1836
class MandosDBusService(dbus.service.Object):
1837
"""A D-Bus proxy object"""
1839
dbus.service.Object.__init__(self, bus, u"/")
1840
_interface = u"se.bsnet.fukt.Mandos"
1842
@dbus.service.signal(_interface, signature=u"o")
1843
def ClientAdded(self, objpath):
1847
@dbus.service.signal(_interface, signature=u"ss")
1848
def ClientNotFound(self, fingerprint, address):
1852
@dbus.service.signal(_interface, signature=u"os")
1853
def ClientRemoved(self, objpath, name):
1857
@dbus.service.method(_interface, out_signature=u"ao")
1858
def GetAllClients(self):
1860
return dbus.Array(c.dbus_object_path
1861
for c in tcp_server.clients)
1863
@dbus.service.method(_interface,
1864
out_signature=u"a{oa{sv}}")
1865
def GetAllClientsWithProperties(self):
1867
return dbus.Dictionary(
1868
((c.dbus_object_path, c.GetAll(u""))
1869
for c in tcp_server.clients),
1870
signature=u"oa{sv}")
1872
@dbus.service.method(_interface, in_signature=u"o")
1873
def RemoveClient(self, object_path):
1875
for c in tcp_server.clients:
1876
if c.dbus_object_path == object_path:
1877
tcp_server.clients.remove(c)
1878
c.remove_from_connection()
1879
# Don't signal anything except ClientRemoved
1880
c.disable(quiet=True)
1882
self.ClientRemoved(object_path, c.name)
1884
raise KeyError(object_path)
1888
mandos_dbus_service = MandosDBusService()
791
1891
"Cleanup function; run on exit"
793
# From the Avahi example code
794
if not group is None:
797
# End of Avahi example code
800
client = clients.pop()
801
client.stop_hook = None
1894
while tcp_server.clients:
1895
client = tcp_server.clients.pop()
1897
client.remove_from_connection()
1898
client.disable_hook = None
1899
# Don't signal anything except ClientRemoved
1900
client.disable(quiet=True)
1903
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
804
1906
atexit.register(cleanup)
807
signal.signal(signal.SIGINT, signal.SIG_IGN)
808
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
809
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
811
for client in clients:
814
tcp_server = IPv6_TCPServer((server_settings["address"],
815
server_settings["port"]),
817
settings=server_settings,
1908
for client in tcp_server.clients:
1911
mandos_dbus_service.ClientAdded(client.dbus_object_path)
1915
tcp_server.server_activate()
819
1917
# Find out what port we got
820
1918
service.port = tcp_server.socket.getsockname()[1]
821
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
822
u" scope_id %d" % tcp_server.socket.getsockname())
1920
logger.info(u"Now listening on address %r, port %d,"
1921
" flowinfo %d, scope_id %d"
1922
% tcp_server.socket.getsockname())
1924
logger.info(u"Now listening on address %r, port %d"
1925
% tcp_server.socket.getsockname())
824
1927
#service.interface = tcp_server.socket.getsockname()[3]
827
1930
# From the Avahi example code
828
server.connect_to_signal("StateChanged", server_state_changed)
830
server_state_changed(server.GetState())
831
1933
except dbus.exceptions.DBusException, error:
832
1934
logger.critical(u"DBusException: %s", error)
834
1937
# End of Avahi example code
836
1939
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
837
1940
lambda *args, **kwargs:
838
tcp_server.handle_request\
839
(*args[2:], **kwargs) or True)
1941
(tcp_server.handle_request
1942
(*args[2:], **kwargs) or True))
841
1944
logger.debug(u"Starting main loop")
842
main_loop_started = True
844
1946
except AvahiError, error:
845
logger.critical(u"AvahiError: %s" + unicode(error))
1947
logger.critical(u"AvahiError: %s", error)
847
1950
except KeyboardInterrupt:
1953
logger.debug(u"Server received KeyboardInterrupt")
1954
logger.debug(u"Server exiting")
1955
# Must run before the D-Bus bus name gets deregistered
851
1958
if __name__ == '__main__':