130
104
max_renames: integer; maximum number of renames
131
105
rename_count: integer; counter so we only rename after collisions
132
106
a sensible number of times
133
group: D-Bus Entry Group
135
bus: dbus.SystemBus()
137
108
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
138
servicetype = None, port = None, TXT = None,
139
domain = u"", host = u"", max_renames = 32768,
140
protocol = avahi.PROTO_UNSPEC, bus = None):
109
type = None, port = None, TXT = None, domain = "",
110
host = "", max_renames = 32768):
141
111
self.interface = interface
143
self.type = servicetype
145
self.TXT = TXT if TXT is not None else []
146
119
self.domain = domain
148
121
self.rename_count = 0
149
122
self.max_renames = max_renames
150
self.protocol = protocol
151
self.group = None # our entry group
154
123
def rename(self):
155
124
"""Derived from the Avahi example code"""
156
125
if self.rename_count >= self.max_renames:
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'
126
logger.critical(u"No suitable service name found after %i"
127
u" retries, exiting.", rename_count)
128
raise AvahiServiceError("Too many renames")
129
self.name = server.GetAlternativeServiceName(self.name)
130
logger.info(u"Changing name to %r ...", str(self.name))
131
syslogger.setFormatter(logging.Formatter\
132
('Mandos (%s): %%(levelname)s:'
133
' %%(message)s' % self.name))
170
136
self.rename_count += 1
171
137
def remove(self):
172
138
"""Derived from the Avahi example code"""
173
if self.group is not None:
139
if group is not None:
176
142
"""Derived from the 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())
145
group = dbus.Interface\
146
(bus.get_object(avahi.DBUS_NAME,
147
server.EntryGroupNew()),
148
avahi.DBUS_INTERFACE_ENTRY_GROUP)
149
group.connect_to_signal('StateChanged',
150
entry_group_state_changed)
151
logger.debug(u"Adding service '%s' of type '%s' ...",
152
service.name, service.type)
154
self.interface, # interface
155
avahi.PROTO_INET6, # protocol
156
dbus.UInt32(0), # flags
157
self.name, self.type,
158
self.domain, self.host,
159
dbus.UInt16(self.port),
160
avahi.string_array_to_txt_array(self.TXT))
163
# From the Avahi example code:
164
group = None # our entry group
165
# End of Avahi example code
234
168
class Client(object):
235
169
"""A representation of a client host served by this server.
238
name: string; from the config file, used in log messages and
171
name: string; from the config file, used in log messages
240
172
fingerprint: string (40 or 32 hexadecimal digits); used to
241
173
uniquely identify the client
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.
174
secret: bytestring; sent verbatim (over TLS) to client
175
host: string; available for use by the checker command
176
created: datetime.datetime(); object creation, not client host
177
last_checked_ok: datetime.datetime() or None if not yet checked OK
178
timeout: datetime.timedelta(); How long from last_checked_ok
179
until this client is invalid
180
interval: datetime.timedelta(); How often to start a new checker
181
stop_hook: If set, called by stop() as stop_hook(self)
182
checker: subprocess.Popen(); a running checker process used
183
to see if the client lives.
184
'None' if no process is running.
255
185
checker_initiator_tag: a gobject event source tag, or None
256
disable_initiator_tag: - '' -
186
stop_initiator_tag: - '' -
257
187
checker_callback_tag: - '' -
258
188
checker_command: string; External command which is run to check if
259
189
client lives. %() expansions are done at
260
190
runtime with vars(self) as dict, so that for
261
191
instance %(name)s can be used in the command.
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
193
_timeout: Real variable for 'timeout'
194
_interval: Real variable for 'interval'
195
_timeout_milliseconds: Used when calling gobject.timeout_add()
196
_interval_milliseconds: - '' -
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):
198
def _set_timeout(self, timeout):
199
"Setter function for 'timeout' attribute"
200
self._timeout = timeout
201
self._timeout_milliseconds = ((self.timeout.days
202
* 24 * 60 * 60 * 1000)
203
+ (self.timeout.seconds * 1000)
204
+ (self.timeout.microseconds
206
timeout = property(lambda self: self._timeout,
209
def _set_interval(self, interval):
210
"Setter function for 'interval' attribute"
211
self._interval = interval
212
self._interval_milliseconds = ((self.interval.days
213
* 24 * 60 * 60 * 1000)
214
+ (self.interval.seconds
216
+ (self.interval.microseconds
218
interval = property(lambda self: self._interval,
221
def __init__(self, name = None, stop_hook=None, config={}):
287
222
"""Note: the 'checker' key in 'config' sets the
288
223
'checker_command' attribute and *not* the 'checker'
293
226
logger.debug(u"Creating client %r", self.name)
294
227
# Uppercase and remove spaces from fingerprint for later
295
228
# comparison purposes with return value from the fingerprint()
297
self.fingerprint = (config[u"fingerprint"].upper()
230
self.fingerprint = config["fingerprint"].upper()\
299
232
logger.debug(u" Fingerprint: %s", self.fingerprint)
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()
233
if "secret" in config:
234
self.secret = config["secret"].decode(u"base64")
235
elif "secfile" in config:
236
sf = open(config["secfile"])
237
self.secret = sf.read()
308
#XXX Need to allow secret on demand!
309
240
raise TypeError(u"No secret or secfile for client %s"
311
self.host = config.get(u"host", u"")
312
self.created = datetime.datetime.utcnow()
314
self.last_enabled = None
242
self.host = config.get("host", "")
243
self.created = datetime.datetime.now()
315
244
self.last_checked_ok = None
316
self.timeout = string_to_delta(config[u"timeout"])
317
self.interval = string_to_delta(config[u"interval"])
318
self.disable_hook = disable_hook
245
self.timeout = string_to_delta(config["timeout"])
246
self.interval = string_to_delta(config["interval"])
247
self.stop_hook = stop_hook
319
248
self.checker = None
320
249
self.checker_initiator_tag = None
321
self.disable_initiator_tag = None
250
self.stop_initiator_tag = None
322
251
self.checker_callback_tag = None
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()
252
self.check_command = config["checker"]
342
254
"""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()
348
255
# Schedule a new checker to be started an 'interval' from now,
349
256
# and every interval from then on.
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(),
257
self.checker_initiator_tag = gobject.timeout_add\
258
(self._interval_milliseconds,
358
260
# Also start a new checker *right now*.
359
261
self.start_checker()
361
def disable(self, quiet=True):
362
"""Disable this client."""
363
if not getattr(self, "enabled", False):
262
# Schedule a stop() when 'timeout' has passed
263
self.stop_initiator_tag = gobject.timeout_add\
264
(self._timeout_milliseconds,
268
The possibility that a client might be restarted is left open,
269
but not currently used."""
270
# If this client doesn't have a secret, it is already stopped.
271
if hasattr(self, "secret") and self.secret:
272
logger.info(u"Stopping client %s", self.name)
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):
276
if getattr(self, "stop_initiator_tag", False):
277
gobject.source_remove(self.stop_initiator_tag)
278
self.stop_initiator_tag = None
279
if getattr(self, "checker_initiator_tag", False):
373
280
gobject.source_remove(self.checker_initiator_tag)
374
281
self.checker_initiator_tag = None
375
282
self.stop_checker()
376
if self.disable_hook:
377
self.disable_hook(self)
379
285
# Do not run this again if called by a gobject.timeout_add
382
287
def __del__(self):
383
self.disable_hook = None
386
def checker_callback(self, pid, condition, command):
288
self.stop_hook = None
290
def checker_callback(self, pid, condition):
387
291
"""The checker has completed, so take appropriate actions."""
292
now = datetime.datetime.now()
388
293
self.checker_callback_tag = None
389
294
self.checker = None
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",
295
if os.WIFEXITED(condition) \
296
and (os.WEXITSTATUS(condition) == 0):
297
logger.info(u"Checker for %(name)s succeeded",
299
self.last_checked_ok = now
300
gobject.source_remove(self.stop_initiator_tag)
301
self.stop_initiator_tag = gobject.timeout_add\
302
(self._timeout_milliseconds,
304
elif not os.WIFEXITED(condition):
400
305
logger.warning(u"Checker for %(name)s crashed?",
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(),
308
logger.info(u"Checker for %(name)s failed",
415
310
def start_checker(self):
416
311
"""Start a new checker subprocess if one is not running.
418
312
If a checker already exists, leave it running and do
420
314
# The reason for not killing a running checker is that if we
423
317
# client would inevitably timeout, since no checker would get
424
318
# a chance to run to completion. If we instead leave running
425
319
# checkers alone, the checker would have to take more time
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
320
# than 'timeout' for the client to be declared invalid, which
321
# is as it should be.
443
322
if self.checker is None:
445
# In case checker_command has exactly one % operator
446
command = self.checker_command % self.host
324
# In case check_command has exactly one % operator
325
command = self.check_command % self.host
447
326
except TypeError:
448
327
# Escape attributes for the shell
449
escaped_attrs = dict((key,
450
re.escape(unicode(str(val),
328
escaped_attrs = dict((key, re.escape(str(val)))
454
330
vars(self).iteritems())
456
command = self.checker_command % escaped_attrs
332
command = self.check_command % escaped_attrs
457
333
except TypeError, error:
458
334
logger.error(u'Could not format string "%s":'
459
u' %s', self.checker_command, error)
335
u' %s', self.check_command, error)
460
336
return True # Try again later
461
self.current_checker_command = command
463
338
logger.info(u"Starting checker %r for %s",
464
339
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.)
469
340
self.checker = subprocess.Popen(command,
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:
343
self.checker_callback_tag = gobject.child_watch_add\
345
self.checker_callback)
346
except subprocess.OSError, error:
483
347
logger.error(u"Failed to start subprocess: %s",
485
349
# Re-run this periodically if run by gobject.timeout_add
488
351
def stop_checker(self):
489
352
"""Force the checker process, if any, to stop."""
490
353
if self.checker_callback_tag:
491
354
gobject.source_remove(self.checker_callback_tag)
492
355
self.checker_callback_tag = None
493
if getattr(self, u"checker", None) is None:
356
if getattr(self, "checker", None) is None:
495
358
logger.debug(u"Stopping checker for %(name)s", vars(self))
497
360
os.kill(self.checker.pid, signal.SIGTERM)
499
362
#if self.checker.poll() is None:
500
363
# os.kill(self.checker.pid, signal.SIGKILL)
501
364
except OSError, error:
502
365
if error.errno != errno.ESRCH: # No such process
504
367
self.checker = None
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:
368
def still_valid(self):
369
"""Has the timeout not yet passed for this client?"""
370
now = datetime.datetime.now()
988
371
if self.last_checked_ok is None:
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.
372
return now < (self.created + self.timeout)
374
return now < (self.last_checked_ok + self.timeout)
377
def peer_certificate(session):
378
"Return the peer's OpenPGP certificate as a bytestring"
379
# If not an OpenPGP certificate...
380
if gnutls.library.functions.gnutls_certificate_type_get\
381
(session._c_object) \
382
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
383
# ...do the normal thing
384
return session.peer_certificate
385
list_size = ctypes.c_uint()
386
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
387
(session._c_object, ctypes.byref(list_size))
388
if list_size.value == 0:
391
return ctypes.string_at(cert.data, cert.size)
394
def fingerprint(openpgp):
395
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
396
# New GnuTLS "datum" with the OpenPGP public key
397
datum = gnutls.library.types.gnutls_datum_t\
398
(ctypes.cast(ctypes.c_char_p(openpgp),
399
ctypes.POINTER(ctypes.c_ubyte)),
400
ctypes.c_uint(len(openpgp)))
401
# New empty GnuTLS certificate
402
crt = gnutls.library.types.gnutls_openpgp_crt_t()
403
gnutls.library.functions.gnutls_openpgp_crt_init\
405
# Import the OpenPGP public key into the certificate
406
gnutls.library.functions.gnutls_openpgp_crt_import\
407
(crt, ctypes.byref(datum),
408
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
409
# New buffer for the fingerprint
410
buffer = ctypes.create_string_buffer(20)
411
buffer_length = ctypes.c_size_t()
412
# Get the fingerprint from the certificate into the buffer
413
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
414
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
415
# Deinit the certificate
416
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
417
# Convert the buffer to a Python bytestring
418
fpr = ctypes.string_at(buffer, buffer_length.value)
419
# Convert the bytestring to hexadecimal notation
420
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
424
class tcp_handler(SocketServer.BaseRequestHandler, object):
425
"""A TCP request handler class.
426
Instantiated by IPv6_TCPServer for each request to handle it.
1106
427
Note: This will run in its own forked process."""
1108
429
def handle(self):
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
430
logger.info(u"TCP connection from: %s",
431
unicode(self.client_address))
432
session = gnutls.connection.ClientSession\
433
(self.request, gnutls.connection.X509Credentials())
435
line = self.request.makefile().readline()
436
logger.debug(u"Protocol version: %r", line)
438
if int(line.strip().split()[0]) > 1:
440
except (ValueError, IndexError, RuntimeError), error:
441
logger.error(u"Unknown protocol version: %s", error)
444
# Note: gnutls.connection.X509Credentials is really a generic
445
# GnuTLS certificate credentials object so long as no X.509
446
# keys are added to it. Therefore, we can use it here despite
447
# using OpenPGP certificates.
449
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
450
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
452
priority = "NORMAL" # Fallback default, since this
454
if self.server.settings["priority"]:
455
priority = self.server.settings["priority"]
456
gnutls.library.functions.gnutls_priority_set_direct\
457
(session._c_object, priority, None);
461
except gnutls.errors.GNUTLSError, error:
462
logger.warning(u"Handshake failed: %s", error)
463
# Do not run session.bye() here: the session is not
464
# established. Just abandon the request.
467
fpr = fingerprint(peer_certificate(session))
468
except (TypeError, gnutls.errors.GNUTLSError), error:
469
logger.warning(u"Bad certificate: %s", error)
472
logger.debug(u"Fingerprint: %s", fpr)
474
for c in self.server.clients:
475
if c.fingerprint == fpr:
479
logger.warning(u"Client not found for fingerprint: %s",
483
# Have to check if client.still_valid(), since it is possible
484
# that the client timed out while establishing the GnuTLS
486
if not client.still_valid():
487
logger.warning(u"Client %(name)s is invalid",
492
while sent_size < len(client.secret):
493
sent = session.send(client.secret[sent_size:])
494
logger.debug(u"Sent: %d, remaining: %d",
495
sent, len(client.secret)
496
- (sent_size + sent))
501
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
502
"""IPv6 TCP server. Accepts 'None' as address and/or port.
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
504
settings: Server settings
505
clients: Set() of Client objects
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)
507
address_family = socket.AF_INET6
508
def __init__(self, *args, **kwargs):
509
if "settings" in kwargs:
510
self.settings = kwargs["settings"]
511
del kwargs["settings"]
512
if "clients" in kwargs:
513
self.clients = kwargs["clients"]
514
del kwargs["clients"]
515
return super(type(self), self).__init__(*args, **kwargs)
1359
516
def server_bind(self):
1360
517
"""This overrides the normal server_bind() function
1361
518
to bind to an interface if one was specified, and also NOT to
1362
519
bind to an address or port if they were not specified."""
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",
520
if self.settings["interface"]:
521
# 25 is from /usr/include/asm-i486/socket.h
522
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
524
self.socket.setsockopt(socket.SOL_SOCKET,
526
self.settings["interface"])
527
except socket.error, error:
528
if error[0] == errno.EPERM:
529
logger.error(u"No permission to"
530
u" bind to interface %s",
531
self.settings["interface"])
1385
534
# Only bind(2) the socket if we really need to.
1386
535
if self.server_address[0] or self.server_address[1]:
1387
536
if not self.server_address[0]:
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
self.server_address = (in6addr_any,
1393
539
self.server_address[1])
1394
540
elif not self.server_address[1]:
1395
541
self.server_address = (self.server_address[0],
1397
# if self.interface:
543
# if self.settings["interface"]:
1398
544
# self.server_address = (self.server_address[0],
1401
547
# if_nametoindex
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)
550
return super(type(self), self).server_bind()
1511
553
def string_to_delta(interval):
1512
554
"""Parse a string and return a datetime.timedelta
1514
>>> string_to_delta(u'7d')
556
>>> string_to_delta('7d')
1515
557
datetime.timedelta(7)
1516
>>> string_to_delta(u'60s')
558
>>> string_to_delta('60s')
1517
559
datetime.timedelta(0, 60)
1518
>>> string_to_delta(u'60m')
560
>>> string_to_delta('60m')
1519
561
datetime.timedelta(0, 3600)
1520
>>> string_to_delta(u'24h')
562
>>> string_to_delta('24h')
1521
563
datetime.timedelta(1)
1522
564
>>> string_to_delta(u'1w')
1523
565
datetime.timedelta(7)
1524
>>> string_to_delta(u'5m 30s')
1525
datetime.timedelta(0, 330)
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)
568
suffix=unicode(interval[-1])
569
value=int(interval[:-1])
571
delta = datetime.timedelta(value)
573
delta = datetime.timedelta(0, value)
575
delta = datetime.timedelta(0, 0, 0, 0, value)
577
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
579
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
582
except (ValueError, IndexError):
587
def server_state_changed(state):
588
"""Derived from the Avahi example code"""
589
if state == avahi.SERVER_COLLISION:
590
logger.error(u"Server name collision")
592
elif state == avahi.SERVER_RUNNING:
596
def entry_group_state_changed(state, error):
597
"""Derived from the Avahi example code"""
598
logger.debug(u"state change: %i", state)
600
if state == avahi.ENTRY_GROUP_ESTABLISHED:
601
logger.debug(u"Service established.")
602
elif state == avahi.ENTRY_GROUP_COLLISION:
603
logger.warning(u"Service name collision.")
605
elif state == avahi.ENTRY_GROUP_FAILURE:
606
logger.critical(u"Error in group state changed %s",
608
raise AvahiGroupError("State changed: %s", str(error))
1550
610
def if_nametoindex(interface):
1551
"""Call the C function if_nametoindex(), or equivalent
1553
Note: This function cannot accept a unicode string."""
611
"""Call the C function if_nametoindex(), or equivalent"""
1554
612
global if_nametoindex
1556
if_nametoindex = (ctypes.cdll.LoadLibrary
1557
(ctypes.util.find_library(u"c"))
614
if "ctypes.util" not in sys.modules:
616
if_nametoindex = ctypes.cdll.LoadLibrary\
617
(ctypes.util.find_library("c")).if_nametoindex
1559
618
except (OSError, AttributeError):
1560
logger.warning(u"Doing if_nametoindex the hard way")
619
if "struct" not in sys.modules:
621
if "fcntl" not in sys.modules:
1561
623
def if_nametoindex(interface):
1562
624
"Get an interface index the hard way, i.e. using fcntl()"
1563
625
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
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"),
627
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
628
struct.pack("16s16x", interface))
630
interface_index = struct.unpack("I", ifreq[16:20])[0]
1570
631
return interface_index
1571
632
return if_nametoindex(interface)
1574
635
def daemon(nochdir = False, noclose = False):
1575
636
"""See daemon(3). Standard BSD Unix function.
1577
637
This should really exist as os.daemon, but it doesn't (yet)."""
1636
689
# Default values for config file for server-global settings
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",
690
server_defaults = { "interface": "",
695
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
696
"servicename": "Mandos",
1648
699
# Parse config file for server-global settings
1649
server_config = configparser.SafeConfigParser(server_defaults)
700
server_config = ConfigParser.SafeConfigParser(server_defaults)
1650
701
del server_defaults
1651
server_config.read(os.path.join(options.configdir,
702
server_config.read(os.path.join(options.configdir, "mandos.conf"))
703
server_section = "server"
1653
704
# Convert the SafeConfigParser object to a dict
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",
705
server_settings = dict(server_config.items(server_section))
706
# Use getboolean on the boolean config option
707
server_settings["debug"] = server_config.getboolean\
708
(server_section, "debug")
1662
709
del server_config
1664
711
# Override the settings from the config file with command line
1665
712
# options, if set.
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"):
713
for option in ("interface", "address", "port", "debug",
714
"priority", "servicename", "configdir"):
1669
715
value = getattr(options, option)
1670
716
if value is not None:
1671
717
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])
1677
719
# Now we have our good server settings in "server_settings"
1679
##################################################################
1682
debug = server_settings[u"debug"]
1683
use_dbus = server_settings[u"use_dbus"]
1684
use_ipv6 = server_settings[u"use_ipv6"]
721
debug = server_settings["debug"]
1687
724
syslogger.setLevel(logging.WARNING)
1688
725
console.setLevel(logging.WARNING)
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"]))
727
if server_settings["servicename"] != "Mandos":
728
syslogger.setFormatter(logging.Formatter\
729
('Mandos (%s): %%(levelname)s:'
731
% server_settings["servicename"]))
1696
733
# Parse config file with clients
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",
734
client_defaults = { "timeout": "1h",
736
"checker": "fping -q -- %%(host)s",
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))
738
client_config = ConfigParser.SafeConfigParser(client_defaults)
739
client_config.read(os.path.join(server_settings["configdir"],
743
service = AvahiService(name = server_settings["servicename"],
744
type = "_mandos._tcp", );
745
if server_settings["interface"]:
746
service.interface = if_nametoindex(server_settings["interface"])
1759
748
global main_loop
1760
751
# From the Avahi example code
1761
752
DBusGMainLoop(set_as_default=True )
1762
753
main_loop = gobject.MainLoop()
1763
754
bus = dbus.SystemBus()
755
server = dbus.Interface(
756
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
757
avahi.DBUS_INTERFACE_SERVER )
1764
758
# End of Avahi example code
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
761
def remove_from_clients(client):
762
clients.remove(client)
764
logger.critical(u"No clients left, exiting")
767
clients.update(Set(Client(name = section,
768
stop_hook = remove_from_clients,
770
= dict(client_config.items(section)))
771
for section in client_config.sections()))
773
logger.critical(u"No clients defined")
1813
777
logger.removeHandler(console)
1814
# Close all input and output, do double fork, etc.
780
pidfilename = "/var/run/mandos/mandos.pid"
1820
pidfile.write(str(pid) + "\n")
783
pidfile = open(pidfilename, "w")
784
pidfile.write(str(pid) + "\n")
1823
logger.error(u"Could not write to file %r with PID %d",
1826
# "pidfile" was never created
788
logger.error(u"Could not write %s file with PID %d",
789
pidfilename, os.getpid())
792
"Cleanup function; run on exit"
794
# From the Avahi example code
795
if not group is None:
798
# End of Avahi example code
801
client = clients.pop()
802
client.stop_hook = None
805
atexit.register(cleanup)
1831
808
signal.signal(signal.SIGINT, signal.SIG_IGN)
1832
809
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1833
810
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()
1891
"Cleanup function; run on exit"
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,
1906
atexit.register(cleanup)
1908
for client in tcp_server.clients:
1911
mandos_dbus_service.ClientAdded(client.dbus_object_path)
1915
tcp_server.server_activate()
812
for client in clients:
815
tcp_server = IPv6_TCPServer((server_settings["address"],
816
server_settings["port"]),
818
settings=server_settings,
1917
820
# Find out what port we got
1918
821
service.port = tcp_server.socket.getsockname()[1]
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())
822
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
823
u" scope_id %d" % tcp_server.socket.getsockname())
1927
825
#service.interface = tcp_server.socket.getsockname()[3]
1930
828
# From the Avahi example code
829
server.connect_to_signal("StateChanged", server_state_changed)
831
server_state_changed(server.GetState())
1933
832
except dbus.exceptions.DBusException, error:
1934
833
logger.critical(u"DBusException: %s", error)
1937
835
# End of Avahi example code
1939
837
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
1940
838
lambda *args, **kwargs:
1941
(tcp_server.handle_request
1942
(*args[2:], **kwargs) or True))
839
tcp_server.handle_request\
840
(*args[2:], **kwargs) or True)
1944
842
logger.debug(u"Starting main loop")
843
main_loop_started = True
1946
845
except AvahiError, error:
1947
logger.critical(u"AvahiError: %s", error)
846
logger.critical(u"AvahiError: %s" + unicode(error))
1950
848
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
1958
852
if __name__ == '__main__':