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 441
- compare with another revision
- download diff
- download tarball
- view history from revision 441
- Committer: Teddy Hogeborn
- Date: 2010-09-25 23:52:17 UTC
- Revision ID: teddy@fukt.bsnet.se-20100925235217-4hhqfryz1ste6uw3
* mandos (ClientDBus.__init__): Bug fix: Translate "-" in client names
to "_" in D-Bus object paths.
(MandosServer.handle_ipc): Bug fix: Send only address string to
D-Bus signal, not whole tuple.
* mandos-ctl: New options "--approve-by-default", "--deny-by-default",
"--approval-delay", and "--approval-duration".
* mandos-ctl.xml (SYNOPSIS, OPTIONS): Document new options.
* mandos-monitor (MandosClientWidget.update): Fix spelling.
to "_" in D-Bus object paths.
(MandosServer.handle_ipc): Bug fix: Send only address string to
D-Bus signal, not whole tuple.
* mandos-ctl: New options "--approve-by-default", "--deny-by-default",
"--approval-delay", and "--approval-duration".
* mandos-ctl.xml (SYNOPSIS, OPTIONS): Document new options.
* mandos-monitor (MandosClientWidget.update): Fix spelling.
added
removed
mandos
55
55
import logging
56
56
import logging.handlers
57
57
import pwd
58
from contextlib import closing
58
import contextlib
59
59
import struct
60
60
import fcntl
61
61
import functools
62
import cPickle as pickle
63
import multiprocessing
62
64
63
65
import dbus
64
66
import dbus.service
81
83
82
84
version = "1.0.14"
83
85
86
#logger = logging.getLogger(u'mandos')
84
87
logger = logging.Logger(u'mandos')
85
88
syslogger = (logging.handlers.SysLogHandler
86
89
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
154
157
u" after %i retries, exiting.",
155
158
self.rename_count)
156
159
raise AvahiServiceError(u"Too many renames")
157
self.name = self.server.GetAlternativeServiceName(self.name)
160
self.name = unicode(self.server.GetAlternativeServiceName(self.name))
158
161
logger.info(u"Changing Zeroconf service name to %r ...",
159
unicode(self.name))
162
self.name)
160
163
syslogger.setFormatter(logging.Formatter
161
164
(u'Mandos (%s) [%%(process)d]:'
162
165
u' %%(levelname)s: %%(message)s'
163
166
% self.name))
164
167
self.remove()
165
self.add()
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)
166
174
self.rename_count += 1
167
175
def remove(self):
168
176
"""Derived from the Avahi example code"""
191
199
self.group.Commit()
192
200
def entry_group_state_changed(self, state, error):
193
201
"""Derived from the Avahi example code"""
194
logger.debug(u"Avahi state change: %i", state)
202
logger.debug(u"Avahi entry group state change: %i", state)
195
203
196
204
if state == avahi.ENTRY_GROUP_ESTABLISHED:
197
205
logger.debug(u"Zeroconf service established.")
210
218
self.group = None
211
219
def server_state_changed(self, state):
212
220
"""Derived from the Avahi example code"""
221
logger.debug(u"Avahi server state change: %i", state)
213
222
if state == avahi.SERVER_COLLISION:
214
223
logger.error(u"Zeroconf server name collision")
215
224
self.remove()
231
240
"""A representation of a client host served by this server.
232
241
233
242
Attributes:
234
name: string; from the config file, used in log messages and
235
D-Bus identifiers
236
fingerprint: string (40 or 32 hexadecimal digits); used to
237
uniquely identify the client
238
secret: bytestring; sent verbatim (over TLS) to client
239
host: string; available for use by the checker command
240
created: datetime.datetime(); (UTC) object creation
241
last_enabled: datetime.datetime(); (UTC)
242
enabled: bool()
243
last_checked_ok: datetime.datetime(); (UTC) or None
244
timeout: datetime.timedelta(); How long from last_checked_ok
245
until this client is invalid
246
interval: datetime.timedelta(); How often to start a new checker
247
disable_hook: If set, called by disable() as disable_hook(self)
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
248
246
checker: subprocess.Popen(); a running checker process used
249
247
to see if the client lives.
250
248
'None' if no process is running.
251
checker_initiator_tag: a gobject event source tag, or None
252
disable_initiator_tag: - '' -
253
249
checker_callback_tag: - '' -
254
checker_command: string; External command which is run to check if
255
client lives. %() expansions are done at
250
checker_command: string; External command which is run to check
251
if client lives. %() expansions are done at
256
252
runtime with vars(self) as dict, so that for
257
253
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
258
256
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.
259
272
"""
260
273
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
261
279
@staticmethod
262
280
def _timedelta_to_milliseconds(td):
263
281
"Convert a datetime.timedelta() to milliseconds"
272
290
def interval_milliseconds(self):
273
291
"Return the 'interval' attribute in milliseconds"
274
292
return self._timedelta_to_milliseconds(self.interval)
293
294
def approval_delay_milliseconds(self):
295
return self._timedelta_to_milliseconds(self.approval_delay)
275
296
276
297
def __init__(self, name = None, disable_hook=None, config=None):
277
298
"""Note: the 'checker' key in 'config' sets the
290
311
if u"secret" in config:
291
312
self.secret = config[u"secret"].decode(u"base64")
292
313
elif u"secfile" in config:
293
with closing(open(os.path.expanduser
294
(os.path.expandvars
295
(config[u"secfile"])),
296
"rb")) as secfile:
314
with open(os.path.expanduser(os.path.expandvars
315
(config[u"secfile"])),
316
"rb") as secfile:
297
317
self.secret = secfile.read()
298
318
else:
299
319
raise TypeError(u"No secret or secfile for client %s"
313
333
self.checker_command = config[u"checker"]
314
334
self.current_checker_command = None
315
335
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())
316
345
346
def send_changedstate(self):
347
self.changedstate.acquire()
348
self.changedstate.notify_all()
349
self.changedstate.release()
350
317
351
def enable(self):
318
352
"""Start this client's checker and timeout hooks"""
319
353
if getattr(self, u"enabled", False):
320
354
# Already enabled
321
355
return
356
self.send_changedstate()
322
357
self.last_enabled = datetime.datetime.utcnow()
323
358
# Schedule a new checker to be started an 'interval' from now,
324
359
# and every interval from then on.
338
373
if not getattr(self, "enabled", False):
339
374
return False
340
375
if not quiet:
376
self.send_changedstate()
377
if not quiet:
341
378
logger.info(u"Disabling client %s", self.name)
342
379
if getattr(self, u"disable_initiator_tag", False):
343
380
gobject.source_remove(self.disable_initiator_tag)
396
433
# client would inevitably timeout, since no checker would get
397
434
# a chance to run to completion. If we instead leave running
398
435
# checkers alone, the checker would have to take more time
399
# than 'timeout' for the client to be declared invalid, which
400
# is as it should be.
436
# than 'timeout' for the client to be disabled, which is as it
437
# should be.
401
438
402
439
# If a checker exists, make sure it is not a zombie
403
440
try:
419
456
command = self.checker_command % self.host
420
457
except TypeError:
421
458
# Escape attributes for the shell
422
escaped_attrs = dict((key,
423
re.escape(unicode(str(val),
424
errors=
425
u'replace')))
426
for key, val in
427
vars(self).iteritems())
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
428
467
try:
429
468
command = self.checker_command % escaped_attrs
430
469
except TypeError, error:
475
514
if error.errno != errno.ESRCH: # No such process
476
515
raise
477
516
self.checker = None
478
479
def still_valid(self):
480
"""Has the timeout not yet passed for this client?"""
481
if not getattr(self, u"enabled", False):
482
return False
483
now = datetime.datetime.utcnow()
484
if self.last_checked_ok is None:
485
return now < (self.created + self.timeout)
486
else:
487
return now < (self.last_checked_ok + self.timeout)
488
489
517
490
518
def dbus_service_property(dbus_interface, signature=u"v",
491
519
access=u"readwrite", byte_arrays=False):
499
527
dbus.service.method, except there is only "signature", since the
500
528
type from Get() and the type sent to Set() is the same.
501
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)
502
535
def decorator(func):
503
536
func._dbus_is_property = True
504
537
func._dbus_interface = dbus_interface
590
623
if prop._dbus_access == u"read":
591
624
raise DBusPropertyAccessException(property_name)
592
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
593
630
value = dbus.ByteArray(''.join(unichr(byte)
594
631
for byte in value))
595
632
prop(value)
674
711
dbus_object_path: dbus.ObjectPath
675
712
bus: dbus.SystemBus()
676
713
"""
714
715
runtime_expansions = (Client.runtime_expansions
716
+ (u"dbus_object_path",))
717
677
718
# dbus.service.Object doesn't use super(), so we can't either.
678
719
679
720
def __init__(self, bus = None, *args, **kwargs):
721
self._approvals_pending = 0
680
722
self.bus = bus
681
723
Client.__init__(self, *args, **kwargs)
682
724
# Only now, when this client is initialized, can it show up on
683
725
# the D-Bus
726
client_object_name = unicode(self.name).translate(
727
{ord(u"."): ord(u"_"),
728
ord(u"-"): ord(u"_")})
684
729
self.dbus_object_path = (dbus.ObjectPath
685
(u"/clients/"
686
+ self.name.replace(u".", u"_")))
730
(u"/clients/" + client_object_name))
687
731
DBusObjectWithProperties.__init__(self, self.bus,
688
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
689
749
690
750
@staticmethod
691
751
def _datetime_to_dbus(dt, variant_level=0):
698
758
r = Client.enable(self)
699
759
if oldstate != self.enabled:
700
760
# Emit D-Bus signals
701
self.PropertyChanged(dbus.String(u"enabled"),
761
self.PropertyChanged(dbus.String(u"Enabled"),
702
762
dbus.Boolean(True, variant_level=1))
703
763
self.PropertyChanged(
704
dbus.String(u"last_enabled"),
764
dbus.String(u"LastEnabled"),
705
765
self._datetime_to_dbus(self.last_enabled,
706
766
variant_level=1))
707
767
return r
711
771
r = Client.disable(self, quiet=quiet)
712
772
if not quiet and oldstate != self.enabled:
713
773
# Emit D-Bus signal
714
self.PropertyChanged(dbus.String(u"enabled"),
774
self.PropertyChanged(dbus.String(u"Enabled"),
715
775
dbus.Boolean(False, variant_level=1))
716
776
return r
717
777
729
789
self.checker_callback_tag = None
730
790
self.checker = None
731
791
# Emit D-Bus signal
732
self.PropertyChanged(dbus.String(u"checker_running"),
792
self.PropertyChanged(dbus.String(u"CheckerRunning"),
733
793
dbus.Boolean(False, variant_level=1))
734
794
if os.WIFEXITED(condition):
735
795
exitstatus = os.WEXITSTATUS(condition)
750
810
r = Client.checked_ok(self, *args, **kwargs)
751
811
# Emit D-Bus signal
752
812
self.PropertyChanged(
753
dbus.String(u"last_checked_ok"),
813
dbus.String(u"LastCheckedOK"),
754
814
(self._datetime_to_dbus(self.last_checked_ok,
755
815
variant_level=1)))
756
816
return r
768
828
# Emit D-Bus signal
769
829
self.CheckerStarted(self.current_checker_command)
770
830
self.PropertyChanged(
771
dbus.String(u"checker_running"),
831
dbus.String(u"CheckerRunning"),
772
832
dbus.Boolean(True, variant_level=1))
773
833
return r
774
834
777
837
r = Client.stop_checker(self, *args, **kwargs)
778
838
if (old_checker is not None
779
839
and getattr(self, u"checker", None) is None):
780
self.PropertyChanged(dbus.String(u"checker_running"),
840
self.PropertyChanged(dbus.String(u"CheckerRunning"),
781
841
dbus.Boolean(False, variant_level=1))
782
842
return r
783
784
## D-Bus methods & signals
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
785
857
_interface = u"se.bsnet.fukt.Mandos.Client"
786
858
787
# CheckedOK - method
788
@dbus.service.method(_interface)
789
def CheckedOK(self):
790
return self.checked_ok()
859
## Signals
791
860
792
861
# CheckerCompleted - signal
793
862
@dbus.service.signal(_interface, signature=u"nxs")
810
879
# GotSecret - signal
811
880
@dbus.service.signal(_interface)
812
881
def GotSecret(self):
813
"D-Bus signal"
882
"""D-Bus signal
883
Is sent after a successful transfer of secret from the Mandos
884
server to mandos-client
885
"""
814
886
pass
815
887
816
888
# Rejected - signal
817
@dbus.service.signal(_interface)
818
def Rejected(self):
819
"D-Bus signal"
820
pass
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()
821
911
822
912
# Enable - method
823
913
@dbus.service.method(_interface)
842
932
def StopChecker(self):
843
933
self.stop_checker()
844
934
845
# name - property
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
846
977
@dbus_service_property(_interface, signature=u"s", access=u"read")
847
def name_dbus_property(self):
978
def Name_dbus_property(self):
848
979
return dbus.String(self.name)
849
980
850
# fingerprint - property
981
# Fingerprint - property
851
982
@dbus_service_property(_interface, signature=u"s", access=u"read")
852
def fingerprint_dbus_property(self):
983
def Fingerprint_dbus_property(self):
853
984
return dbus.String(self.fingerprint)
854
985
855
# host - property
986
# Host - property
856
987
@dbus_service_property(_interface, signature=u"s",
857
988
access=u"readwrite")
858
def host_dbus_property(self, value=None):
989
def Host_dbus_property(self, value=None):
859
990
if value is None: # get
860
991
return dbus.String(self.host)
861
992
self.host = value
862
993
# Emit D-Bus signal
863
self.PropertyChanged(dbus.String(u"host"),
994
self.PropertyChanged(dbus.String(u"Host"),
864
995
dbus.String(value, variant_level=1))
865
996
866
# created - property
997
# Created - property
867
998
@dbus_service_property(_interface, signature=u"s", access=u"read")
868
def created_dbus_property(self):
999
def Created_dbus_property(self):
869
1000
return dbus.String(self._datetime_to_dbus(self.created))
870
1001
871
# last_enabled - property
1002
# LastEnabled - property
872
1003
@dbus_service_property(_interface, signature=u"s", access=u"read")
873
def last_enabled_dbus_property(self):
1004
def LastEnabled_dbus_property(self):
874
1005
if self.last_enabled is None:
875
1006
return dbus.String(u"")
876
1007
return dbus.String(self._datetime_to_dbus(self.last_enabled))
877
1008
878
# enabled - property
1009
# Enabled - property
879
1010
@dbus_service_property(_interface, signature=u"b",
880
1011
access=u"readwrite")
881
def enabled_dbus_property(self, value=None):
1012
def Enabled_dbus_property(self, value=None):
882
1013
if value is None: # get
883
1014
return dbus.Boolean(self.enabled)
884
1015
if value:
886
1017
else:
887
1018
self.disable()
888
1019
889
# last_checked_ok - property
1020
# LastCheckedOK - property
890
1021
@dbus_service_property(_interface, signature=u"s",
891
1022
access=u"readwrite")
892
def last_checked_ok_dbus_property(self, value=None):
1023
def LastCheckedOK_dbus_property(self, value=None):
893
1024
if value is not None:
894
1025
self.checked_ok()
895
1026
return
898
1029
return dbus.String(self._datetime_to_dbus(self
899
1030
.last_checked_ok))
900
1031
901
# timeout - property
1032
# Timeout - property
902
1033
@dbus_service_property(_interface, signature=u"t",
903
1034
access=u"readwrite")
904
def timeout_dbus_property(self, value=None):
1035
def Timeout_dbus_property(self, value=None):
905
1036
if value is None: # get
906
1037
return dbus.UInt64(self.timeout_milliseconds())
907
1038
self.timeout = datetime.timedelta(0, 0, 0, value)
908
1039
# Emit D-Bus signal
909
self.PropertyChanged(dbus.String(u"timeout"),
1040
self.PropertyChanged(dbus.String(u"Timeout"),
910
1041
dbus.UInt64(value, variant_level=1))
911
1042
if getattr(self, u"disable_initiator_tag", None) is None:
912
1043
return
926
1057
self.disable_initiator_tag = (gobject.timeout_add
927
1058
(time_to_die, self.disable))
928
1059
929
# interval - property
1060
# Interval - property
930
1061
@dbus_service_property(_interface, signature=u"t",
931
1062
access=u"readwrite")
932
def interval_dbus_property(self, value=None):
1063
def Interval_dbus_property(self, value=None):
933
1064
if value is None: # get
934
1065
return dbus.UInt64(self.interval_milliseconds())
935
1066
self.interval = datetime.timedelta(0, 0, 0, value)
936
1067
# Emit D-Bus signal
937
self.PropertyChanged(dbus.String(u"interval"),
1068
self.PropertyChanged(dbus.String(u"Interval"),
938
1069
dbus.UInt64(value, variant_level=1))
939
1070
if getattr(self, u"checker_initiator_tag", None) is None:
940
1071
return
944
1075
(value, self.start_checker))
945
1076
self.start_checker() # Start one now, too
946
1077
947
# checker - property
1078
# Checker - property
948
1079
@dbus_service_property(_interface, signature=u"s",
949
1080
access=u"readwrite")
950
def checker_dbus_property(self, value=None):
1081
def Checker_dbus_property(self, value=None):
951
1082
if value is None: # get
952
1083
return dbus.String(self.checker_command)
953
1084
self.checker_command = value
954
1085
# Emit D-Bus signal
955
self.PropertyChanged(dbus.String(u"checker"),
1086
self.PropertyChanged(dbus.String(u"Checker"),
956
1087
dbus.String(self.checker_command,
957
1088
variant_level=1))
958
1089
959
# checker_running - property
1090
# CheckerRunning - property
960
1091
@dbus_service_property(_interface, signature=u"b",
961
1092
access=u"readwrite")
962
def checker_running_dbus_property(self, value=None):
1093
def CheckerRunning_dbus_property(self, value=None):
963
1094
if value is None: # get
964
1095
return dbus.Boolean(self.checker is not None)
965
1096
if value:
967
1098
else:
968
1099
self.stop_checker()
969
1100
970
# object_path - property
1101
# ObjectPath - property
971
1102
@dbus_service_property(_interface, signature=u"o", access=u"read")
972
def object_path_dbus_property(self):
1103
def ObjectPath_dbus_property(self):
973
1104
return self.dbus_object_path # is already a dbus.ObjectPath
974
1105
975
# secret = property
1106
# Secret = property
976
1107
@dbus_service_property(_interface, signature=u"ay",
977
1108
access=u"write", byte_arrays=True)
978
def secret_dbus_property(self, value):
1109
def Secret_dbus_property(self, value):
979
1110
self.secret = str(value)
980
1111
981
1112
del _interface
982
1113
983
1114
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
984
1141
class ClientHandler(socketserver.BaseRequestHandler, object):
985
1142
"""A class to handle client connections.
986
1143
988
1145
Note: This will run in its own forked process."""
989
1146
990
1147
def handle(self):
991
logger.info(u"TCP connection from: %s",
992
unicode(self.client_address))
993
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
994
# Open IPC pipe to parent process
995
with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:
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
996
1154
session = (gnutls.connection
997
1155
.ClientSession(self.request,
998
1156
gnutls.connection
999
1157
.X509Credentials()))
1000
1001
line = self.request.makefile().readline()
1002
logger.debug(u"Protocol version: %r", line)
1003
try:
1004
if int(line.strip().split()[0]) > 1:
1005
raise RuntimeError
1006
except (ValueError, IndexError, RuntimeError), error:
1007
logger.error(u"Unknown protocol version: %s", error)
1008
return
1009
1158
1010
1159
# Note: gnutls.connection.X509Credentials is really a
1011
1160
# generic GnuTLS certificate credentials object so long as
1012
1161
# no X.509 keys are added to it. Therefore, we can use it
1013
1162
# here despite using OpenPGP certificates.
1014
1163
1015
1164
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1016
1165
# u"+AES-256-CBC", u"+SHA1",
1017
1166
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1023
1172
(gnutls.library.functions
1024
1173
.gnutls_priority_set_direct(session._c_object,
1025
1174
priority, None))
1026
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
1027
1188
try:
1028
1189
session.handshake()
1029
1190
except gnutls.errors.GNUTLSError, error:
1032
1193
# established. Just abandon the request.
1033
1194
return
1034
1195
logger.debug(u"Handshake succeeded")
1196
1197
approval_required = False
1035
1198
try:
1036
fpr = self.fingerprint(self.peer_certificate(session))
1037
except (TypeError, gnutls.errors.GNUTLSError), error:
1038
logger.warning(u"Bad certificate: %s", error)
1039
session.bye()
1040
return
1041
logger.debug(u"Fingerprint: %s", fpr)
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()
1042
1285
1043
for c in self.server.clients:
1044
if c.fingerprint == fpr:
1045
client = c
1046
break
1047
else:
1048
ipc.write(u"NOTFOUND %s %s\n"
1049
% (fpr, unicode(self.client_address)))
1050
session.bye()
1051
return
1052
# Have to check if client.still_valid(), since it is
1053
# possible that the client timed out while establishing
1054
# the GnuTLS session.
1055
if not client.still_valid():
1056
ipc.write(u"INVALID %s\n" % client.name)
1057
session.bye()
1058
return
1059
ipc.write(u"SENDING %s\n" % client.name)
1060
sent_size = 0
1061
while sent_size < len(client.secret):
1062
sent = session.send(client.secret[sent_size:])
1063
logger.debug(u"Sent: %d, remaining: %d",
1064
sent, len(client.secret)
1065
- (sent_size + sent))
1066
sent_size += sent
1067
session.bye()
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")
1068
1293
1069
1294
@staticmethod
1070
1295
def peer_certificate(session):
1130
1355
return hex_fpr
1131
1356
1132
1357
1133
class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):
1134
"""Like socketserver.ForkingMixIn, but also pass a pipe."""
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 """
1135
1374
def process_request(self, request, client_address):
1136
1375
"""Overrides and wraps the original process_request().
1137
1376
1138
1377
This function creates a new pipe in self.pipe
1139
1378
"""
1140
self.pipe = os.pipe()
1141
super(ForkingMixInWithPipe,
1379
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1380
1381
super(MultiprocessingMixInWithPipe,
1142
1382
self).process_request(request, client_address)
1143
os.close(self.pipe[1]) # close write end
1144
self.add_pipe(self.pipe[0])
1145
def add_pipe(self, pipe):
1383
self.child_pipe.close()
1384
self.add_pipe(parent_pipe)
1385
1386
def add_pipe(self, parent_pipe):
1146
1387
"""Dummy function; override as necessary"""
1147
os.close(pipe)
1148
1149
1150
class IPv6_TCPServer(ForkingMixInWithPipe,
1388
pass
1389
1390
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1151
1391
socketserver.TCPServer, object):
1152
1392
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1153
1393
1238
1478
return socketserver.TCPServer.server_activate(self)
1239
1479
def enable(self):
1240
1480
self.enabled = True
1241
def add_pipe(self, pipe):
1481
def add_pipe(self, parent_pipe):
1242
1482
# Call "handle_ipc" for both data and EOF events
1243
gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,
1244
self.handle_ipc)
1245
def handle_ipc(self, source, condition, file_objects={}):
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):
1246
1490
condition_names = {
1247
1491
gobject.IO_IN: u"IN", # There is data to read.
1248
1492
gobject.IO_OUT: u"OUT", # Data can be written (without
1257
1501
for cond, name in
1258
1502
condition_names.iteritems()
1259
1503
if cond & condition)
1260
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1261
conditions_string)
1262
1263
# Turn the pipe file descriptor into a Python file object
1264
if source not in file_objects:
1265
file_objects[source] = os.fdopen(source, u"r", 1)
1266
1267
# Read a line from the file object
1268
cmdline = file_objects[source].readline()
1269
if not cmdline: # Empty line means end of file
1270
# close the IPC pipe
1271
file_objects[source].close()
1272
del file_objects[source]
1273
1274
# Stop calling this function
1275
return False
1276
1277
logger.debug(u"IPC command: %r", cmdline)
1278
1279
# Parse and act on command
1280
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1281
1282
if cmd == u"NOTFOUND":
1283
logger.warning(u"Client not found for fingerprint: %s",
1284
args)
1285
if self.use_dbus:
1286
# Emit D-Bus signal
1287
mandos_dbus_service.ClientNotFound(args)
1288
elif cmd == u"INVALID":
1289
for client in self.clients:
1290
if client.name == args:
1291
logger.warning(u"Client %s is invalid", args)
1292
if self.use_dbus:
1293
# Emit D-Bus signal
1294
client.Rejected()
1295
break
1296
else:
1297
logger.error(u"Unknown client %s is invalid", args)
1298
elif cmd == u"SENDING":
1299
for client in self.clients:
1300
if client.name == args:
1301
logger.info(u"Sending secret to %s", client.name)
1302
client.checked_ok()
1303
if self.use_dbus:
1304
# Emit D-Bus signal
1305
client.GotSecret()
1306
break
1307
else:
1308
logger.error(u"Sending secret to unknown client %s",
1309
args)
1310
else:
1311
logger.error(u"Unknown IPC command: %r", cmdline)
1312
1313
# Keep calling this function
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
1314
1556
return True
1315
1557
1316
1558
1367
1609
def if_nametoindex(interface):
1368
1610
"Get an interface index the hard way, i.e. using fcntl()"
1369
1611
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1370
with closing(socket.socket()) as s:
1612
with contextlib.closing(socket.socket()) as s:
1371
1613
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1372
1614
struct.pack(str(u"16s16x"),
1373
1615
interface))
1419
1661
parser.add_option("--debug", action=u"store_true",
1420
1662
help=u"Debug mode; run in foreground and log to"
1421
1663
u" terminal")
1664
parser.add_option("--debuglevel", type=u"string", metavar="Level",
1665
help=u"Debug level for stdout output")
1422
1666
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1423
1667
u" priority string (see GnuTLS documentation)")
1424
1668
parser.add_option("--servicename", type=u"string",
1449
1693
u"servicename": u"Mandos",
1450
1694
u"use_dbus": u"True",
1451
1695
u"use_ipv6": u"True",
1696
u"debuglevel": u"",
1452
1697
}
1453
1698
1454
1699
# Parse config file for server-global settings
1471
1716
# options, if set.
1472
1717
for option in (u"interface", u"address", u"port", u"debug",
1473
1718
u"priority", u"servicename", u"configdir",
1474
u"use_dbus", u"use_ipv6"):
1719
u"use_dbus", u"use_ipv6", u"debuglevel"):
1475
1720
value = getattr(options, option)
1476
1721
if value is not None:
1477
1722
server_settings[option] = value
1486
1731
1487
1732
# For convenience
1488
1733
debug = server_settings[u"debug"]
1734
debuglevel = server_settings[u"debuglevel"]
1489
1735
use_dbus = server_settings[u"use_dbus"]
1490
1736
use_ipv6 = server_settings[u"use_ipv6"]
1491
1492
if not debug:
1493
syslogger.setLevel(logging.WARNING)
1494
console.setLevel(logging.WARNING)
1495
1737
1496
1738
if server_settings[u"servicename"] != u"Mandos":
1497
1739
syslogger.setFormatter(logging.Formatter
1498
1740
(u'Mandos (%s) [%%(process)d]:'
1504
1746
u"interval": u"5m",
1505
1747
u"checker": u"fping -q -- %%(host)s",
1506
1748
u"host": u"",
1749
u"approval_delay": u"0s",
1750
u"approval_duration": u"1s",
1507
1751
}
1508
1752
client_config = configparser.SafeConfigParser(client_defaults)
1509
1753
client_config.read(os.path.join(server_settings[u"configdir"],
1515
1759
tcp_server = MandosServer((server_settings[u"address"],
1516
1760
server_settings[u"port"]),
1517
1761
ClientHandler,
1518
interface=server_settings[u"interface"],
1762
interface=(server_settings[u"interface"]
1763
or None),
1519
1764
use_ipv6=use_ipv6,
1520
1765
gnutls_priority=
1521
1766
server_settings[u"priority"],
1522
1767
use_dbus=use_dbus)
1523
pidfilename = u"/var/run/mandos.pid"
1524
try:
1525
pidfile = open(pidfilename, u"w")
1526
except IOError:
1527
logger.error(u"Could not open file %r", pidfilename)
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)
1528
1774
1529
1775
try:
1530
1776
uid = pwd.getpwnam(u"_mandos").pw_uid
1547
1793
if error[0] != errno.EPERM:
1548
1794
raise error
1549
1795
1550
# Enable all possible GnuTLS debugging
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
1551
1804
if debug:
1805
# Enable all possible GnuTLS debugging
1806
1552
1807
# "Use a log level over 10 to enable all debugging options."
1553
1808
# - GnuTLS manual
1554
1809
gnutls.library.functions.gnutls_global_set_log_level(11)
1559
1814
1560
1815
(gnutls.library.functions
1561
1816
.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
1562
1827
1563
1828
global main_loop
1564
1829
# From the Avahi example code
1582
1847
if server_settings["interface"]:
1583
1848
service.interface = (if_nametoindex
1584
1849
(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()
1585
1857
1586
1858
client_class = Client
1587
1859
if use_dbus:
1588
1860
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
1589
1873
tcp_server.clients.update(set(
1590
1874
client_class(name = section,
1591
config= dict(client_config.items(section)))
1875
config= dict(client_config_items(
1876
client_config, section)))
1592
1877
for section in client_config.sections()))
1593
1878
if not tcp_server.clients:
1594
1879
logger.warning(u"No clients defined")
1595
1596
if debug:
1597
# Redirect stdin so all checkers get /dev/null
1598
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1599
os.dup2(null, sys.stdin.fileno())
1600
if null > 2:
1601
os.close(null)
1602
else:
1603
# No console logging
1604
logger.removeHandler(console)
1605
# Close all input and output, do double fork, etc.
1606
daemon()
1607
1608
try:
1609
with closing(pidfile):
1610
pid = os.getpid()
1611
pidfile.write(str(pid) + "\n")
1612
del pidfile
1613
except IOError:
1614
logger.error(u"Could not write to file %r with PID %d",
1615
pidfilename, pid)
1616
except NameError:
1617
# "pidfile" was never created
1618
pass
1619
del pidfilename
1620
1880
1621
1881
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
1622
1895
signal.signal(signal.SIGINT, signal.SIG_IGN)
1896
1623
1897
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1624
1898
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1625
1899
1630
1904
dbus.service.Object.__init__(self, bus, u"/")
1631
1905
_interface = u"se.bsnet.fukt.Mandos"
1632
1906
1633
@dbus.service.signal(_interface, signature=u"oa{sv}")
1634
def ClientAdded(self, objpath, properties):
1907
@dbus.service.signal(_interface, signature=u"o")
1908
def ClientAdded(self, objpath):
1635
1909
"D-Bus signal"
1636
1910
pass
1637
1911
1638
@dbus.service.signal(_interface, signature=u"s")
1639
def ClientNotFound(self, fingerprint):
1912
@dbus.service.signal(_interface, signature=u"ss")
1913
def ClientNotFound(self, fingerprint, address):
1640
1914
"D-Bus signal"
1641
1915
pass
1642
1916
1699
1973
for client in tcp_server.clients:
1700
1974
if use_dbus:
1701
1975
# Emit D-Bus signal
1702
mandos_dbus_service.ClientAdded(client.dbus_object_path,
1703
client.GetAll(u""))
1976
mandos_dbus_service.ClientAdded(client.dbus_object_path)
1704
1977
client.enable()
1705
1978
1706
1979
tcp_server.enable()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0