To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to mandos
- browse files at revision 341
- compare with another revision
- download diff
- download tarball
- view history from revision 341
- Committer: Teddy Hogeborn
- Date: 2009-04-17 01:16:37 UTC
- Revision ID: teddy@fukt.bsnet.se-20090417011637-bcqjpm7fskm4370v
Code cleanup and one bug fix.
* mandos (Client.enable): Bug fix: Do not enable if already enabled.
(MandosServer.__init__): Create empty set of clients if none passed.
(main): Do not create clients set; do not pass a clients set to
MandosServer. Use tcp_server.clients throughout.
* mandos (Client.enable): Bug fix: Do not enable if already enabled.
(MandosServer.__init__): Create empty set of clients if none passed.
(main): Do not create clients set; do not pass a clients set to
MandosServer. Use tcp_server.clients throughout.
added
removed
mandos
55
55
import logging
56
56
import logging.handlers
57
57
import pwd
58
import contextlib
58
from contextlib import closing
59
59
import struct
60
60
import fcntl
61
61
import functools
62
import cPickle as pickle
63
import multiprocessing
64
62
65
63
import dbus
66
64
import dbus.service
69
67
from dbus.mainloop.glib import DBusGMainLoop
70
68
import ctypes
71
69
import ctypes.util
72
import xml.dom.minidom
73
import inspect
74
70
75
71
try:
76
72
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
81
77
SO_BINDTODEVICE = None
82
78
83
79
84
version = "1.0.14"
80
version = "1.0.8"
85
81
86
#logger = logging.getLogger(u'mandos')
87
82
logger = logging.Logger(u'mandos')
88
83
syslogger = (logging.handlers.SysLogHandler
89
84
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
157
152
u" after %i retries, exiting.",
158
153
self.rename_count)
159
154
raise AvahiServiceError(u"Too many renames")
160
self.name = unicode(self.server.GetAlternativeServiceName(self.name))
155
self.name = self.server.GetAlternativeServiceName(self.name)
161
156
logger.info(u"Changing Zeroconf service name to %r ...",
162
self.name)
157
unicode(self.name))
163
158
syslogger.setFormatter(logging.Formatter
164
159
(u'Mandos (%s) [%%(process)d]:'
165
160
u' %%(levelname)s: %%(message)s'
166
161
% self.name))
167
162
self.remove()
168
try:
169
self.add()
170
except dbus.exceptions.DBusException, error:
171
logger.critical(u"DBusException: %s", error)
172
self.cleanup()
173
os._exit(1)
163
self.add()
174
164
self.rename_count += 1
175
165
def remove(self):
176
166
"""Derived from the Avahi example code"""
184
174
self.server.EntryGroupNew()),
185
175
avahi.DBUS_INTERFACE_ENTRY_GROUP)
186
176
self.group.connect_to_signal('StateChanged',
187
self
188
.entry_group_state_changed)
177
self.entry_group_state_changed)
189
178
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
190
179
self.name, self.type)
191
180
self.group.AddService(
199
188
self.group.Commit()
200
189
def entry_group_state_changed(self, state, error):
201
190
"""Derived from the Avahi example code"""
202
logger.debug(u"Avahi entry group state change: %i", state)
191
logger.debug(u"Avahi state change: %i", state)
203
192
204
193
if state == avahi.ENTRY_GROUP_ESTABLISHED:
205
194
logger.debug(u"Zeroconf service established.")
218
207
self.group = None
219
208
def server_state_changed(self, state):
220
209
"""Derived from the Avahi example code"""
221
logger.debug(u"Avahi server state change: %i", state)
222
210
if state == avahi.SERVER_COLLISION:
223
211
logger.error(u"Zeroconf server name collision")
224
212
self.remove()
240
228
"""A representation of a client host served by this server.
241
229
242
230
Attributes:
243
_approved: bool(); 'None' if not yet approved/disapproved
244
approval_delay: datetime.timedelta(); Time to wait for approval
245
approval_duration: datetime.timedelta(); Duration of one approval
231
name: string; from the config file, used in log messages and
232
D-Bus identifiers
233
fingerprint: string (40 or 32 hexadecimal digits); used to
234
uniquely identify the client
235
secret: bytestring; sent verbatim (over TLS) to client
236
host: string; available for use by the checker command
237
created: datetime.datetime(); (UTC) object creation
238
last_enabled: datetime.datetime(); (UTC)
239
enabled: bool()
240
last_checked_ok: datetime.datetime(); (UTC) or None
241
timeout: datetime.timedelta(); How long from last_checked_ok
242
until this client is invalid
243
interval: datetime.timedelta(); How often to start a new checker
244
disable_hook: If set, called by disable() as disable_hook(self)
246
245
checker: subprocess.Popen(); a running checker process used
247
246
to see if the client lives.
248
247
'None' if no process is running.
248
checker_initiator_tag: a gobject event source tag, or None
249
disable_initiator_tag: - '' -
249
250
checker_callback_tag: - '' -
250
checker_command: string; External command which is run to check
251
if client lives. %() expansions are done at
251
checker_command: string; External command which is run to check if
252
client lives. %() expansions are done at
252
253
runtime with vars(self) as dict, so that for
253
254
instance %(name)s can be used in the command.
254
checker_initiator_tag: a gobject event source tag, or None
255
created: datetime.datetime(); (UTC) object creation
256
255
current_checker_command: string; current running checker_command
257
disable_hook: If set, called by disable() as disable_hook(self)
258
disable_initiator_tag: - '' -
259
enabled: bool()
260
fingerprint: string (40 or 32 hexadecimal digits); used to
261
uniquely identify the client
262
host: string; available for use by the checker command
263
interval: datetime.timedelta(); How often to start a new checker
264
last_checked_ok: datetime.datetime(); (UTC) or None
265
last_enabled: datetime.datetime(); (UTC)
266
name: string; from the config file, used in log messages and
267
D-Bus identifiers
268
secret: bytestring; sent verbatim (over TLS) to client
269
timeout: datetime.timedelta(); How long from last_checked_ok
270
until this client is disabled
271
runtime_expansions: Allowed attributes for runtime expansion.
272
256
"""
273
257
274
runtime_expansions = (u"approval_delay", u"approval_duration",
275
u"created", u"enabled", u"fingerprint",
276
u"host", u"interval", u"last_checked_ok",
277
u"last_enabled", u"name", u"timeout")
278
279
258
@staticmethod
280
def _timedelta_to_milliseconds(td):
281
"Convert a datetime.timedelta() to milliseconds"
282
return ((td.days * 24 * 60 * 60 * 1000)
283
+ (td.seconds * 1000)
284
+ (td.microseconds // 1000))
259
def _datetime_to_milliseconds(dt):
260
"Convert a datetime.datetime() to milliseconds"
261
return ((dt.days * 24 * 60 * 60 * 1000)
262
+ (dt.seconds * 1000)
263
+ (dt.microseconds // 1000))
285
264
286
265
def timeout_milliseconds(self):
287
266
"Return the 'timeout' attribute in milliseconds"
288
return self._timedelta_to_milliseconds(self.timeout)
267
return self._datetime_to_milliseconds(self.timeout)
289
268
290
269
def interval_milliseconds(self):
291
270
"Return the 'interval' attribute in milliseconds"
292
return self._timedelta_to_milliseconds(self.interval)
293
294
def approval_delay_milliseconds(self):
295
return self._timedelta_to_milliseconds(self.approval_delay)
271
return self._datetime_to_milliseconds(self.interval)
296
272
297
273
def __init__(self, name = None, disable_hook=None, config=None):
298
274
"""Note: the 'checker' key in 'config' sets the
311
287
if u"secret" in config:
312
288
self.secret = config[u"secret"].decode(u"base64")
313
289
elif u"secfile" in config:
314
with open(os.path.expanduser(os.path.expandvars
315
(config[u"secfile"])),
316
"rb") as secfile:
290
with closing(open(os.path.expanduser
291
(os.path.expandvars
292
(config[u"secfile"])))) as secfile:
317
293
self.secret = secfile.read()
318
294
else:
319
295
raise TypeError(u"No secret or secfile for client %s"
333
309
self.checker_command = config[u"checker"]
334
310
self.current_checker_command = None
335
311
self.last_connect = None
336
self._approved = None
337
self.approved_by_default = config.get(u"approved_by_default",
338
True)
339
self.approvals_pending = 0
340
self.approval_delay = string_to_delta(
341
config[u"approval_delay"])
342
self.approval_duration = string_to_delta(
343
config[u"approval_duration"])
344
self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())
345
312
346
def send_changedstate(self):
347
self.changedstate.acquire()
348
self.changedstate.notify_all()
349
self.changedstate.release()
350
351
313
def enable(self):
352
314
"""Start this client's checker and timeout hooks"""
353
315
if getattr(self, u"enabled", False):
354
316
# Already enabled
355
317
return
356
self.send_changedstate()
357
318
self.last_enabled = datetime.datetime.utcnow()
358
319
# Schedule a new checker to be started an 'interval' from now,
359
320
# and every interval from then on.
360
321
self.checker_initiator_tag = (gobject.timeout_add
361
322
(self.interval_milliseconds(),
362
323
self.start_checker))
324
# Also start a new checker *right now*.
325
self.start_checker()
363
326
# Schedule a disable() when 'timeout' has passed
364
327
self.disable_initiator_tag = (gobject.timeout_add
365
328
(self.timeout_milliseconds(),
366
329
self.disable))
367
330
self.enabled = True
368
# Also start a new checker *right now*.
369
self.start_checker()
370
331
371
def disable(self, quiet=True):
332
def disable(self):
372
333
"""Disable this client."""
373
334
if not getattr(self, "enabled", False):
374
335
return False
375
if not quiet:
376
self.send_changedstate()
377
if not quiet:
378
logger.info(u"Disabling client %s", self.name)
336
logger.info(u"Disabling client %s", self.name)
379
337
if getattr(self, u"disable_initiator_tag", False):
380
338
gobject.source_remove(self.disable_initiator_tag)
381
339
self.disable_initiator_tag = None
433
391
# client would inevitably timeout, since no checker would get
434
392
# a chance to run to completion. If we instead leave running
435
393
# checkers alone, the checker would have to take more time
436
# than 'timeout' for the client to be disabled, which is as it
437
# should be.
394
# than 'timeout' for the client to be declared invalid, which
395
# is as it should be.
438
396
439
397
# If a checker exists, make sure it is not a zombie
440
try:
398
if self.checker is not None:
441
399
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
442
except (AttributeError, OSError), error:
443
if (isinstance(error, OSError)
444
and error.errno != errno.ECHILD):
445
raise error
446
else:
447
400
if pid:
448
401
logger.warning(u"Checker was a zombie")
449
402
gobject.source_remove(self.checker_callback_tag)
456
409
command = self.checker_command % self.host
457
410
except TypeError:
458
411
# Escape attributes for the shell
459
escaped_attrs = dict(
460
(attr,
461
re.escape(unicode(str(getattr(self, attr, u"")),
462
errors=
463
u'replace')))
464
for attr in
465
self.runtime_expansions)
466
412
escaped_attrs = dict((key,
413
re.escape(unicode(str(val),
414
errors=
415
u'replace')))
416
for key, val in
417
vars(self).iteritems())
467
418
try:
468
419
command = self.checker_command % escaped_attrs
469
420
except TypeError, error:
507
458
logger.debug(u"Stopping checker for %(name)s", vars(self))
508
459
try:
509
460
os.kill(self.checker.pid, signal.SIGTERM)
510
#time.sleep(0.5)
461
#os.sleep(0.5)
511
462
#if self.checker.poll() is None:
512
463
# os.kill(self.checker.pid, signal.SIGKILL)
513
464
except OSError, error:
514
465
if error.errno != errno.ESRCH: # No such process
515
466
raise
516
467
self.checker = None
517
518
def dbus_service_property(dbus_interface, signature=u"v",
519
access=u"readwrite", byte_arrays=False):
520
"""Decorators for marking methods of a DBusObjectWithProperties to
521
become properties on the D-Bus.
522
523
The decorated method will be called with no arguments by "Get"
524
and with one argument by "Set".
525
526
The parameters, where they are supported, are the same as
527
dbus.service.method, except there is only "signature", since the
528
type from Get() and the type sent to Set() is the same.
529
"""
530
# Encoding deeply encoded byte arrays is not supported yet by the
531
# "Set" method, so we fail early here:
532
if byte_arrays and signature != u"ay":
533
raise ValueError(u"Byte arrays not supported for non-'ay'"
534
u" signature %r" % signature)
535
def decorator(func):
536
func._dbus_is_property = True
537
func._dbus_interface = dbus_interface
538
func._dbus_signature = signature
539
func._dbus_access = access
540
func._dbus_name = func.__name__
541
if func._dbus_name.endswith(u"_dbus_property"):
542
func._dbus_name = func._dbus_name[:-14]
543
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
544
return func
545
return decorator
546
547
548
class DBusPropertyException(dbus.exceptions.DBusException):
549
"""A base class for D-Bus property-related exceptions
550
"""
551
def __unicode__(self):
552
return unicode(str(self))
553
554
555
class DBusPropertyAccessException(DBusPropertyException):
556
"""A property's access permissions disallows an operation.
557
"""
558
pass
559
560
561
class DBusPropertyNotFound(DBusPropertyException):
562
"""An attempt was made to access a non-existing property.
563
"""
564
pass
565
566
567
class DBusObjectWithProperties(dbus.service.Object):
568
"""A D-Bus object with properties.
569
570
Classes inheriting from this can use the dbus_service_property
571
decorator to expose methods as D-Bus properties. It exposes the
572
standard Get(), Set(), and GetAll() methods on the D-Bus.
573
"""
574
575
@staticmethod
576
def _is_dbus_property(obj):
577
return getattr(obj, u"_dbus_is_property", False)
578
579
def _get_all_dbus_properties(self):
580
"""Returns a generator of (name, attribute) pairs
581
"""
582
return ((prop._dbus_name, prop)
583
for name, prop in
584
inspect.getmembers(self, self._is_dbus_property))
585
586
def _get_dbus_property(self, interface_name, property_name):
587
"""Returns a bound method if one exists which is a D-Bus
588
property with the specified name and interface.
589
"""
590
for name in (property_name,
591
property_name + u"_dbus_property"):
592
prop = getattr(self, name, None)
593
if (prop is None
594
or not self._is_dbus_property(prop)
595
or prop._dbus_name != property_name
596
or (interface_name and prop._dbus_interface
597
and interface_name != prop._dbus_interface)):
598
continue
599
return prop
600
# No such property
601
raise DBusPropertyNotFound(self.dbus_object_path + u":"
602
+ interface_name + u"."
603
+ property_name)
604
605
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
606
out_signature=u"v")
607
def Get(self, interface_name, property_name):
608
"""Standard D-Bus property Get() method, see D-Bus standard.
609
"""
610
prop = self._get_dbus_property(interface_name, property_name)
611
if prop._dbus_access == u"write":
612
raise DBusPropertyAccessException(property_name)
613
value = prop()
614
if not hasattr(value, u"variant_level"):
615
return value
616
return type(value)(value, variant_level=value.variant_level+1)
617
618
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
619
def Set(self, interface_name, property_name, value):
620
"""Standard D-Bus property Set() method, see D-Bus standard.
621
"""
622
prop = self._get_dbus_property(interface_name, property_name)
623
if prop._dbus_access == u"read":
624
raise DBusPropertyAccessException(property_name)
625
if prop._dbus_get_args_options[u"byte_arrays"]:
626
# The byte_arrays option is not supported yet on
627
# signatures other than "ay".
628
if prop._dbus_signature != u"ay":
629
raise ValueError
630
value = dbus.ByteArray(''.join(unichr(byte)
631
for byte in value))
632
prop(value)
633
634
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
635
out_signature=u"a{sv}")
636
def GetAll(self, interface_name):
637
"""Standard D-Bus property GetAll() method, see D-Bus
638
standard.
639
640
Note: Will not include properties with access="write".
641
"""
642
all = {}
643
for name, prop in self._get_all_dbus_properties():
644
if (interface_name
645
and interface_name != prop._dbus_interface):
646
# Interface non-empty but did not match
647
continue
648
# Ignore write-only properties
649
if prop._dbus_access == u"write":
650
continue
651
value = prop()
652
if not hasattr(value, u"variant_level"):
653
all[name] = value
654
continue
655
all[name] = type(value)(value, variant_level=
656
value.variant_level+1)
657
return dbus.Dictionary(all, signature=u"sv")
658
659
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
660
out_signature=u"s",
661
path_keyword='object_path',
662
connection_keyword='connection')
663
def Introspect(self, object_path, connection):
664
"""Standard D-Bus method, overloaded to insert property tags.
665
"""
666
xmlstring = dbus.service.Object.Introspect(self, object_path,
667
connection)
668
try:
669
document = xml.dom.minidom.parseString(xmlstring)
670
def make_tag(document, name, prop):
671
e = document.createElement(u"property")
672
e.setAttribute(u"name", name)
673
e.setAttribute(u"type", prop._dbus_signature)
674
e.setAttribute(u"access", prop._dbus_access)
675
return e
676
for if_tag in document.getElementsByTagName(u"interface"):
677
for tag in (make_tag(document, name, prop)
678
for name, prop
679
in self._get_all_dbus_properties()
680
if prop._dbus_interface
681
== if_tag.getAttribute(u"name")):
682
if_tag.appendChild(tag)
683
# Add the names to the return values for the
684
# "org.freedesktop.DBus.Properties" methods
685
if (if_tag.getAttribute(u"name")
686
== u"org.freedesktop.DBus.Properties"):
687
for cn in if_tag.getElementsByTagName(u"method"):
688
if cn.getAttribute(u"name") == u"Get":
689
for arg in cn.getElementsByTagName(u"arg"):
690
if (arg.getAttribute(u"direction")
691
== u"out"):
692
arg.setAttribute(u"name", u"value")
693
elif cn.getAttribute(u"name") == u"GetAll":
694
for arg in cn.getElementsByTagName(u"arg"):
695
if (arg.getAttribute(u"direction")
696
== u"out"):
697
arg.setAttribute(u"name", u"props")
698
xmlstring = document.toxml(u"utf-8")
699
document.unlink()
700
except (AttributeError, xml.dom.DOMException,
701
xml.parsers.expat.ExpatError), error:
702
logger.error(u"Failed to override Introspection method",
703
error)
704
return xmlstring
705
706
707
class ClientDBus(Client, DBusObjectWithProperties):
468
469
def still_valid(self):
470
"""Has the timeout not yet passed for this client?"""
471
if not getattr(self, u"enabled", False):
472
return False
473
now = datetime.datetime.utcnow()
474
if self.last_checked_ok is None:
475
return now < (self.created + self.timeout)
476
else:
477
return now < (self.last_checked_ok + self.timeout)
478
479
480
class ClientDBus(Client, dbus.service.Object):
708
481
"""A Client class using D-Bus
709
482
710
483
Attributes:
711
484
dbus_object_path: dbus.ObjectPath
712
485
bus: dbus.SystemBus()
713
486
"""
714
715
runtime_expansions = (Client.runtime_expansions
716
+ (u"dbus_object_path",))
717
718
487
# dbus.service.Object doesn't use super(), so we can't either.
719
488
720
489
def __init__(self, bus = None, *args, **kwargs):
721
self._approvals_pending = 0
722
490
self.bus = bus
723
491
Client.__init__(self, *args, **kwargs)
724
492
# Only now, when this client is initialized, can it show up on
725
493
# the D-Bus
726
client_object_name = unicode(self.name).translate(
727
{ord(u"."): ord(u"_"),
728
ord(u"-"): ord(u"_")})
729
494
self.dbus_object_path = (dbus.ObjectPath
730
(u"/clients/" + client_object_name))
731
DBusObjectWithProperties.__init__(self, self.bus,
732
self.dbus_object_path)
733
734
def _get_approvals_pending(self):
735
return self._approvals_pending
736
def _set_approvals_pending(self, value):
737
old_value = self._approvals_pending
738
self._approvals_pending = value
739
bval = bool(value)
740
if (hasattr(self, "dbus_object_path")
741
and bval is not bool(old_value)):
742
dbus_bool = dbus.Boolean(bval, variant_level=1)
743
self.PropertyChanged(dbus.String(u"ApprovalPending"),
744
dbus_bool)
745
746
approvals_pending = property(_get_approvals_pending,
747
_set_approvals_pending)
748
del _get_approvals_pending, _set_approvals_pending
495
(u"/clients/"
496
+ self.name.replace(u".", u"_")))
497
dbus.service.Object.__init__(self, self.bus,
498
self.dbus_object_path)
749
499
750
500
@staticmethod
751
501
def _datetime_to_dbus(dt, variant_level=0):
758
508
r = Client.enable(self)
759
509
if oldstate != self.enabled:
760
510
# Emit D-Bus signals
761
self.PropertyChanged(dbus.String(u"Enabled"),
511
self.PropertyChanged(dbus.String(u"enabled"),
762
512
dbus.Boolean(True, variant_level=1))
763
513
self.PropertyChanged(
764
dbus.String(u"LastEnabled"),
514
dbus.String(u"last_enabled"),
765
515
self._datetime_to_dbus(self.last_enabled,
766
516
variant_level=1))
767
517
return r
768
518
769
def disable(self, quiet = False):
519
def disable(self, signal = True):
770
520
oldstate = getattr(self, u"enabled", False)
771
r = Client.disable(self, quiet=quiet)
772
if not quiet and oldstate != self.enabled:
521
r = Client.disable(self)
522
if signal and oldstate != self.enabled:
773
523
# Emit D-Bus signal
774
self.PropertyChanged(dbus.String(u"Enabled"),
524
self.PropertyChanged(dbus.String(u"enabled"),
775
525
dbus.Boolean(False, variant_level=1))
776
526
return r
777
527
780
530
self.remove_from_connection()
781
531
except LookupError:
782
532
pass
783
if hasattr(DBusObjectWithProperties, u"__del__"):
784
DBusObjectWithProperties.__del__(self, *args, **kwargs)
533
if hasattr(dbus.service.Object, u"__del__"):
534
dbus.service.Object.__del__(self, *args, **kwargs)
785
535
Client.__del__(self, *args, **kwargs)
786
536
787
537
def checker_callback(self, pid, condition, command,
789
539
self.checker_callback_tag = None
790
540
self.checker = None
791
541
# Emit D-Bus signal
792
self.PropertyChanged(dbus.String(u"CheckerRunning"),
542
self.PropertyChanged(dbus.String(u"checker_running"),
793
543
dbus.Boolean(False, variant_level=1))
794
544
if os.WIFEXITED(condition):
795
545
exitstatus = os.WEXITSTATUS(condition)
810
560
r = Client.checked_ok(self, *args, **kwargs)
811
561
# Emit D-Bus signal
812
562
self.PropertyChanged(
813
dbus.String(u"LastCheckedOK"),
563
dbus.String(u"last_checked_ok"),
814
564
(self._datetime_to_dbus(self.last_checked_ok,
815
565
variant_level=1)))
816
566
return r
828
578
# Emit D-Bus signal
829
579
self.CheckerStarted(self.current_checker_command)
830
580
self.PropertyChanged(
831
dbus.String(u"CheckerRunning"),
581
dbus.String(u"checker_running"),
832
582
dbus.Boolean(True, variant_level=1))
833
583
return r
834
584
837
587
r = Client.stop_checker(self, *args, **kwargs)
838
588
if (old_checker is not None
839
589
and getattr(self, u"checker", None) is None):
840
self.PropertyChanged(dbus.String(u"CheckerRunning"),
590
self.PropertyChanged(dbus.String(u"checker_running"),
841
591
dbus.Boolean(False, variant_level=1))
842
592
return r
843
844
def _reset_approved(self):
845
self._approved = None
846
return False
847
848
def approve(self, value=True):
849
self.send_changedstate()
850
self._approved = value
851
gobject.timeout_add(self._timedelta_to_milliseconds
852
(self.approval_duration),
853
self._reset_approved)
854
855
856
## D-Bus methods, signals & properties
593
594
## D-Bus methods & signals
857
595
_interface = u"se.bsnet.fukt.Mandos.Client"
858
596
859
## Signals
597
# CheckedOK - method
598
@dbus.service.method(_interface)
599
def CheckedOK(self):
600
return self.checked_ok()
860
601
861
602
# CheckerCompleted - signal
862
603
@dbus.service.signal(_interface, signature=u"nxs")
870
611
"D-Bus signal"
871
612
pass
872
613
614
# GetAllProperties - method
615
@dbus.service.method(_interface, out_signature=u"a{sv}")
616
def GetAllProperties(self):
617
"D-Bus method"
618
return dbus.Dictionary({
619
dbus.String(u"name"):
620
dbus.String(self.name, variant_level=1),
621
dbus.String(u"fingerprint"):
622
dbus.String(self.fingerprint, variant_level=1),
623
dbus.String(u"host"):
624
dbus.String(self.host, variant_level=1),
625
dbus.String(u"created"):
626
self._datetime_to_dbus(self.created,
627
variant_level=1),
628
dbus.String(u"last_enabled"):
629
(self._datetime_to_dbus(self.last_enabled,
630
variant_level=1)
631
if self.last_enabled is not None
632
else dbus.Boolean(False, variant_level=1)),
633
dbus.String(u"enabled"):
634
dbus.Boolean(self.enabled, variant_level=1),
635
dbus.String(u"last_checked_ok"):
636
(self._datetime_to_dbus(self.last_checked_ok,
637
variant_level=1)
638
if self.last_checked_ok is not None
639
else dbus.Boolean (False, variant_level=1)),
640
dbus.String(u"timeout"):
641
dbus.UInt64(self.timeout_milliseconds(),
642
variant_level=1),
643
dbus.String(u"interval"):
644
dbus.UInt64(self.interval_milliseconds(),
645
variant_level=1),
646
dbus.String(u"checker"):
647
dbus.String(self.checker_command,
648
variant_level=1),
649
dbus.String(u"checker_running"):
650
dbus.Boolean(self.checker is not None,
651
variant_level=1),
652
dbus.String(u"object_path"):
653
dbus.ObjectPath(self.dbus_object_path,
654
variant_level=1)
655
}, signature=u"sv")
656
657
# IsStillValid - method
658
@dbus.service.method(_interface, out_signature=u"b")
659
def IsStillValid(self):
660
return self.still_valid()
661
873
662
# PropertyChanged - signal
874
663
@dbus.service.signal(_interface, signature=u"sv")
875
664
def PropertyChanged(self, property, value):
876
665
"D-Bus signal"
877
666
pass
878
667
879
# GotSecret - signal
668
# ReceivedSecret - signal
880
669
@dbus.service.signal(_interface)
881
def GotSecret(self):
882
"""D-Bus signal
883
Is sent after a successful transfer of secret from the Mandos
884
server to mandos-client
885
"""
670
def ReceivedSecret(self):
671
"D-Bus signal"
886
672
pass
887
673
888
674
# Rejected - signal
889
@dbus.service.signal(_interface, signature=u"s")
890
def Rejected(self, reason):
891
"D-Bus signal"
892
pass
893
894
# NeedApproval - signal
895
@dbus.service.signal(_interface, signature=u"tb")
896
def NeedApproval(self, timeout, default):
897
"D-Bus signal"
898
pass
899
900
## Methods
901
902
# Approve - method
903
@dbus.service.method(_interface, in_signature=u"b")
904
def Approve(self, value):
905
self.approve(value)
906
907
# CheckedOK - method
908
@dbus.service.method(_interface)
909
def CheckedOK(self):
910
return self.checked_ok()
675
@dbus.service.signal(_interface)
676
def Rejected(self):
677
"D-Bus signal"
678
pass
679
680
# SetChecker - method
681
@dbus.service.method(_interface, in_signature=u"s")
682
def SetChecker(self, checker):
683
"D-Bus setter method"
684
self.checker_command = checker
685
# Emit D-Bus signal
686
self.PropertyChanged(dbus.String(u"checker"),
687
dbus.String(self.checker_command,
688
variant_level=1))
689
690
# SetHost - method
691
@dbus.service.method(_interface, in_signature=u"s")
692
def SetHost(self, host):
693
"D-Bus setter method"
694
self.host = host
695
# Emit D-Bus signal
696
self.PropertyChanged(dbus.String(u"host"),
697
dbus.String(self.host, variant_level=1))
698
699
# SetInterval - method
700
@dbus.service.method(_interface, in_signature=u"t")
701
def SetInterval(self, milliseconds):
702
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
703
# Emit D-Bus signal
704
self.PropertyChanged(dbus.String(u"interval"),
705
(dbus.UInt64(self.interval_milliseconds(),
706
variant_level=1)))
707
708
# SetSecret - method
709
@dbus.service.method(_interface, in_signature=u"ay",
710
byte_arrays=True)
711
def SetSecret(self, secret):
712
"D-Bus setter method"
713
self.secret = str(secret)
714
715
# SetTimeout - method
716
@dbus.service.method(_interface, in_signature=u"t")
717
def SetTimeout(self, milliseconds):
718
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
719
# Emit D-Bus signal
720
self.PropertyChanged(dbus.String(u"timeout"),
721
(dbus.UInt64(self.timeout_milliseconds(),
722
variant_level=1)))
911
723
912
724
# Enable - method
913
725
@dbus.service.method(_interface)
932
744
def StopChecker(self):
933
745
self.stop_checker()
934
746
935
## Properties
936
937
# ApprovalPending - property
938
@dbus_service_property(_interface, signature=u"b", access=u"read")
939
def ApprovalPending_dbus_property(self):
940
return dbus.Boolean(bool(self.approvals_pending))
941
942
# ApprovedByDefault - property
943
@dbus_service_property(_interface, signature=u"b",
944
access=u"readwrite")
945
def ApprovedByDefault_dbus_property(self, value=None):
946
if value is None: # get
947
return dbus.Boolean(self.approved_by_default)
948
self.approved_by_default = bool(value)
949
# Emit D-Bus signal
950
self.PropertyChanged(dbus.String(u"ApprovedByDefault"),
951
dbus.Boolean(value, variant_level=1))
952
953
# ApprovalDelay - property
954
@dbus_service_property(_interface, signature=u"t",
955
access=u"readwrite")
956
def ApprovalDelay_dbus_property(self, value=None):
957
if value is None: # get
958
return dbus.UInt64(self.approval_delay_milliseconds())
959
self.approval_delay = datetime.timedelta(0, 0, 0, value)
960
# Emit D-Bus signal
961
self.PropertyChanged(dbus.String(u"ApprovalDelay"),
962
dbus.UInt64(value, variant_level=1))
963
964
# ApprovalDuration - property
965
@dbus_service_property(_interface, signature=u"t",
966
access=u"readwrite")
967
def ApprovalDuration_dbus_property(self, value=None):
968
if value is None: # get
969
return dbus.UInt64(self._timedelta_to_milliseconds(
970
self.approval_duration))
971
self.approval_duration = datetime.timedelta(0, 0, 0, value)
972
# Emit D-Bus signal
973
self.PropertyChanged(dbus.String(u"ApprovalDuration"),
974
dbus.UInt64(value, variant_level=1))
975
976
# Name - property
977
@dbus_service_property(_interface, signature=u"s", access=u"read")
978
def Name_dbus_property(self):
979
return dbus.String(self.name)
980
981
# Fingerprint - property
982
@dbus_service_property(_interface, signature=u"s", access=u"read")
983
def Fingerprint_dbus_property(self):
984
return dbus.String(self.fingerprint)
985
986
# Host - property
987
@dbus_service_property(_interface, signature=u"s",
988
access=u"readwrite")
989
def Host_dbus_property(self, value=None):
990
if value is None: # get
991
return dbus.String(self.host)
992
self.host = value
993
# Emit D-Bus signal
994
self.PropertyChanged(dbus.String(u"Host"),
995
dbus.String(value, variant_level=1))
996
997
# Created - property
998
@dbus_service_property(_interface, signature=u"s", access=u"read")
999
def Created_dbus_property(self):
1000
return dbus.String(self._datetime_to_dbus(self.created))
1001
1002
# LastEnabled - property
1003
@dbus_service_property(_interface, signature=u"s", access=u"read")
1004
def LastEnabled_dbus_property(self):
1005
if self.last_enabled is None:
1006
return dbus.String(u"")
1007
return dbus.String(self._datetime_to_dbus(self.last_enabled))
1008
1009
# Enabled - property
1010
@dbus_service_property(_interface, signature=u"b",
1011
access=u"readwrite")
1012
def Enabled_dbus_property(self, value=None):
1013
if value is None: # get
1014
return dbus.Boolean(self.enabled)
1015
if value:
1016
self.enable()
1017
else:
1018
self.disable()
1019
1020
# LastCheckedOK - property
1021
@dbus_service_property(_interface, signature=u"s",
1022
access=u"readwrite")
1023
def LastCheckedOK_dbus_property(self, value=None):
1024
if value is not None:
1025
self.checked_ok()
1026
return
1027
if self.last_checked_ok is None:
1028
return dbus.String(u"")
1029
return dbus.String(self._datetime_to_dbus(self
1030
.last_checked_ok))
1031
1032
# Timeout - property
1033
@dbus_service_property(_interface, signature=u"t",
1034
access=u"readwrite")
1035
def Timeout_dbus_property(self, value=None):
1036
if value is None: # get
1037
return dbus.UInt64(self.timeout_milliseconds())
1038
self.timeout = datetime.timedelta(0, 0, 0, value)
1039
# Emit D-Bus signal
1040
self.PropertyChanged(dbus.String(u"Timeout"),
1041
dbus.UInt64(value, variant_level=1))
1042
if getattr(self, u"disable_initiator_tag", None) is None:
1043
return
1044
# Reschedule timeout
1045
gobject.source_remove(self.disable_initiator_tag)
1046
self.disable_initiator_tag = None
1047
time_to_die = (self.
1048
_timedelta_to_milliseconds((self
1049
.last_checked_ok
1050
+ self.timeout)
1051
- datetime.datetime
1052
.utcnow()))
1053
if time_to_die <= 0:
1054
# The timeout has passed
1055
self.disable()
1056
else:
1057
self.disable_initiator_tag = (gobject.timeout_add
1058
(time_to_die, self.disable))
1059
1060
# Interval - property
1061
@dbus_service_property(_interface, signature=u"t",
1062
access=u"readwrite")
1063
def Interval_dbus_property(self, value=None):
1064
if value is None: # get
1065
return dbus.UInt64(self.interval_milliseconds())
1066
self.interval = datetime.timedelta(0, 0, 0, value)
1067
# Emit D-Bus signal
1068
self.PropertyChanged(dbus.String(u"Interval"),
1069
dbus.UInt64(value, variant_level=1))
1070
if getattr(self, u"checker_initiator_tag", None) is None:
1071
return
1072
# Reschedule checker run
1073
gobject.source_remove(self.checker_initiator_tag)
1074
self.checker_initiator_tag = (gobject.timeout_add
1075
(value, self.start_checker))
1076
self.start_checker() # Start one now, too
1077
1078
# Checker - property
1079
@dbus_service_property(_interface, signature=u"s",
1080
access=u"readwrite")
1081
def Checker_dbus_property(self, value=None):
1082
if value is None: # get
1083
return dbus.String(self.checker_command)
1084
self.checker_command = value
1085
# Emit D-Bus signal
1086
self.PropertyChanged(dbus.String(u"Checker"),
1087
dbus.String(self.checker_command,
1088
variant_level=1))
1089
1090
# CheckerRunning - property
1091
@dbus_service_property(_interface, signature=u"b",
1092
access=u"readwrite")
1093
def CheckerRunning_dbus_property(self, value=None):
1094
if value is None: # get
1095
return dbus.Boolean(self.checker is not None)
1096
if value:
1097
self.start_checker()
1098
else:
1099
self.stop_checker()
1100
1101
# ObjectPath - property
1102
@dbus_service_property(_interface, signature=u"o", access=u"read")
1103
def ObjectPath_dbus_property(self):
1104
return self.dbus_object_path # is already a dbus.ObjectPath
1105
1106
# Secret = property
1107
@dbus_service_property(_interface, signature=u"ay",
1108
access=u"write", byte_arrays=True)
1109
def Secret_dbus_property(self, value):
1110
self.secret = str(value)
1111
1112
747
del _interface
1113
748
1114
749
1115
class ProxyClient(object):
1116
def __init__(self, child_pipe, fpr, address):
1117
self._pipe = child_pipe
1118
self._pipe.send(('init', fpr, address))
1119
if not self._pipe.recv():
1120
raise KeyError()
1121
1122
def __getattribute__(self, name):
1123
if(name == '_pipe'):
1124
return super(ProxyClient, self).__getattribute__(name)
1125
self._pipe.send(('getattr', name))
1126
data = self._pipe.recv()
1127
if data[0] == 'data':
1128
return data[1]
1129
if data[0] == 'function':
1130
def func(*args, **kwargs):
1131
self._pipe.send(('funcall', name, args, kwargs))
1132
return self._pipe.recv()[1]
1133
return func
1134
1135
def __setattr__(self, name, value):
1136
if(name == '_pipe'):
1137
return super(ProxyClient, self).__setattr__(name, value)
1138
self._pipe.send(('setattr', name, value))
1139
1140
1141
750
class ClientHandler(socketserver.BaseRequestHandler, object):
1142
751
"""A class to handle client connections.
1143
752
1145
754
Note: This will run in its own forked process."""
1146
755
1147
756
def handle(self):
1148
with contextlib.closing(self.server.child_pipe) as child_pipe:
1149
logger.info(u"TCP connection from: %s",
1150
unicode(self.client_address))
1151
logger.debug(u"Pipe FD: %d",
1152
self.server.child_pipe.fileno())
1153
757
logger.info(u"TCP connection from: %s",
758
unicode(self.client_address))
759
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
760
# Open IPC pipe to parent process
761
with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
1154
762
session = (gnutls.connection
1155
763
.ClientSession(self.request,
1156
764
gnutls.connection
1157
765
.X509Credentials()))
1158
766
767
line = self.request.makefile().readline()
768
logger.debug(u"Protocol version: %r", line)
769
try:
770
if int(line.strip().split()[0]) > 1:
771
raise RuntimeError
772
except (ValueError, IndexError, RuntimeError), error:
773
logger.error(u"Unknown protocol version: %s", error)
774
return
775
1159
776
# Note: gnutls.connection.X509Credentials is really a
1160
777
# generic GnuTLS certificate credentials object so long as
1161
778
# no X.509 keys are added to it. Therefore, we can use it
1162
779
# here despite using OpenPGP certificates.
1163
780
1164
781
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1165
782
# u"+AES-256-CBC", u"+SHA1",
1166
783
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1172
789
(gnutls.library.functions
1173
790
.gnutls_priority_set_direct(session._c_object,
1174
791
priority, None))
1175
1176
# Start communication using the Mandos protocol
1177
# Get protocol number
1178
line = self.request.makefile().readline()
1179
logger.debug(u"Protocol version: %r", line)
1180
try:
1181
if int(line.strip().split()[0]) > 1:
1182
raise RuntimeError
1183
except (ValueError, IndexError, RuntimeError), error:
1184
logger.error(u"Unknown protocol version: %s", error)
1185
return
1186
1187
# Start GnuTLS connection
792
1188
793
try:
1189
794
session.handshake()
1190
795
except gnutls.errors.GNUTLSError, error:
1193
798
# established. Just abandon the request.
1194
799
return
1195
800
logger.debug(u"Handshake succeeded")
1196
1197
approval_required = False
1198
801
try:
1199
try:
1200
fpr = self.fingerprint(self.peer_certificate
1201
(session))
1202
except (TypeError, gnutls.errors.GNUTLSError), error:
1203
logger.warning(u"Bad certificate: %s", error)
1204
return
1205
logger.debug(u"Fingerprint: %s", fpr)
1206
1207
try:
1208
client = ProxyClient(child_pipe, fpr,
1209
self.client_address)
1210
except KeyError:
1211
return
1212
1213
if client.approval_delay:
1214
delay = client.approval_delay
1215
client.approvals_pending += 1
1216
approval_required = True
1217
1218
while True:
1219
if not client.enabled:
1220
logger.warning(u"Client %s is disabled",
1221
client.name)
1222
if self.server.use_dbus:
1223
# Emit D-Bus signal
1224
client.Rejected("Disabled")
1225
return
1226
1227
if client._approved or not client.approval_delay:
1228
#We are approved or approval is disabled
1229
break
1230
elif client._approved is None:
1231
logger.info(u"Client %s needs approval",
1232
client.name)
1233
if self.server.use_dbus:
1234
# Emit D-Bus signal
1235
client.NeedApproval(
1236
client.approval_delay_milliseconds(),
1237
client.approved_by_default)
1238
else:
1239
logger.warning(u"Client %s was not approved",
1240
client.name)
1241
if self.server.use_dbus:
1242
# Emit D-Bus signal
1243
client.Rejected("Denied")
1244
return
1245
1246
#wait until timeout or approved
1247
#x = float(client._timedelta_to_milliseconds(delay))
1248
time = datetime.datetime.now()
1249
client.changedstate.acquire()
1250
client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))
1251
client.changedstate.release()
1252
time2 = datetime.datetime.now()
1253
if (time2 - time) >= delay:
1254
if not client.approved_by_default:
1255
logger.warning("Client %s timed out while"
1256
" waiting for approval",
1257
client.name)
1258
if self.server.use_dbus:
1259
# Emit D-Bus signal
1260
client.Rejected("Approval timed out")
1261
return
1262
else:
1263
break
1264
else:
1265
delay -= time2 - time
1266
1267
sent_size = 0
1268
while sent_size < len(client.secret):
1269
try:
1270
sent = session.send(client.secret[sent_size:])
1271
except (gnutls.errors.GNUTLSError), error:
1272
logger.warning("gnutls send failed")
1273
return
1274
logger.debug(u"Sent: %d, remaining: %d",
1275
sent, len(client.secret)
1276
- (sent_size + sent))
1277
sent_size += sent
1278
1279
logger.info(u"Sending secret to %s", client.name)
1280
# bump the timeout as if seen
1281
client.checked_ok()
1282
if self.server.use_dbus:
1283
# Emit D-Bus signal
1284
client.GotSecret()
802
fpr = self.fingerprint(self.peer_certificate(session))
803
except (TypeError, gnutls.errors.GNUTLSError), error:
804
logger.warning(u"Bad certificate: %s", error)
805
session.bye()
806
return
807
logger.debug(u"Fingerprint: %s", fpr)
1285
808
1286
finally:
1287
if approval_required:
1288
client.approvals_pending -= 1
1289
try:
1290
session.bye()
1291
except (gnutls.errors.GNUTLSError), error:
1292
logger.warning("GnuTLS bye failed")
809
for c in self.server.clients:
810
if c.fingerprint == fpr:
811
client = c
812
break
813
else:
814
ipc.write(u"NOTFOUND %s\n" % fpr)
815
session.bye()
816
return
817
# Have to check if client.still_valid(), since it is
818
# possible that the client timed out while establishing
819
# the GnuTLS session.
820
if not client.still_valid():
821
ipc.write(u"INVALID %s\n" % client.name)
822
session.bye()
823
return
824
ipc.write(u"SENDING %s\n" % client.name)
825
sent_size = 0
826
while sent_size < len(client.secret):
827
sent = session.send(client.secret[sent_size:])
828
logger.debug(u"Sent: %d, remaining: %d",
829
sent, len(client.secret)
830
- (sent_size + sent))
831
sent_size += sent
832
session.bye()
1293
833
1294
834
@staticmethod
1295
835
def peer_certificate(session):
1355
895
return hex_fpr
1356
896
1357
897
1358
class MultiprocessingMixIn(object):
1359
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1360
def sub_process_main(self, request, address):
1361
try:
1362
self.finish_request(request, address)
1363
except:
1364
self.handle_error(request, address)
1365
self.close_request(request)
1366
1367
def process_request(self, request, address):
1368
"""Start a new process to process the request."""
1369
multiprocessing.Process(target = self.sub_process_main,
1370
args = (request, address)).start()
1371
1372
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1373
""" adds a pipe to the MixIn """
898
class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):
899
"""Like socketserver.ForkingMixIn, but also pass a pipe."""
1374
900
def process_request(self, request, client_address):
1375
901
"""Overrides and wraps the original process_request().
1376
902
1377
This function creates a new pipe in self.pipe
903
This function creates a new pipe in self.pipe
1378
904
"""
1379
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1380
1381
super(MultiprocessingMixInWithPipe,
905
self.pipe = os.pipe()
906
super(ForkingMixInWithPipe,
1382
907
self).process_request(request, client_address)
1383
self.child_pipe.close()
1384
self.add_pipe(parent_pipe)
1385
1386
def add_pipe(self, parent_pipe):
908
os.close(self.pipe[1]) # close write end
909
self.add_pipe(self.pipe[0])
910
def add_pipe(self, pipe):
1387
911
"""Dummy function; override as necessary"""
1388
pass
1389
1390
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
912
os.close(pipe)
913
914
915
class IPv6_TCPServer(ForkingMixInWithPipe,
1391
916
socketserver.TCPServer, object):
1392
917
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1393
918
1457
982
clients: set of Client objects
1458
983
gnutls_priority GnuTLS priority string
1459
984
use_dbus: Boolean; to emit D-Bus signals or not
985
clients: set of Client objects
986
gnutls_priority GnuTLS priority string
987
use_dbus: Boolean; to emit D-Bus signals or not
1460
988
1461
989
Assumes a gobject.MainLoop event loop.
1462
990
"""
1478
1006
return socketserver.TCPServer.server_activate(self)
1479
1007
def enable(self):
1480
1008
self.enabled = True
1481
def add_pipe(self, parent_pipe):
1009
def add_pipe(self, pipe):
1482
1010
# Call "handle_ipc" for both data and EOF events
1483
gobject.io_add_watch(parent_pipe.fileno(),
1484
gobject.IO_IN | gobject.IO_HUP,
1485
functools.partial(self.handle_ipc,
1486
parent_pipe = parent_pipe))
1487
1488
def handle_ipc(self, source, condition, parent_pipe=None,
1489
client_object=None):
1011
gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
1012
self.handle_ipc)
1013
def handle_ipc(self, source, condition, file_objects={}):
1490
1014
condition_names = {
1491
1015
gobject.IO_IN: u"IN", # There is data to read.
1492
1016
gobject.IO_OUT: u"OUT", # Data can be written (without
1501
1025
for cond, name in
1502
1026
condition_names.iteritems()
1503
1027
if cond & condition)
1504
# error or the other end of multiprocessing.Pipe has closed
1505
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1506
return False
1507
1508
# Read a request from the child
1509
request = parent_pipe.recv()
1510
command = request[0]
1511
1512
if command == 'init':
1513
fpr = request[1]
1514
address = request[2]
1515
1516
for c in self.clients:
1517
if c.fingerprint == fpr:
1518
client = c
1519
break
1520
else:
1521
logger.warning(u"Client not found for fingerprint: %s, ad"
1522
u"dress: %s", fpr, address)
1523
if self.use_dbus:
1524
# Emit D-Bus signal
1525
mandos_dbus_service.ClientNotFound(fpr, address[0])
1526
parent_pipe.send(False)
1527
return False
1528
1529
gobject.io_add_watch(parent_pipe.fileno(),
1530
gobject.IO_IN | gobject.IO_HUP,
1531
functools.partial(self.handle_ipc,
1532
parent_pipe = parent_pipe,
1533
client_object = client))
1534
parent_pipe.send(True)
1535
# remove the old hook in favor of the new above hook on same fileno
1536
return False
1537
if command == 'funcall':
1538
funcname = request[1]
1539
args = request[2]
1540
kwargs = request[3]
1541
1542
parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))
1543
1544
if command == 'getattr':
1545
attrname = request[1]
1546
if callable(client_object.__getattribute__(attrname)):
1547
parent_pipe.send(('function',))
1548
else:
1549
parent_pipe.send(('data', client_object.__getattribute__(attrname)))
1550
1551
if command == 'setattr':
1552
attrname = request[1]
1553
value = request[2]
1554
setattr(client_object, attrname, value)
1555
1028
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1029
conditions_string)
1030
1031
# Turn the pipe file descriptor into a Python file object
1032
if source not in file_objects:
1033
file_objects[source] = os.fdopen(source, u"r", 1)
1034
1035
# Read a line from the file object
1036
cmdline = file_objects[source].readline()
1037
if not cmdline: # Empty line means end of file
1038
# close the IPC pipe
1039
file_objects[source].close()
1040
del file_objects[source]
1041
1042
# Stop calling this function
1043
return False
1044
1045
logger.debug(u"IPC command: %r", cmdline)
1046
1047
# Parse and act on command
1048
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1049
1050
if cmd == u"NOTFOUND":
1051
logger.warning(u"Client not found for fingerprint: %s",
1052
args)
1053
if self.use_dbus:
1054
# Emit D-Bus signal
1055
mandos_dbus_service.ClientNotFound(args)
1056
elif cmd == u"INVALID":
1057
for client in self.clients:
1058
if client.name == args:
1059
logger.warning(u"Client %s is invalid", args)
1060
if self.use_dbus:
1061
# Emit D-Bus signal
1062
client.Rejected()
1063
break
1064
else:
1065
logger.error(u"Unknown client %s is invalid", args)
1066
elif cmd == u"SENDING":
1067
for client in self.clients:
1068
if client.name == args:
1069
logger.info(u"Sending secret to %s", client.name)
1070
client.checked_ok()
1071
if self.use_dbus:
1072
# Emit D-Bus signal
1073
client.ReceivedSecret()
1074
break
1075
else:
1076
logger.error(u"Sending secret to unknown client %s",
1077
args)
1078
else:
1079
logger.error(u"Unknown IPC command: %r", cmdline)
1080
1081
# Keep calling this function
1556
1082
return True
1557
1083
1558
1084
1588
1114
elif suffix == u"w":
1589
1115
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1590
1116
else:
1591
raise ValueError(u"Unknown suffix %r" % suffix)
1592
except (ValueError, IndexError), e:
1593
raise ValueError(e.message)
1117
raise ValueError
1118
except (ValueError, IndexError):
1119
raise ValueError
1594
1120
timevalue += delta
1595
1121
return timevalue
1596
1122
1609
1135
def if_nametoindex(interface):
1610
1136
"Get an interface index the hard way, i.e. using fcntl()"
1611
1137
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1612
with contextlib.closing(socket.socket()) as s:
1138
with closing(socket.socket()) as s:
1613
1139
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1614
1140
struct.pack(str(u"16s16x"),
1615
1141
interface))
1635
1161
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1636
1162
if not stat.S_ISCHR(os.fstat(null).st_mode):
1637
1163
raise OSError(errno.ENODEV,
1638
u"%s not a character device"
1639
% os.path.devnull)
1164
u"/dev/null not a character device")
1640
1165
os.dup2(null, sys.stdin.fileno())
1641
1166
os.dup2(null, sys.stdout.fileno())
1642
1167
os.dup2(null, sys.stderr.fileno())
1646
1171
1647
1172
def main():
1648
1173
1649
##################################################################
1174
######################################################################
1650
1175
# Parsing of options, both command line and config file
1651
1176
1652
1177
parser = optparse.OptionParser(version = "%%prog %s" % version)
1661
1186
parser.add_option("--debug", action=u"store_true",
1662
1187
help=u"Debug mode; run in foreground and log to"
1663
1188
u" terminal")
1664
parser.add_option("--debuglevel", type=u"string", metavar="Level",
1665
help=u"Debug level for stdout output")
1666
1189
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1667
1190
u" priority string (see GnuTLS documentation)")
1668
1191
parser.add_option("--servicename", type=u"string",
1693
1216
u"servicename": u"Mandos",
1694
1217
u"use_dbus": u"True",
1695
1218
u"use_ipv6": u"True",
1696
u"debuglevel": u"",
1697
1219
}
1698
1220
1699
1221
# Parse config file for server-global settings
1716
1238
# options, if set.
1717
1239
for option in (u"interface", u"address", u"port", u"debug",
1718
1240
u"priority", u"servicename", u"configdir",
1719
u"use_dbus", u"use_ipv6", u"debuglevel"):
1241
u"use_dbus", u"use_ipv6"):
1720
1242
value = getattr(options, option)
1721
1243
if value is not None:
1722
1244
server_settings[option] = value
1731
1253
1732
1254
# For convenience
1733
1255
debug = server_settings[u"debug"]
1734
debuglevel = server_settings[u"debuglevel"]
1735
1256
use_dbus = server_settings[u"use_dbus"]
1736
1257
use_ipv6 = server_settings[u"use_ipv6"]
1737
1258
1259
if not debug:
1260
syslogger.setLevel(logging.WARNING)
1261
console.setLevel(logging.WARNING)
1262
1738
1263
if server_settings[u"servicename"] != u"Mandos":
1739
1264
syslogger.setFormatter(logging.Formatter
1740
1265
(u'Mandos (%s) [%%(process)d]:'
1746
1271
u"interval": u"5m",
1747
1272
u"checker": u"fping -q -- %%(host)s",
1748
1273
u"host": u"",
1749
u"approval_delay": u"0s",
1750
u"approval_duration": u"1s",
1751
1274
}
1752
1275
client_config = configparser.SafeConfigParser(client_defaults)
1753
1276
client_config.read(os.path.join(server_settings[u"configdir"],
1759
1282
tcp_server = MandosServer((server_settings[u"address"],
1760
1283
server_settings[u"port"]),
1761
1284
ClientHandler,
1762
interface=(server_settings[u"interface"]
1763
or None),
1285
interface=server_settings[u"interface"],
1764
1286
use_ipv6=use_ipv6,
1765
1287
gnutls_priority=
1766
1288
server_settings[u"priority"],
1767
1289
use_dbus=use_dbus)
1768
if not debug:
1769
pidfilename = u"/var/run/mandos.pid"
1770
try:
1771
pidfile = open(pidfilename, u"w")
1772
except IOError:
1773
logger.error(u"Could not open file %r", pidfilename)
1290
pidfilename = u"/var/run/mandos.pid"
1291
try:
1292
pidfile = open(pidfilename, u"w")
1293
except IOError:
1294
logger.error(u"Could not open file %r", pidfilename)
1774
1295
1775
1296
try:
1776
1297
uid = pwd.getpwnam(u"_mandos").pw_uid
1793
1314
if error[0] != errno.EPERM:
1794
1315
raise error
1795
1316
1796
if not debug and not debuglevel:
1797
syslogger.setLevel(logging.WARNING)
1798
console.setLevel(logging.WARNING)
1799
if debuglevel:
1800
level = getattr(logging, debuglevel.upper())
1801
syslogger.setLevel(level)
1802
console.setLevel(level)
1803
1317
# Enable all possible GnuTLS debugging
1804
1318
if debug:
1805
# Enable all possible GnuTLS debugging
1806
1807
1319
# "Use a log level over 10 to enable all debugging options."
1808
1320
# - GnuTLS manual
1809
1321
gnutls.library.functions.gnutls_global_set_log_level(11)
1814
1326
1815
1327
(gnutls.library.functions
1816
1328
.gnutls_global_set_log_function(debug_gnutls))
1817
1818
# Redirect stdin so all checkers get /dev/null
1819
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1820
os.dup2(null, sys.stdin.fileno())
1821
if null > 2:
1822
os.close(null)
1823
else:
1824
# No console logging
1825
logger.removeHandler(console)
1826
1827
1329
1828
1330
global main_loop
1829
1331
# From the Avahi example code
1832
1334
bus = dbus.SystemBus()
1833
1335
# End of Avahi example code
1834
1336
if use_dbus:
1835
try:
1836
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1837
bus, do_not_queue=True)
1838
except dbus.exceptions.NameExistsException, e:
1839
logger.error(unicode(e) + u", disabling D-Bus")
1840
use_dbus = False
1841
server_settings[u"use_dbus"] = False
1842
tcp_server.use_dbus = False
1337
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1843
1338
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1844
1339
service = AvahiService(name = server_settings[u"servicename"],
1845
1340
servicetype = u"_mandos._tcp",
1847
1342
if server_settings["interface"]:
1848
1343
service.interface = (if_nametoindex
1849
1344
(str(server_settings[u"interface"])))
1850
1851
if not debug:
1852
# Close all input and output, do double fork, etc.
1853
daemon()
1854
1855
global multiprocessing_manager
1856
multiprocessing_manager = multiprocessing.Manager()
1857
1345
1858
1346
client_class = Client
1859
1347
if use_dbus:
1860
1348
client_class = functools.partial(ClientDBus, bus = bus)
1861
def client_config_items(config, section):
1862
special_settings = {
1863
"approved_by_default":
1864
lambda: config.getboolean(section,
1865
"approved_by_default"),
1866
}
1867
for name, value in config.items(section):
1868
try:
1869
yield (name, special_settings[name]())
1870
except KeyError:
1871
yield (name, value)
1872
1873
1349
tcp_server.clients.update(set(
1874
1350
client_class(name = section,
1875
config= dict(client_config_items(
1876
client_config, section)))
1351
config= dict(client_config.items(section)))
1877
1352
for section in client_config.sections()))
1878
1353
if not tcp_server.clients:
1879
1354
logger.warning(u"No clients defined")
1355
1356
if debug:
1357
# Redirect stdin so all checkers get /dev/null
1358
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1359
os.dup2(null, sys.stdin.fileno())
1360
if null > 2:
1361
os.close(null)
1362
else:
1363
# No console logging
1364
logger.removeHandler(console)
1365
# Close all input and output, do double fork, etc.
1366
daemon()
1367
1368
try:
1369
with closing(pidfile):
1370
pid = os.getpid()
1371
pidfile.write(str(pid) + "\n")
1372
del pidfile
1373
except IOError:
1374
logger.error(u"Could not write to file %r with PID %d",
1375
pidfilename, pid)
1376
except NameError:
1377
# "pidfile" was never created
1378
pass
1379
del pidfilename
1380
1381
def cleanup():
1382
"Cleanup function; run on exit"
1383
service.cleanup()
1880
1384
1385
while tcp_server.clients:
1386
client = tcp_server.clients.pop()
1387
client.disable_hook = None
1388
client.disable()
1389
1390
atexit.register(cleanup)
1391
1881
1392
if not debug:
1882
try:
1883
with pidfile:
1884
pid = os.getpid()
1885
pidfile.write(str(pid) + "\n")
1886
del pidfile
1887
except IOError:
1888
logger.error(u"Could not write to file %r with PID %d",
1889
pidfilename, pid)
1890
except NameError:
1891
# "pidfile" was never created
1892
pass
1893
del pidfilename
1894
1895
1393
signal.signal(signal.SIGINT, signal.SIG_IGN)
1896
1897
1394
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1898
1395
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1899
1396
1904
1401
dbus.service.Object.__init__(self, bus, u"/")
1905
1402
_interface = u"se.bsnet.fukt.Mandos"
1906
1403
1907
@dbus.service.signal(_interface, signature=u"o")
1908
def ClientAdded(self, objpath):
1404
@dbus.service.signal(_interface, signature=u"oa{sv}")
1405
def ClientAdded(self, objpath, properties):
1909
1406
"D-Bus signal"
1910
1407
pass
1911
1408
1912
@dbus.service.signal(_interface, signature=u"ss")
1913
def ClientNotFound(self, fingerprint, address):
1409
@dbus.service.signal(_interface, signature=u"s")
1410
def ClientNotFound(self, fingerprint):
1914
1411
"D-Bus signal"
1915
1412
pass
1916
1413
1930
1427
def GetAllClientsWithProperties(self):
1931
1428
"D-Bus method"
1932
1429
return dbus.Dictionary(
1933
((c.dbus_object_path, c.GetAll(u""))
1430
((c.dbus_object_path, c.GetAllProperties())
1934
1431
for c in tcp_server.clients),
1935
1432
signature=u"oa{sv}")
1936
1433
1942
1439
tcp_server.clients.remove(c)
1943
1440
c.remove_from_connection()
1944
1441
# Don't signal anything except ClientRemoved
1945
c.disable(quiet=True)
1442
c.disable(signal=False)
1946
1443
# Emit D-Bus signal
1947
1444
self.ClientRemoved(object_path, c.name)
1948
1445
return
1949
raise KeyError(object_path)
1446
raise KeyError
1950
1447
1951
1448
del _interface
1952
1449
1953
1450
mandos_dbus_service = MandosDBusService()
1954
1451
1955
def cleanup():
1956
"Cleanup function; run on exit"
1957
service.cleanup()
1958
1959
while tcp_server.clients:
1960
client = tcp_server.clients.pop()
1961
if use_dbus:
1962
client.remove_from_connection()
1963
client.disable_hook = None
1964
# Don't signal anything except ClientRemoved
1965
client.disable(quiet=True)
1966
if use_dbus:
1967
# Emit D-Bus signal
1968
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
1969
client.name)
1970
1971
atexit.register(cleanup)
1972
1973
1452
for client in tcp_server.clients:
1974
1453
if use_dbus:
1975
1454
# Emit D-Bus signal
1976
mandos_dbus_service.ClientAdded(client.dbus_object_path)
1455
mandos_dbus_service.ClientAdded(client.dbus_object_path,
1456
client.GetAllProperties())
1977
1457
client.enable()
1978
1458
1979
1459
tcp_server.enable()
1997
1477
service.activate()
1998
1478
except dbus.exceptions.DBusException, error:
1999
1479
logger.critical(u"DBusException: %s", error)
2000
cleanup()
2001
1480
sys.exit(1)
2002
1481
# End of Avahi example code
2003
1482
2010
1489
main_loop.run()
2011
1490
except AvahiError, error:
2012
1491
logger.critical(u"AvahiError: %s", error)
2013
cleanup()
2014
1492
sys.exit(1)
2015
1493
except KeyboardInterrupt:
2016
1494
if debug:
2017
1495
print >> sys.stderr
2018
1496
logger.debug(u"Server received KeyboardInterrupt")
2019
1497
logger.debug(u"Server exiting")
2020
# Must run before the D-Bus bus name gets deregistered
2021
cleanup()
2022
1498
2023
1499
if __name__ == '__main__':
2024
1500
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0