2
# -*- mode: python; coding: utf-8 -*-
4
# Mandos server - give out binary blobs to connecting clients.
6
# This program is partly derived from an example program for an Avahi
7
# service publisher, downloaded from
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
# methods "add", "remove", "server_state_changed",
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
# "AvahiService" class, and some lines in "main".
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 Björn Påhlsson
17
# This program is free software: you can redistribute it and/or modify
18
# it under the terms of the GNU General Public License as published by
19
# the Free Software Foundation, either version 3 of the License, or
20
# (at your option) any later version.
22
# This program is distributed in the hope that it will be useful,
23
# but WITHOUT ANY WARRANTY; without even the implied warranty of
24
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25
# GNU General Public License for more details.
27
# You should have received a copy of the GNU General Public License
28
# along with this program. If not, see
29
# <http://www.gnu.org/licenses/>.
31
# Contact the authors at <mandos@recompile.se>.
34
from __future__ import (division, absolute_import, print_function,
37
import SocketServer as socketserver
3
from __future__ import division
8
from optparse import OptionParser
42
11
import gnutls.crypto
43
12
import gnutls.connection
44
13
import gnutls.errors
45
import gnutls.library.functions
46
import gnutls.library.constants
47
import gnutls.library.types
48
import ConfigParser as configparser
57
import logging.handlers
63
import cPickle as pickle
64
import multiprocessing
71
25
from dbus.mainloop.glib import DBusGMainLoop
74
import xml.dom.minidom
78
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
79
except AttributeError:
81
from IN import SO_BINDTODEVICE
83
SO_BINDTODEVICE = None
88
#logger = logging.getLogger('mandos')
89
logger = logging.Logger('mandos')
90
syslogger = (logging.handlers.SysLogHandler
91
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
92
address = str("/dev/log")))
93
syslogger.setFormatter(logging.Formatter
94
('Mandos [%(process)d]: %(levelname)s:'
96
logger.addHandler(syslogger)
98
console = logging.StreamHandler()
99
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
102
logger.addHandler(console)
104
class AvahiError(Exception):
105
def __init__(self, value, *args, **kwargs):
107
super(AvahiError, self).__init__(value, *args, **kwargs)
108
def __unicode__(self):
109
return unicode(repr(self.value))
111
class AvahiServiceError(AvahiError):
114
class AvahiGroupError(AvahiError):
118
class AvahiService(object):
119
"""An Avahi (Zeroconf) service.
122
interface: integer; avahi.IF_UNSPEC or an interface index.
123
Used to optionally bind to the specified interface.
124
name: string; Example: 'Mandos'
125
type: string; Example: '_mandos._tcp'.
126
See <http://www.dns-sd.org/ServiceTypes.html>
127
port: integer; what port to announce
128
TXT: list of strings; TXT record for the service
129
domain: string; Domain to publish on, default to .local if empty.
130
host: string; Host to publish records for, default is localhost
131
max_renames: integer; maximum number of renames
132
rename_count: integer; counter so we only rename after collisions
133
a sensible number of times
134
group: D-Bus Entry Group
136
bus: dbus.SystemBus()
138
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
139
servicetype = None, port = None, TXT = None,
140
domain = "", host = "", max_renames = 32768,
141
protocol = avahi.PROTO_UNSPEC, bus = None):
142
self.interface = interface
144
self.type = servicetype
146
self.TXT = TXT if TXT is not None else []
149
self.rename_count = 0
150
self.max_renames = max_renames
151
self.protocol = protocol
152
self.group = None # our entry group
155
self.entry_group_state_changed_match = None
157
"""Derived from the Avahi example code"""
158
if self.rename_count >= self.max_renames:
159
logger.critical("No suitable Zeroconf service name found"
160
" after %i retries, exiting.",
162
raise AvahiServiceError("Too many renames")
163
self.name = unicode(self.server
164
.GetAlternativeServiceName(self.name))
165
logger.info("Changing Zeroconf service name to %r ...",
167
syslogger.setFormatter(logging.Formatter
168
('Mandos (%s) [%%(process)d]:'
169
' %%(levelname)s: %%(message)s'
174
except dbus.exceptions.DBusException as error:
175
logger.critical("DBusException: %s", error)
178
self.rename_count += 1
180
"""Derived from the Avahi example code"""
181
if self.entry_group_state_changed_match is not None:
182
self.entry_group_state_changed_match.remove()
183
self.entry_group_state_changed_match = None
184
if self.group is not None:
187
"""Derived from the Avahi example code"""
189
if self.group is None:
190
self.group = dbus.Interface(
191
self.bus.get_object(avahi.DBUS_NAME,
192
self.server.EntryGroupNew()),
193
avahi.DBUS_INTERFACE_ENTRY_GROUP)
194
self.entry_group_state_changed_match = (
195
self.group.connect_to_signal(
196
'StateChanged', self .entry_group_state_changed))
197
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
198
self.name, self.type)
199
self.group.AddService(
202
dbus.UInt32(0), # flags
203
self.name, self.type,
204
self.domain, self.host,
205
dbus.UInt16(self.port),
206
avahi.string_array_to_txt_array(self.TXT))
208
def entry_group_state_changed(self, state, error):
209
"""Derived from the Avahi example code"""
210
logger.debug("Avahi entry group state change: %i", state)
212
if state == avahi.ENTRY_GROUP_ESTABLISHED:
213
logger.debug("Zeroconf service established.")
214
elif state == avahi.ENTRY_GROUP_COLLISION:
215
logger.info("Zeroconf service name collision.")
217
elif state == avahi.ENTRY_GROUP_FAILURE:
218
logger.critical("Avahi: Error in group state changed %s",
220
raise AvahiGroupError("State changed: %s"
223
"""Derived from the Avahi example code"""
224
if self.group is not None:
227
except (dbus.exceptions.UnknownMethodException,
228
dbus.exceptions.DBusException) as e:
232
def server_state_changed(self, state, error=None):
233
"""Derived from the Avahi example code"""
234
logger.debug("Avahi server state change: %i", state)
235
bad_states = { avahi.SERVER_INVALID:
236
"Zeroconf server invalid",
237
avahi.SERVER_REGISTERING: None,
238
avahi.SERVER_COLLISION:
239
"Zeroconf server name collision",
240
avahi.SERVER_FAILURE:
241
"Zeroconf server failure" }
242
if state in bad_states:
243
if bad_states[state] is not None:
245
logger.error(bad_states[state])
247
logger.error(bad_states[state] + ": %r", error)
249
elif state == avahi.SERVER_RUNNING:
253
logger.debug("Unknown state: %r", state)
255
logger.debug("Unknown state: %r: %r", state, error)
257
"""Derived from the Avahi example code"""
258
if self.server is None:
259
self.server = dbus.Interface(
260
self.bus.get_object(avahi.DBUS_NAME,
261
avahi.DBUS_PATH_SERVER,
262
follow_name_owner_changes=True),
263
avahi.DBUS_INTERFACE_SERVER)
264
self.server.connect_to_signal("StateChanged",
265
self.server_state_changed)
266
self.server_state_changed(self.server.GetState())
269
def _timedelta_to_milliseconds(td):
270
"Convert a datetime.timedelta() to milliseconds"
271
return ((td.days * 24 * 60 * 60 * 1000)
272
+ (td.seconds * 1000)
273
+ (td.microseconds // 1000))
27
# This variable is used to optionally bind to a specified
29
serviceInterface = avahi.IF_UNSPEC
30
# It is a global variable to fit in with the rest of the
31
# variables from the Avahi server example code:
32
serviceName = "Mandos"
33
serviceType = "_mandos._tcp" # http://www.dns-sd.org/ServiceTypes.html
34
servicePort = None # Not known at startup
35
serviceTXT = [] # TXT record for the service
36
domain = "" # Domain to publish on, default to .local
37
host = "" # Host to publish records for, default to localhost
38
group = None #our entry group
39
rename_count = 12 # Counter so we only rename after collisions a
40
# sensible number of times
41
# End of Avahi example code
275
44
class Client(object):
276
45
"""A representation of a client host served by this server.
279
_approved: bool(); 'None' if not yet approved/disapproved
280
approval_delay: datetime.timedelta(); Time to wait for approval
281
approval_duration: datetime.timedelta(); Duration of one approval
282
checker: subprocess.Popen(); a running checker process used
283
to see if the client lives.
284
'None' if no process is running.
285
checker_callback_tag: a gobject event source tag, or None
286
checker_command: string; External command which is run to check
287
if client lives. %() expansions are done at
288
runtime with vars(self) as dict, so that for
289
instance %(name)s can be used in the command.
48
fqdn: string, FQDN (used by the checker)
49
created: datetime.datetime()
50
last_seen: datetime.datetime() or None if not yet seen
51
timeout: datetime.timedelta(); How long from last_seen until
52
this client is invalid
53
interval: datetime.timedelta(); How often to start a new checker
54
timeout_milliseconds: Used by gobject.timeout_add()
55
interval_milliseconds: - '' -
56
stop_hook: If set, called by stop() as stop_hook(self)
57
checker: subprocess.Popen(); a running checker process used
58
to see if the client lives.
59
Is None if no process is running.
290
60
checker_initiator_tag: a gobject event source tag, or None
291
created: datetime.datetime(); (UTC) object creation
292
current_checker_command: string; current running checker_command
293
disable_hook: If set, called by disable() as disable_hook(self)
294
disable_initiator_tag: a gobject event source tag, or None
296
fingerprint: string (40 or 32 hexadecimal digits); used to
297
uniquely identify the client
298
host: string; available for use by the checker command
299
interval: datetime.timedelta(); How often to start a new checker
300
last_approval_request: datetime.datetime(); (UTC) or None
301
last_checked_ok: datetime.datetime(); (UTC) or None
302
last_enabled: datetime.datetime(); (UTC)
303
name: string; from the config file, used in log messages and
305
secret: bytestring; sent verbatim (over TLS) to client
306
timeout: datetime.timedelta(); How long from last_checked_ok
307
until this client is disabled
308
extended_timeout: extra long timeout when password has been sent
309
runtime_expansions: Allowed attributes for runtime expansion.
310
expires: datetime.datetime(); time (UTC) when a client will be
61
stop_initiator_tag: - '' -
62
checker_callback_tag: - '' -
314
runtime_expansions = ("approval_delay", "approval_duration",
315
"created", "enabled", "fingerprint",
316
"host", "interval", "last_checked_ok",
317
"last_enabled", "name", "timeout")
319
def timeout_milliseconds(self):
320
"Return the 'timeout' attribute in milliseconds"
321
return _timedelta_to_milliseconds(self.timeout)
323
def extended_timeout_milliseconds(self):
324
"Return the 'extended_timeout' attribute in milliseconds"
325
return _timedelta_to_milliseconds(self.extended_timeout)
327
def interval_milliseconds(self):
328
"Return the 'interval' attribute in milliseconds"
329
return _timedelta_to_milliseconds(self.interval)
331
def approval_delay_milliseconds(self):
332
return _timedelta_to_milliseconds(self.approval_delay)
334
def __init__(self, name = None, disable_hook=None, config=None):
335
"""Note: the 'checker' key in 'config' sets the
336
'checker_command' attribute and *not* the 'checker'
64
def __init__(self, name=None, options=None, stop_hook=None,
65
dn=None, password=None, passfile=None, fqdn=None,
66
timeout=None, interval=-1):
341
logger.debug("Creating client %r", self.name)
342
# Uppercase and remove spaces from fingerprint for later
343
# comparison purposes with return value from the fingerprint()
345
self.fingerprint = (config["fingerprint"].upper()
347
logger.debug(" Fingerprint: %s", self.fingerprint)
348
if "secret" in config:
349
self.secret = config["secret"].decode("base64")
350
elif "secfile" in config:
351
with open(os.path.expanduser(os.path.expandvars
352
(config["secfile"])),
354
self.secret = secfile.read()
356
raise TypeError("No secret or secfile for client %s"
358
self.host = config.get("host", "")
359
self.created = datetime.datetime.utcnow()
361
self.last_approval_request = None
362
self.last_enabled = None
363
self.last_checked_ok = None
364
self.timeout = string_to_delta(config["timeout"])
365
self.extended_timeout = string_to_delta(config
366
["extended_timeout"])
367
self.interval = string_to_delta(config["interval"])
368
self.disable_hook = disable_hook
70
self.password = password
72
self.password = open(passfile).readall()
74
raise RuntimeError(u"No Password or Passfile for client %s"
76
self.fqdn = fqdn # string
77
self.created = datetime.datetime.now()
80
timeout = options.timeout
81
self.timeout = timeout
82
self.timeout_milliseconds = ((self.timeout.days
83
* 24 * 60 * 60 * 1000)
84
+ (self.timeout.seconds * 1000)
85
+ (self.timeout.microseconds
88
interval = options.interval
90
interval = string_to_delta(interval)
91
self.interval = interval
92
self.interval_milliseconds = ((self.interval.days
93
* 24 * 60 * 60 * 1000)
94
+ (self.interval.seconds * 1000)
95
+ (self.interval.microseconds
97
self.stop_hook = stop_hook
369
98
self.checker = None
370
99
self.checker_initiator_tag = None
371
self.disable_initiator_tag = None
100
self.stop_initiator_tag = None
373
101
self.checker_callback_tag = None
374
self.checker_command = config["checker"]
375
self.current_checker_command = None
376
self.last_connect = None
377
self._approved = None
378
self.approved_by_default = config.get("approved_by_default",
380
self.approvals_pending = 0
381
self.approval_delay = string_to_delta(
382
config["approval_delay"])
383
self.approval_duration = string_to_delta(
384
config["approval_duration"])
385
self.changedstate = (multiprocessing_manager
386
.Condition(multiprocessing_manager
389
def send_changedstate(self):
390
self.changedstate.acquire()
391
self.changedstate.notify_all()
392
self.changedstate.release()
395
"""Start this client's checker and timeout hooks"""
396
if getattr(self, "enabled", False):
399
self.send_changedstate()
103
"""Start this clients checker and timeout hooks"""
400
104
# Schedule a new checker to be started an 'interval' from now,
401
105
# and every interval from then on.
402
self.checker_initiator_tag = (gobject.timeout_add
403
(self.interval_milliseconds(),
405
# Schedule a disable() when 'timeout' has passed
406
self.expires = datetime.datetime.utcnow() + self.timeout
407
self.disable_initiator_tag = (gobject.timeout_add
408
(self.timeout_milliseconds(),
411
self.last_enabled = datetime.datetime.utcnow()
106
self.checker_initiator_tag = gobject.\
107
timeout_add(self.interval_milliseconds,
412
109
# Also start a new checker *right now*.
413
110
self.start_checker()
415
def disable(self, quiet=True):
416
"""Disable this client."""
417
if not getattr(self, "enabled", False):
420
self.send_changedstate()
422
logger.info("Disabling client %s", self.name)
423
if getattr(self, "disable_initiator_tag", False):
424
gobject.source_remove(self.disable_initiator_tag)
425
self.disable_initiator_tag = None
427
if getattr(self, "checker_initiator_tag", False):
111
# Schedule a stop() when 'timeout' has passed
112
self.stop_initiator_tag = gobject.\
113
timeout_add(self.timeout_milliseconds,
117
The possibility that this client might be restarted is left
118
open, but not currently used."""
119
# print "Stopping client", self.name
121
if self.stop_initiator_tag:
122
gobject.source_remove(self.stop_initiator_tag)
123
self.stop_initiator_tag = None
124
if self.checker_initiator_tag:
428
125
gobject.source_remove(self.checker_initiator_tag)
429
126
self.checker_initiator_tag = None
430
127
self.stop_checker()
431
if self.disable_hook:
432
self.disable_hook(self)
434
130
# Do not run this again if called by a gobject.timeout_add
437
132
def __del__(self):
438
self.disable_hook = None
441
def checker_callback(self, pid, condition, command):
133
# Some code duplication here and in stop()
134
if hasattr(self, "stop_initiator_tag") \
135
and self.stop_initiator_tag:
136
gobject.source_remove(self.stop_initiator_tag)
137
self.stop_initiator_tag = None
138
if hasattr(self, "checker_initiator_tag") \
139
and self.checker_initiator_tag:
140
gobject.source_remove(self.checker_initiator_tag)
141
self.checker_initiator_tag = None
143
def checker_callback(self, pid, condition):
442
144
"""The checker has completed, so take appropriate actions."""
145
now = datetime.datetime.now()
146
if os.WIFEXITED(condition) \
147
and (os.WEXITSTATUS(condition) == 0):
148
#print "Checker for %(name)s succeeded" % vars(self)
150
gobject.source_remove(self.stop_initiator_tag)
151
self.stop_initiator_tag = gobject.\
152
timeout_add(self.timeout_milliseconds,
155
# if not os.WIFEXITED(condition):
156
# print "Checker for %(name)s crashed?" % vars(self)
158
# print "Checker for %(name)s failed" % vars(self)
443
160
self.checker_callback_tag = None
445
if os.WIFEXITED(condition):
446
exitstatus = os.WEXITSTATUS(condition)
448
logger.info("Checker for %(name)s succeeded",
452
logger.info("Checker for %(name)s failed",
455
logger.warning("Checker for %(name)s crashed?",
458
def checked_ok(self, timeout=None):
459
"""Bump up the timeout for this client.
461
This should only be called when the client has been seen,
465
timeout = self.timeout
466
self.last_checked_ok = datetime.datetime.utcnow()
467
gobject.source_remove(self.disable_initiator_tag)
468
self.disable_initiator_tag = (gobject.timeout_add
469
(_timedelta_to_milliseconds
470
(timeout), self.disable))
471
self.expires = datetime.datetime.utcnow() + timeout
473
def need_approval(self):
474
self.last_approval_request = datetime.datetime.utcnow()
476
161
def start_checker(self):
477
162
"""Start a new checker subprocess if one is not running.
479
163
If a checker already exists, leave it running and do
481
# The reason for not killing a running checker is that if we
482
# did that, then if a checker (for some reason) started
483
# running slowly and taking more than 'interval' time, the
484
# client would inevitably timeout, since no checker would get
485
# a chance to run to completion. If we instead leave running
486
# checkers alone, the checker would have to take more time
487
# than 'timeout' for the client to be disabled, which is as it
490
# If a checker exists, make sure it is not a zombie
492
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
493
except (AttributeError, OSError) as error:
494
if (isinstance(error, OSError)
495
and error.errno != errno.ECHILD):
499
logger.warning("Checker was a zombie")
500
gobject.source_remove(self.checker_callback_tag)
501
self.checker_callback(pid, status,
502
self.current_checker_command)
503
# Start a new checker if needed
504
165
if self.checker is None:
506
# In case checker_command has exactly one % operator
507
command = self.checker_command % self.host
509
# Escape attributes for the shell
510
escaped_attrs = dict(
512
re.escape(unicode(str(getattr(self, attr, "")),
516
self.runtime_expansions)
519
command = self.checker_command % escaped_attrs
520
except TypeError as error:
521
logger.error('Could not format string "%s":'
522
' %s', self.checker_command, error)
523
return True # Try again later
524
self.current_checker_command = command
526
logger.info("Starting checker %r for %s",
528
# We don't need to redirect stdout and stderr, since
529
# in normal mode, that is already done by daemon(),
530
# and in debug mode we don't want to. (Stdin is
531
# always replaced by /dev/null.)
532
self.checker = subprocess.Popen(command,
535
self.checker_callback_tag = (gobject.child_watch_add
537
self.checker_callback,
539
# The checker may have completed before the gobject
540
# watch was added. Check for this.
541
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
543
gobject.source_remove(self.checker_callback_tag)
544
self.checker_callback(pid, status, command)
545
except OSError as error:
546
logger.error("Failed to start subprocess: %s",
166
#print "Starting checker for", self.name
168
self.checker = subprocess.\
169
Popen("sleep 1; fping -q -- %s"
170
% re.escape(self.fqdn),
171
stdout=subprocess.PIPE,
172
close_fds=True, shell=True,
174
self.checker_callback_tag = gobject.\
175
child_watch_add(self.checker.pid,
178
except subprocess.OSError, error:
179
sys.stderr.write(u"Failed to start subprocess: %s\n"
548
181
# Re-run this periodically if run by gobject.timeout_add
551
183
def stop_checker(self):
552
184
"""Force the checker process, if any, to stop."""
553
if self.checker_callback_tag:
554
gobject.source_remove(self.checker_callback_tag)
555
self.checker_callback_tag = None
556
if getattr(self, "checker", None) is None:
185
if not hasattr(self, "checker") or self.checker is None:
558
logger.debug("Stopping checker for %(name)s", vars(self))
560
os.kill(self.checker.pid, signal.SIGTERM)
562
#if self.checker.poll() is None:
563
# os.kill(self.checker.pid, signal.SIGKILL)
564
except OSError as error:
565
if error.errno != errno.ESRCH: # No such process
570
def dbus_service_property(dbus_interface, signature="v",
571
access="readwrite", byte_arrays=False):
572
"""Decorators for marking methods of a DBusObjectWithProperties to
573
become properties on the D-Bus.
575
The decorated method will be called with no arguments by "Get"
576
and with one argument by "Set".
578
The parameters, where they are supported, are the same as
579
dbus.service.method, except there is only "signature", since the
580
type from Get() and the type sent to Set() is the same.
582
# Encoding deeply encoded byte arrays is not supported yet by the
583
# "Set" method, so we fail early here:
584
if byte_arrays and signature != "ay":
585
raise ValueError("Byte arrays not supported for non-'ay'"
586
" signature %r" % signature)
588
func._dbus_is_property = True
589
func._dbus_interface = dbus_interface
590
func._dbus_signature = signature
591
func._dbus_access = access
592
func._dbus_name = func.__name__
593
if func._dbus_name.endswith("_dbus_property"):
594
func._dbus_name = func._dbus_name[:-14]
595
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
600
class DBusPropertyException(dbus.exceptions.DBusException):
601
"""A base class for D-Bus property-related exceptions
603
def __unicode__(self):
604
return unicode(str(self))
607
class DBusPropertyAccessException(DBusPropertyException):
608
"""A property's access permissions disallows an operation.
613
class DBusPropertyNotFound(DBusPropertyException):
614
"""An attempt was made to access a non-existing property.
619
class DBusObjectWithProperties(dbus.service.Object):
620
"""A D-Bus object with properties.
622
Classes inheriting from this can use the dbus_service_property
623
decorator to expose methods as D-Bus properties. It exposes the
624
standard Get(), Set(), and GetAll() methods on the D-Bus.
628
def _is_dbus_property(obj):
629
return getattr(obj, "_dbus_is_property", False)
631
def _get_all_dbus_properties(self):
632
"""Returns a generator of (name, attribute) pairs
634
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
635
for cls in self.__class__.__mro__
637
inspect.getmembers(cls, self._is_dbus_property))
639
def _get_dbus_property(self, interface_name, property_name):
640
"""Returns a bound method if one exists which is a D-Bus
641
property with the specified name and interface.
643
for cls in self.__class__.__mro__:
644
for name, value in (inspect.getmembers
645
(cls, self._is_dbus_property)):
646
if (value._dbus_name == property_name
647
and value._dbus_interface == interface_name):
648
return value.__get__(self)
651
raise DBusPropertyNotFound(self.dbus_object_path + ":"
652
+ interface_name + "."
655
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
657
def Get(self, interface_name, property_name):
658
"""Standard D-Bus property Get() method, see D-Bus standard.
660
prop = self._get_dbus_property(interface_name, property_name)
661
if prop._dbus_access == "write":
662
raise DBusPropertyAccessException(property_name)
664
if not hasattr(value, "variant_level"):
666
return type(value)(value, variant_level=value.variant_level+1)
668
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
669
def Set(self, interface_name, property_name, value):
670
"""Standard D-Bus property Set() method, see D-Bus standard.
672
prop = self._get_dbus_property(interface_name, property_name)
673
if prop._dbus_access == "read":
674
raise DBusPropertyAccessException(property_name)
675
if prop._dbus_get_args_options["byte_arrays"]:
676
# The byte_arrays option is not supported yet on
677
# signatures other than "ay".
678
if prop._dbus_signature != "ay":
680
value = dbus.ByteArray(''.join(unichr(byte)
684
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
685
out_signature="a{sv}")
686
def GetAll(self, interface_name):
687
"""Standard D-Bus property GetAll() method, see D-Bus
690
Note: Will not include properties with access="write".
693
for name, prop in self._get_all_dbus_properties():
695
and interface_name != prop._dbus_interface):
696
# Interface non-empty but did not match
698
# Ignore write-only properties
699
if prop._dbus_access == "write":
702
if not hasattr(value, "variant_level"):
705
all[name] = type(value)(value, variant_level=
706
value.variant_level+1)
707
return dbus.Dictionary(all, signature="sv")
709
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
711
path_keyword='object_path',
712
connection_keyword='connection')
713
def Introspect(self, object_path, connection):
714
"""Standard D-Bus method, overloaded to insert property tags.
716
xmlstring = dbus.service.Object.Introspect(self, object_path,
719
document = xml.dom.minidom.parseString(xmlstring)
720
def make_tag(document, name, prop):
721
e = document.createElement("property")
722
e.setAttribute("name", name)
723
e.setAttribute("type", prop._dbus_signature)
724
e.setAttribute("access", prop._dbus_access)
726
for if_tag in document.getElementsByTagName("interface"):
727
for tag in (make_tag(document, name, prop)
729
in self._get_all_dbus_properties()
730
if prop._dbus_interface
731
== if_tag.getAttribute("name")):
732
if_tag.appendChild(tag)
733
# Add the names to the return values for the
734
# "org.freedesktop.DBus.Properties" methods
735
if (if_tag.getAttribute("name")
736
== "org.freedesktop.DBus.Properties"):
737
for cn in if_tag.getElementsByTagName("method"):
738
if cn.getAttribute("name") == "Get":
739
for arg in cn.getElementsByTagName("arg"):
740
if (arg.getAttribute("direction")
742
arg.setAttribute("name", "value")
743
elif cn.getAttribute("name") == "GetAll":
744
for arg in cn.getElementsByTagName("arg"):
745
if (arg.getAttribute("direction")
747
arg.setAttribute("name", "props")
748
xmlstring = document.toxml("utf-8")
750
except (AttributeError, xml.dom.DOMException,
751
xml.parsers.expat.ExpatError) as error:
752
logger.error("Failed to override Introspection method",
757
def datetime_to_dbus (dt, variant_level=0):
758
"""Convert a UTC datetime.datetime() to a D-Bus type."""
760
return dbus.String("", variant_level = variant_level)
761
return dbus.String(dt.isoformat(),
762
variant_level=variant_level)
764
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
766
"""Applied to an empty subclass of a D-Bus object, this metaclass
767
will add additional D-Bus attributes matching a certain pattern.
769
def __new__(mcs, name, bases, attr):
770
# Go through all the base classes which could have D-Bus
771
# methods, signals, or properties in them
772
for base in (b for b in bases
773
if issubclass(b, dbus.service.Object)):
774
# Go though all attributes of the base class
775
for attrname, attribute in inspect.getmembers(base):
776
# Ignore non-D-Bus attributes, and D-Bus attributes
777
# with the wrong interface name
778
if (not hasattr(attribute, "_dbus_interface")
779
or not attribute._dbus_interface
780
.startswith("se.recompile.Mandos")):
782
# Create an alternate D-Bus interface name based on
784
alt_interface = (attribute._dbus_interface
785
.replace("se.recompile.Mandos",
786
"se.bsnet.fukt.Mandos"))
787
# Is this a D-Bus signal?
788
if getattr(attribute, "_dbus_is_signal", False):
789
# Extract the original non-method function by
791
nonmethod_func = (dict(
792
zip(attribute.func_code.co_freevars,
793
attribute.__closure__))["func"]
795
# Create a new, but exactly alike, function
796
# object, and decorate it to be a new D-Bus signal
797
# with the alternate D-Bus interface name
798
new_function = (dbus.service.signal
800
attribute._dbus_signature)
802
nonmethod_func.func_code,
803
nonmethod_func.func_globals,
804
nonmethod_func.func_name,
805
nonmethod_func.func_defaults,
806
nonmethod_func.func_closure)))
807
# Define a creator of a function to call both the
808
# old and new functions, so both the old and new
809
# signals gets sent when the function is called
810
def fixscope(func1, func2):
811
"""This function is a scope container to pass
812
func1 and func2 to the "call_both" function
813
outside of its arguments"""
814
def call_both(*args, **kwargs):
815
"""This function will emit two D-Bus
816
signals by calling func1 and func2"""
817
func1(*args, **kwargs)
818
func2(*args, **kwargs)
820
# Create the "call_both" function and add it to
822
attr[attrname] = fixscope(attribute,
824
# Is this a D-Bus method?
825
elif getattr(attribute, "_dbus_is_method", False):
826
# Create a new, but exactly alike, function
827
# object. Decorate it to be a new D-Bus method
828
# with the alternate D-Bus interface name. Add it
830
attr[attrname] = (dbus.service.method
832
attribute._dbus_in_signature,
833
attribute._dbus_out_signature)
835
(attribute.func_code,
836
attribute.func_globals,
838
attribute.func_defaults,
839
attribute.func_closure)))
840
# Is this a D-Bus property?
841
elif getattr(attribute, "_dbus_is_property", False):
842
# Create a new, but exactly alike, function
843
# object, and decorate it to be a new D-Bus
844
# property with the alternate D-Bus interface
845
# name. Add it to the class.
846
attr[attrname] = (dbus_service_property
848
attribute._dbus_signature,
849
attribute._dbus_access,
851
._dbus_get_args_options
854
(attribute.func_code,
855
attribute.func_globals,
857
attribute.func_defaults,
858
attribute.func_closure)))
859
return type.__new__(mcs, name, bases, attr)
861
class ClientDBus(Client, DBusObjectWithProperties):
862
"""A Client class using D-Bus
865
dbus_object_path: dbus.ObjectPath
866
bus: dbus.SystemBus()
869
runtime_expansions = (Client.runtime_expansions
870
+ ("dbus_object_path",))
872
# dbus.service.Object doesn't use super(), so we can't either.
874
def __init__(self, bus = None, *args, **kwargs):
875
self._approvals_pending = 0
877
Client.__init__(self, *args, **kwargs)
878
# Only now, when this client is initialized, can it show up on
880
client_object_name = unicode(self.name).translate(
883
self.dbus_object_path = (dbus.ObjectPath
884
("/clients/" + client_object_name))
885
DBusObjectWithProperties.__init__(self, self.bus,
886
self.dbus_object_path)
888
def notifychangeproperty(transform_func,
889
dbus_name, type_func=lambda x: x,
891
""" Modify a variable so that it's a property which announces
894
transform_fun: Function that takes a value and transforms it
896
dbus_name: D-Bus name of the variable
897
type_func: Function that transform the value before sending it
898
to the D-Bus. Default: no transform
899
variant_level: D-Bus variant level. Default: 1
901
attrname = "_{0}".format(dbus_name)
902
def setter(self, value):
903
if hasattr(self, "dbus_object_path"):
904
if (not hasattr(self, attrname) or
905
type_func(getattr(self, attrname, None))
906
!= type_func(value)):
907
dbus_value = transform_func(type_func(value),
909
self.PropertyChanged(dbus.String(dbus_name),
911
setattr(self, attrname, value)
913
return property(lambda self: getattr(self, attrname), setter)
916
expires = notifychangeproperty(datetime_to_dbus, "Expires")
917
approvals_pending = notifychangeproperty(dbus.Boolean,
920
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
921
last_enabled = notifychangeproperty(datetime_to_dbus,
923
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
924
type_func = lambda checker:
926
last_checked_ok = notifychangeproperty(datetime_to_dbus,
928
last_approval_request = notifychangeproperty(
929
datetime_to_dbus, "LastApprovalRequest")
930
approved_by_default = notifychangeproperty(dbus.Boolean,
932
approval_delay = notifychangeproperty(dbus.UInt16,
935
_timedelta_to_milliseconds)
936
approval_duration = notifychangeproperty(
937
dbus.UInt16, "ApprovalDuration",
938
type_func = _timedelta_to_milliseconds)
939
host = notifychangeproperty(dbus.String, "Host")
940
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
942
_timedelta_to_milliseconds)
943
extended_timeout = notifychangeproperty(
944
dbus.UInt16, "ExtendedTimeout",
945
type_func = _timedelta_to_milliseconds)
946
interval = notifychangeproperty(dbus.UInt16,
949
_timedelta_to_milliseconds)
950
checker_command = notifychangeproperty(dbus.String, "Checker")
952
del notifychangeproperty
954
def __del__(self, *args, **kwargs):
956
self.remove_from_connection()
959
if hasattr(DBusObjectWithProperties, "__del__"):
960
DBusObjectWithProperties.__del__(self, *args, **kwargs)
961
Client.__del__(self, *args, **kwargs)
963
def checker_callback(self, pid, condition, command,
187
gobject.source_remove(self.checker_callback_tag)
965
188
self.checker_callback_tag = None
189
os.kill(self.checker.pid, signal.SIGTERM)
190
if self.checker.poll() is None:
191
os.kill(self.checker.pid, signal.SIGKILL)
966
192
self.checker = None
967
if os.WIFEXITED(condition):
968
exitstatus = os.WEXITSTATUS(condition)
970
self.CheckerCompleted(dbus.Int16(exitstatus),
971
dbus.Int64(condition),
972
dbus.String(command))
975
self.CheckerCompleted(dbus.Int16(-1),
976
dbus.Int64(condition),
977
dbus.String(command))
979
return Client.checker_callback(self, pid, condition, command,
982
def start_checker(self, *args, **kwargs):
983
old_checker = self.checker
984
if self.checker is not None:
985
old_checker_pid = self.checker.pid
987
old_checker_pid = None
988
r = Client.start_checker(self, *args, **kwargs)
989
# Only if new checker process was started
990
if (self.checker is not None
991
and old_checker_pid != self.checker.pid):
993
self.CheckerStarted(self.current_checker_command)
996
def _reset_approved(self):
997
self._approved = None
1000
def approve(self, value=True):
1001
self.send_changedstate()
1002
self._approved = value
1003
gobject.timeout_add(_timedelta_to_milliseconds
1004
(self.approval_duration),
1005
self._reset_approved)
1008
## D-Bus methods, signals & properties
1009
_interface = "se.recompile.Mandos.Client"
1013
# CheckerCompleted - signal
1014
@dbus.service.signal(_interface, signature="nxs")
1015
def CheckerCompleted(self, exitcode, waitstatus, command):
1019
# CheckerStarted - signal
1020
@dbus.service.signal(_interface, signature="s")
1021
def CheckerStarted(self, command):
1025
# PropertyChanged - signal
1026
@dbus.service.signal(_interface, signature="sv")
1027
def PropertyChanged(self, property, value):
1031
# GotSecret - signal
1032
@dbus.service.signal(_interface)
1033
def GotSecret(self):
1035
Is sent after a successful transfer of secret from the Mandos
1036
server to mandos-client
1041
@dbus.service.signal(_interface, signature="s")
1042
def Rejected(self, reason):
1046
# NeedApproval - signal
1047
@dbus.service.signal(_interface, signature="tb")
1048
def NeedApproval(self, timeout, default):
1050
return self.need_approval()
1055
@dbus.service.method(_interface, in_signature="b")
1056
def Approve(self, value):
1059
# CheckedOK - method
1060
@dbus.service.method(_interface)
1061
def CheckedOK(self):
1065
@dbus.service.method(_interface)
1070
# StartChecker - method
1071
@dbus.service.method(_interface)
1072
def StartChecker(self):
1074
self.start_checker()
1077
@dbus.service.method(_interface)
1082
# StopChecker - method
1083
@dbus.service.method(_interface)
1084
def StopChecker(self):
1089
# ApprovalPending - property
1090
@dbus_service_property(_interface, signature="b", access="read")
1091
def ApprovalPending_dbus_property(self):
1092
return dbus.Boolean(bool(self.approvals_pending))
1094
# ApprovedByDefault - property
1095
@dbus_service_property(_interface, signature="b",
1097
def ApprovedByDefault_dbus_property(self, value=None):
1098
if value is None: # get
1099
return dbus.Boolean(self.approved_by_default)
1100
self.approved_by_default = bool(value)
1102
# ApprovalDelay - property
1103
@dbus_service_property(_interface, signature="t",
1105
def ApprovalDelay_dbus_property(self, value=None):
1106
if value is None: # get
1107
return dbus.UInt64(self.approval_delay_milliseconds())
1108
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1110
# ApprovalDuration - property
1111
@dbus_service_property(_interface, signature="t",
1113
def ApprovalDuration_dbus_property(self, value=None):
1114
if value is None: # get
1115
return dbus.UInt64(_timedelta_to_milliseconds(
1116
self.approval_duration))
1117
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1120
@dbus_service_property(_interface, signature="s", access="read")
1121
def Name_dbus_property(self):
1122
return dbus.String(self.name)
1124
# Fingerprint - property
1125
@dbus_service_property(_interface, signature="s", access="read")
1126
def Fingerprint_dbus_property(self):
1127
return dbus.String(self.fingerprint)
1130
@dbus_service_property(_interface, signature="s",
1132
def Host_dbus_property(self, value=None):
1133
if value is None: # get
1134
return dbus.String(self.host)
1137
# Created - property
1138
@dbus_service_property(_interface, signature="s", access="read")
1139
def Created_dbus_property(self):
1140
return dbus.String(datetime_to_dbus(self.created))
1142
# LastEnabled - property
1143
@dbus_service_property(_interface, signature="s", access="read")
1144
def LastEnabled_dbus_property(self):
1145
return datetime_to_dbus(self.last_enabled)
1147
# Enabled - property
1148
@dbus_service_property(_interface, signature="b",
1150
def Enabled_dbus_property(self, value=None):
1151
if value is None: # get
1152
return dbus.Boolean(self.enabled)
1158
# LastCheckedOK - property
1159
@dbus_service_property(_interface, signature="s",
1161
def LastCheckedOK_dbus_property(self, value=None):
1162
if value is not None:
1165
return datetime_to_dbus(self.last_checked_ok)
1167
# Expires - property
1168
@dbus_service_property(_interface, signature="s", access="read")
1169
def Expires_dbus_property(self):
1170
return datetime_to_dbus(self.expires)
1172
# LastApprovalRequest - property
1173
@dbus_service_property(_interface, signature="s", access="read")
1174
def LastApprovalRequest_dbus_property(self):
1175
return datetime_to_dbus(self.last_approval_request)
1177
# Timeout - property
1178
@dbus_service_property(_interface, signature="t",
1180
def Timeout_dbus_property(self, value=None):
1181
if value is None: # get
1182
return dbus.UInt64(self.timeout_milliseconds())
1183
self.timeout = datetime.timedelta(0, 0, 0, value)
1184
if getattr(self, "disable_initiator_tag", None) is None:
1186
# Reschedule timeout
1187
gobject.source_remove(self.disable_initiator_tag)
1188
self.disable_initiator_tag = None
1190
time_to_die = (self.
1191
_timedelta_to_milliseconds((self
1196
if time_to_die <= 0:
1197
# The timeout has passed
1200
self.expires = (datetime.datetime.utcnow()
1201
+ datetime.timedelta(milliseconds =
1203
self.disable_initiator_tag = (gobject.timeout_add
1204
(time_to_die, self.disable))
1206
# ExtendedTimeout - property
1207
@dbus_service_property(_interface, signature="t",
1209
def ExtendedTimeout_dbus_property(self, value=None):
1210
if value is None: # get
1211
return dbus.UInt64(self.extended_timeout_milliseconds())
1212
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1214
# Interval - property
1215
@dbus_service_property(_interface, signature="t",
1217
def Interval_dbus_property(self, value=None):
1218
if value is None: # get
1219
return dbus.UInt64(self.interval_milliseconds())
1220
self.interval = datetime.timedelta(0, 0, 0, value)
1221
if getattr(self, "checker_initiator_tag", None) is None:
1223
# Reschedule checker run
1224
gobject.source_remove(self.checker_initiator_tag)
1225
self.checker_initiator_tag = (gobject.timeout_add
1226
(value, self.start_checker))
1227
self.start_checker() # Start one now, too
1229
# Checker - property
1230
@dbus_service_property(_interface, signature="s",
1232
def Checker_dbus_property(self, value=None):
1233
if value is None: # get
1234
return dbus.String(self.checker_command)
1235
self.checker_command = value
1237
# CheckerRunning - property
1238
@dbus_service_property(_interface, signature="b",
1240
def CheckerRunning_dbus_property(self, value=None):
1241
if value is None: # get
1242
return dbus.Boolean(self.checker is not None)
1244
self.start_checker()
1248
# ObjectPath - property
1249
@dbus_service_property(_interface, signature="o", access="read")
1250
def ObjectPath_dbus_property(self):
1251
return self.dbus_object_path # is already a dbus.ObjectPath
1254
@dbus_service_property(_interface, signature="ay",
1255
access="write", byte_arrays=True)
1256
def Secret_dbus_property(self, value):
1257
self.secret = str(value)
1262
class ProxyClient(object):
1263
def __init__(self, child_pipe, fpr, address):
1264
self._pipe = child_pipe
1265
self._pipe.send(('init', fpr, address))
1266
if not self._pipe.recv():
1269
def __getattribute__(self, name):
1270
if(name == '_pipe'):
1271
return super(ProxyClient, self).__getattribute__(name)
1272
self._pipe.send(('getattr', name))
1273
data = self._pipe.recv()
1274
if data[0] == 'data':
1276
if data[0] == 'function':
1277
def func(*args, **kwargs):
1278
self._pipe.send(('funcall', name, args, kwargs))
1279
return self._pipe.recv()[1]
1282
def __setattr__(self, name, value):
1283
if(name == '_pipe'):
1284
return super(ProxyClient, self).__setattr__(name, value)
1285
self._pipe.send(('setattr', name, value))
1287
class ClientDBusTransitional(ClientDBus):
1288
__metaclass__ = AlternateDBusNamesMetaclass
1290
class ClientHandler(socketserver.BaseRequestHandler, object):
1291
"""A class to handle client connections.
1293
Instantiated once for each connection to handle it.
193
def still_valid(self, now=None):
194
"""Has the timeout not yet passed for this client?"""
196
now = datetime.datetime.now()
197
if self.last_seen is None:
198
return now < (self.created + self.timeout)
200
return now < (self.last_seen + self.timeout)
203
class tcp_handler(SocketServer.BaseRequestHandler, object):
204
"""A TCP request handler class.
205
Instantiated by IPv6_TCPServer for each request to handle it.
1294
206
Note: This will run in its own forked process."""
1296
207
def handle(self):
1297
with contextlib.closing(self.server.child_pipe) as child_pipe:
1298
logger.info("TCP connection from: %s",
1299
unicode(self.client_address))
1300
logger.debug("Pipe FD: %d",
1301
self.server.child_pipe.fileno())
1303
session = (gnutls.connection
1304
.ClientSession(self.request,
1306
.X509Credentials()))
1308
# Note: gnutls.connection.X509Credentials is really a
1309
# generic GnuTLS certificate credentials object so long as
1310
# no X.509 keys are added to it. Therefore, we can use it
1311
# here despite using OpenPGP certificates.
1313
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1314
# "+AES-256-CBC", "+SHA1",
1315
# "+COMP-NULL", "+CTYPE-OPENPGP",
1317
# Use a fallback default, since this MUST be set.
1318
priority = self.server.gnutls_priority
1319
if priority is None:
1321
(gnutls.library.functions
1322
.gnutls_priority_set_direct(session._c_object,
1325
# Start communication using the Mandos protocol
1326
# Get protocol number
1327
line = self.request.makefile().readline()
1328
logger.debug("Protocol version: %r", line)
1330
if int(line.strip().split()[0]) > 1:
1332
except (ValueError, IndexError, RuntimeError) as error:
1333
logger.error("Unknown protocol version: %s", error)
1336
# Start GnuTLS connection
1339
except gnutls.errors.GNUTLSError as error:
1340
logger.warning("Handshake failed: %s", error)
1341
# Do not run session.bye() here: the session is not
1342
# established. Just abandon the request.
1344
logger.debug("Handshake succeeded")
1346
approval_required = False
1349
fpr = self.fingerprint(self.peer_certificate
1352
gnutls.errors.GNUTLSError) as error:
1353
logger.warning("Bad certificate: %s", error)
1355
logger.debug("Fingerprint: %s", fpr)
1358
client = ProxyClient(child_pipe, fpr,
1359
self.client_address)
1363
if client.approval_delay:
1364
delay = client.approval_delay
1365
client.approvals_pending += 1
1366
approval_required = True
1369
if not client.enabled:
1370
logger.info("Client %s is disabled",
1372
if self.server.use_dbus:
1374
client.Rejected("Disabled")
1377
if client._approved or not client.approval_delay:
1378
#We are approved or approval is disabled
1380
elif client._approved is None:
1381
logger.info("Client %s needs approval",
1383
if self.server.use_dbus:
1385
client.NeedApproval(
1386
client.approval_delay_milliseconds(),
1387
client.approved_by_default)
1389
logger.warning("Client %s was not approved",
1391
if self.server.use_dbus:
1393
client.Rejected("Denied")
1396
#wait until timeout or approved
1397
time = datetime.datetime.now()
1398
client.changedstate.acquire()
1399
(client.changedstate.wait
1400
(float(client._timedelta_to_milliseconds(delay)
1402
client.changedstate.release()
1403
time2 = datetime.datetime.now()
1404
if (time2 - time) >= delay:
1405
if not client.approved_by_default:
1406
logger.warning("Client %s timed out while"
1407
" waiting for approval",
1409
if self.server.use_dbus:
1411
client.Rejected("Approval timed out")
1416
delay -= time2 - time
1419
while sent_size < len(client.secret):
1421
sent = session.send(client.secret[sent_size:])
1422
except gnutls.errors.GNUTLSError as error:
1423
logger.warning("gnutls send failed")
1425
logger.debug("Sent: %d, remaining: %d",
1426
sent, len(client.secret)
1427
- (sent_size + sent))
1430
logger.info("Sending secret to %s", client.name)
1431
# bump the timeout using extended_timeout
1432
client.checked_ok(client.extended_timeout)
1433
if self.server.use_dbus:
1438
if approval_required:
1439
client.approvals_pending -= 1
1442
except gnutls.errors.GNUTLSError as error:
1443
logger.warning("GnuTLS bye failed")
1446
def peer_certificate(session):
1447
"Return the peer's OpenPGP certificate as a bytestring"
1448
# If not an OpenPGP certificate...
1449
if (gnutls.library.functions
1450
.gnutls_certificate_type_get(session._c_object)
1451
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1452
# ...do the normal thing
1453
return session.peer_certificate
1454
list_size = ctypes.c_uint(1)
1455
cert_list = (gnutls.library.functions
1456
.gnutls_certificate_get_peers
1457
(session._c_object, ctypes.byref(list_size)))
1458
if not bool(cert_list) and list_size.value != 0:
1459
raise gnutls.errors.GNUTLSError("error getting peer"
1461
if list_size.value == 0:
1464
return ctypes.string_at(cert.data, cert.size)
1467
def fingerprint(openpgp):
1468
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1469
# New GnuTLS "datum" with the OpenPGP public key
1470
datum = (gnutls.library.types
1471
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1474
ctypes.c_uint(len(openpgp))))
1475
# New empty GnuTLS certificate
1476
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1477
(gnutls.library.functions
1478
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1479
# Import the OpenPGP public key into the certificate
1480
(gnutls.library.functions
1481
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1482
gnutls.library.constants
1483
.GNUTLS_OPENPGP_FMT_RAW))
1484
# Verify the self signature in the key
1485
crtverify = ctypes.c_uint()
1486
(gnutls.library.functions
1487
.gnutls_openpgp_crt_verify_self(crt, 0,
1488
ctypes.byref(crtverify)))
1489
if crtverify.value != 0:
1490
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1491
raise (gnutls.errors.CertificateSecurityError
1493
# New buffer for the fingerprint
1494
buf = ctypes.create_string_buffer(20)
1495
buf_len = ctypes.c_size_t()
1496
# Get the fingerprint from the certificate into the buffer
1497
(gnutls.library.functions
1498
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1499
ctypes.byref(buf_len)))
1500
# Deinit the certificate
1501
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1502
# Convert the buffer to a Python bytestring
1503
fpr = ctypes.string_at(buf, buf_len.value)
1504
# Convert the bytestring to hexadecimal notation
1505
hex_fpr = ''.join("%02X" % ord(char) for char in fpr)
1509
class MultiprocessingMixIn(object):
1510
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1511
def sub_process_main(self, request, address):
1513
self.finish_request(request, address)
1515
self.handle_error(request, address)
1516
self.close_request(request)
1518
def process_request(self, request, address):
1519
"""Start a new process to process the request."""
1520
proc = multiprocessing.Process(target = self.sub_process_main,
1527
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1528
""" adds a pipe to the MixIn """
1529
def process_request(self, request, client_address):
1530
"""Overrides and wraps the original process_request().
1532
This function creates a new pipe in self.pipe
1534
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1536
proc = MultiprocessingMixIn.process_request(self, request,
1538
self.child_pipe.close()
1539
self.add_pipe(parent_pipe, proc)
1541
def add_pipe(self, parent_pipe, proc):
1542
"""Dummy function; override as necessary"""
1543
raise NotImplementedError
1546
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1547
socketserver.TCPServer, object):
1548
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
208
#print u"TCP request came"
209
#print u"Request:", self.request
210
#print u"Client Address:", self.client_address
211
#print u"Server:", self.server
212
session = gnutls.connection.ServerSession(self.request,
217
except gnutls.errors.GNUTLSError, error:
218
#sys.stderr.write(u"Handshake failed: %s\n" % error)
219
# Do not run session.bye() here: the session is not
220
# established. Just abandon the request.
222
#if session.peer_certificate:
223
# print "DN:", session.peer_certificate.subject
225
session.verify_peer()
226
except gnutls.errors.CertificateError, error:
227
#sys.stderr.write(u"Verify failed: %s\n" % error)
232
if c.dn == session.peer_certificate.subject:
235
# Have to check if client.still_valid(), since it is possible
236
# that the client timed out while establishing the GnuTLS
238
if client and client.still_valid():
239
session.send(client.password)
242
# sys.stderr.write(u"Client %(name)s is invalid\n"
245
# sys.stderr.write(u"Client not found for DN: %s\n"
246
# % session.peer_certificate.subject)
247
#session.send("gazonk")
252
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
253
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1551
enabled: Boolean; whether this server is activated yet
1552
interface: None or a network interface name (string)
1553
use_ipv6: Boolean; to use IPv6 or not
255
options: Command line options
256
clients: Set() of Client objects
257
credentials: GnuTLS X.509 credentials
1555
def __init__(self, server_address, RequestHandlerClass,
1556
interface=None, use_ipv6=True):
1557
self.interface = interface
1559
self.address_family = socket.AF_INET6
1560
socketserver.TCPServer.__init__(self, server_address,
1561
RequestHandlerClass)
259
address_family = socket.AF_INET6
260
def __init__(self, *args, **kwargs):
261
if "options" in kwargs:
262
self.options = kwargs["options"]
263
del kwargs["options"]
264
if "clients" in kwargs:
265
self.clients = kwargs["clients"]
266
del kwargs["clients"]
267
if "credentials" in kwargs:
268
self.credentials = kwargs["credentials"]
269
del kwargs["credentials"]
270
return super(type(self), self).__init__(*args, **kwargs)
1562
271
def server_bind(self):
1563
272
"""This overrides the normal server_bind() function
1564
273
to bind to an interface if one was specified, and also NOT to
1565
274
bind to an address or port if they were not specified."""
1566
if self.interface is not None:
1567
if SO_BINDTODEVICE is None:
1568
logger.error("SO_BINDTODEVICE does not exist;"
1569
" cannot bind to interface %s",
1573
self.socket.setsockopt(socket.SOL_SOCKET,
1577
except socket.error as error:
1578
if error[0] == errno.EPERM:
1579
logger.error("No permission to"
1580
" bind to interface %s",
1582
elif error[0] == errno.ENOPROTOOPT:
1583
logger.error("SO_BINDTODEVICE not available;"
1584
" cannot bind to interface %s",
275
if self.options.interface:
276
if not hasattr(socket, "SO_BINDTODEVICE"):
277
# From /usr/include/asm-i486/socket.h
278
socket.SO_BINDTODEVICE = 25
280
self.socket.setsockopt(socket.SOL_SOCKET,
281
socket.SO_BINDTODEVICE,
282
self.options.interface)
283
except socket.error, error:
284
if error[0] == errno.EPERM:
285
sys.stderr.write(u"Warning: No permission to bind to interface %s\n"
286
% self.options.interface)
1588
289
# Only bind(2) the socket if we really need to.
1589
290
if self.server_address[0] or self.server_address[1]:
1590
291
if not self.server_address[0]:
1591
if self.address_family == socket.AF_INET6:
1592
any_address = "::" # in6addr_any
1594
any_address = socket.INADDR_ANY
1595
self.server_address = (any_address,
293
self.server_address = (in6addr_any,
1596
294
self.server_address[1])
1597
elif not self.server_address[1]:
295
elif self.server_address[1] is None:
1598
296
self.server_address = (self.server_address[0],
1600
# if self.interface:
1601
# self.server_address = (self.server_address[0],
1606
return socketserver.TCPServer.server_bind(self)
1609
class MandosServer(IPv6_TCPServer):
1613
clients: set of Client objects
1614
gnutls_priority GnuTLS priority string
1615
use_dbus: Boolean; to emit D-Bus signals or not
1617
Assumes a gobject.MainLoop event loop.
1619
def __init__(self, server_address, RequestHandlerClass,
1620
interface=None, use_ipv6=True, clients=None,
1621
gnutls_priority=None, use_dbus=True):
1622
self.enabled = False
1623
self.clients = clients
1624
if self.clients is None:
1625
self.clients = set()
1626
self.use_dbus = use_dbus
1627
self.gnutls_priority = gnutls_priority
1628
IPv6_TCPServer.__init__(self, server_address,
1629
RequestHandlerClass,
1630
interface = interface,
1631
use_ipv6 = use_ipv6)
1632
def server_activate(self):
1634
return socketserver.TCPServer.server_activate(self)
1639
def add_pipe(self, parent_pipe, proc):
1640
# Call "handle_ipc" for both data and EOF events
1641
gobject.io_add_watch(parent_pipe.fileno(),
1642
gobject.IO_IN | gobject.IO_HUP,
1643
functools.partial(self.handle_ipc,
1648
def handle_ipc(self, source, condition, parent_pipe=None,
1649
proc = None, client_object=None):
1651
gobject.IO_IN: "IN", # There is data to read.
1652
gobject.IO_OUT: "OUT", # Data can be written (without
1654
gobject.IO_PRI: "PRI", # There is urgent data to read.
1655
gobject.IO_ERR: "ERR", # Error condition.
1656
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1657
# broken, usually for pipes and
1660
conditions_string = ' | '.join(name
1662
condition_names.iteritems()
1663
if cond & condition)
1664
# error, or the other end of multiprocessing.Pipe has closed
1665
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1666
# Wait for other process to exit
1670
# Read a request from the child
1671
request = parent_pipe.recv()
1672
command = request[0]
1674
if command == 'init':
1676
address = request[2]
1678
for c in self.clients:
1679
if c.fingerprint == fpr:
1683
logger.info("Client not found for fingerprint: %s, ad"
1684
"dress: %s", fpr, address)
1687
mandos_dbus_service.ClientNotFound(fpr,
1689
parent_pipe.send(False)
1692
gobject.io_add_watch(parent_pipe.fileno(),
1693
gobject.IO_IN | gobject.IO_HUP,
1694
functools.partial(self.handle_ipc,
1700
parent_pipe.send(True)
1701
# remove the old hook in favor of the new above hook on
1704
if command == 'funcall':
1705
funcname = request[1]
1709
parent_pipe.send(('data', getattr(client_object,
1713
if command == 'getattr':
1714
attrname = request[1]
1715
if callable(client_object.__getattribute__(attrname)):
1716
parent_pipe.send(('function',))
1718
parent_pipe.send(('data', client_object
1719
.__getattribute__(attrname)))
1721
if command == 'setattr':
1722
attrname = request[1]
1724
setattr(client_object, attrname, value)
298
return super(type(self), self).server_bind()
1729
301
def string_to_delta(interval):
1730
302
"""Parse a string and return a datetime.timedelta
1732
304
>>> string_to_delta('7d')
1733
305
datetime.timedelta(7)
1734
306
>>> string_to_delta('60s')
1737
309
datetime.timedelta(0, 3600)
1738
310
>>> string_to_delta('24h')
1739
311
datetime.timedelta(1)
1740
>>> string_to_delta('1w')
312
>>> string_to_delta(u'1w')
1741
313
datetime.timedelta(7)
1742
>>> string_to_delta('5m 30s')
1743
datetime.timedelta(0, 330)
1745
timevalue = datetime.timedelta(0)
1746
for s in interval.split():
1748
suffix = unicode(s[-1])
1751
delta = datetime.timedelta(value)
1753
delta = datetime.timedelta(0, value)
1755
delta = datetime.timedelta(0, 0, 0, 0, value)
1757
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1759
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1761
raise ValueError("Unknown suffix %r" % suffix)
1762
except (ValueError, IndexError) as e:
1763
raise ValueError(*(e.args))
316
suffix=unicode(interval[-1])
317
value=int(interval[:-1])
319
delta = datetime.timedelta(value)
321
delta = datetime.timedelta(0, value)
323
delta = datetime.timedelta(0, 0, 0, 0, value)
325
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
327
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
330
except (ValueError, IndexError):
336
"""From the Avahi server example code"""
337
global group, serviceName, serviceType, servicePort, serviceTXT, \
340
group = dbus.Interface(
341
bus.get_object( avahi.DBUS_NAME,
342
server.EntryGroupNew()),
343
avahi.DBUS_INTERFACE_ENTRY_GROUP)
344
group.connect_to_signal('StateChanged',
345
entry_group_state_changed)
347
# print "Adding service '%s' of type '%s' ..." % (serviceName,
351
serviceInterface, # interface
352
avahi.PROTO_INET6, # protocol
353
dbus.UInt32(0), # flags
354
serviceName, serviceType,
356
dbus.UInt16(servicePort),
357
avahi.string_array_to_txt_array(serviceTXT))
361
def remove_service():
362
"""From the Avahi server example code"""
365
if not group is None:
369
def server_state_changed(state):
370
"""From the Avahi server example code"""
371
if state == avahi.SERVER_COLLISION:
372
print "WARNING: Server name collision"
374
elif state == avahi.SERVER_RUNNING:
378
def entry_group_state_changed(state, error):
379
"""From the Avahi server example code"""
380
global serviceName, server, rename_count
382
# print "state change: %i" % state
384
if state == avahi.ENTRY_GROUP_ESTABLISHED:
386
# print "Service established."
387
elif state == avahi.ENTRY_GROUP_COLLISION:
389
rename_count = rename_count - 1
391
name = server.GetAlternativeServiceName(name)
392
print "WARNING: Service name collision, changing name to '%s' ..." % name
397
print "ERROR: No suitable service name found after %i retries, exiting." % n_rename
399
elif state == avahi.ENTRY_GROUP_FAILURE:
400
print "Error in group state changed", error
1768
405
def if_nametoindex(interface):
1769
"""Call the C function if_nametoindex(), or equivalent
1771
Note: This function cannot accept a unicode string."""
1772
global if_nametoindex
406
"""Call the C function if_nametoindex()"""
1774
if_nametoindex = (ctypes.cdll.LoadLibrary
1775
(ctypes.util.find_library("c"))
1777
except (OSError, AttributeError):
1778
logger.warning("Doing if_nametoindex the hard way")
1779
def if_nametoindex(interface):
1780
"Get an interface index the hard way, i.e. using fcntl()"
1781
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1782
with contextlib.closing(socket.socket()) as s:
1783
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1784
struct.pack(str("16s16x"),
1786
interface_index = struct.unpack(str("I"),
1788
return interface_index
1789
return if_nametoindex(interface)
1792
def daemon(nochdir = False, noclose = False):
1793
"""See daemon(3). Standard BSD Unix function.
1795
This should really exist as os.daemon, but it doesn't (yet)."""
1804
# Close all standard open file descriptors
1805
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1806
if not stat.S_ISCHR(os.fstat(null).st_mode):
1807
raise OSError(errno.ENODEV,
1808
"%s not a character device"
1810
os.dup2(null, sys.stdin.fileno())
1811
os.dup2(null, sys.stdout.fileno())
1812
os.dup2(null, sys.stderr.fileno())
1819
##################################################################
1820
# Parsing of options, both command line and config file
1822
parser = argparse.ArgumentParser()
1823
parser.add_argument("-v", "--version", action="version",
1824
version = "%%(prog)s %s" % version,
1825
help="show version number and exit")
1826
parser.add_argument("-i", "--interface", metavar="IF",
1827
help="Bind to interface IF")
1828
parser.add_argument("-a", "--address",
1829
help="Address to listen for requests on")
1830
parser.add_argument("-p", "--port", type=int,
1831
help="Port number to receive requests on")
1832
parser.add_argument("--check", action="store_true",
1833
help="Run self-test")
1834
parser.add_argument("--debug", action="store_true",
1835
help="Debug mode; run in foreground and log"
1837
parser.add_argument("--debuglevel", metavar="LEVEL",
1838
help="Debug level for stdout output")
1839
parser.add_argument("--priority", help="GnuTLS"
1840
" priority string (see GnuTLS documentation)")
1841
parser.add_argument("--servicename",
1842
metavar="NAME", help="Zeroconf service name")
1843
parser.add_argument("--configdir",
1844
default="/etc/mandos", metavar="DIR",
1845
help="Directory to search for configuration"
1847
parser.add_argument("--no-dbus", action="store_false",
1848
dest="use_dbus", help="Do not provide D-Bus"
1849
" system bus interface")
1850
parser.add_argument("--no-ipv6", action="store_false",
1851
dest="use_ipv6", help="Do not use IPv6")
1852
options = parser.parse_args()
408
if "ctypes" not in sys.modules:
410
libc = ctypes.cdll.LoadLibrary("libc.so.6")
411
return libc.if_nametoindex(interface)
412
except (ImportError, OSError, AttributeError):
413
if "struct" not in sys.modules:
415
if "fcntl" not in sys.modules:
417
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
419
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
420
struct.pack("16s16x", interface))
422
interface_index = struct.unpack("I", ifreq[16:20])[0]
423
return interface_index
426
if __name__ == '__main__':
427
parser = OptionParser()
428
parser.add_option("-i", "--interface", type="string",
429
default=None, metavar="IF",
430
help="Bind to interface IF")
431
parser.add_option("--cert", type="string", default="cert.pem",
433
help="Public key certificate PEM file to use")
434
parser.add_option("--key", type="string", default="key.pem",
436
help="Private key PEM file to use")
437
parser.add_option("--ca", type="string", default="ca.pem",
439
help="Certificate Authority certificate PEM file to use")
440
parser.add_option("--crl", type="string", default="crl.pem",
442
help="Certificate Revokation List PEM file to use")
443
parser.add_option("-p", "--port", type="int", default=None,
444
help="Port number to receive requests on")
445
parser.add_option("--timeout", type="string", # Parsed later
447
help="Amount of downtime allowed for clients")
448
parser.add_option("--interval", type="string", # Parsed later
450
help="How often to check that a client is up")
451
parser.add_option("--check", action="store_true", default=False,
452
help="Run self-test")
453
(options, args) = parser.parse_args()
1854
455
if options.check:
1856
457
doctest.testmod()
1859
# Default values for config file for server-global settings
1860
server_defaults = { "interface": "",
1865
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1866
"servicename": "Mandos",
1872
# Parse config file for server-global settings
1873
server_config = configparser.SafeConfigParser(server_defaults)
1875
server_config.read(os.path.join(options.configdir,
1877
# Convert the SafeConfigParser object to a dict
1878
server_settings = server_config.defaults()
1879
# Use the appropriate methods on the non-string config options
1880
for option in ("debug", "use_dbus", "use_ipv6"):
1881
server_settings[option] = server_config.getboolean("DEFAULT",
1883
if server_settings["port"]:
1884
server_settings["port"] = server_config.getint("DEFAULT",
1888
# Override the settings from the config file with command line
1890
for option in ("interface", "address", "port", "debug",
1891
"priority", "servicename", "configdir",
1892
"use_dbus", "use_ipv6", "debuglevel"):
1893
value = getattr(options, option)
1894
if value is not None:
1895
server_settings[option] = value
1897
# Force all strings to be unicode
1898
for option in server_settings.keys():
1899
if type(server_settings[option]) is str:
1900
server_settings[option] = unicode(server_settings[option])
1901
# Now we have our good server settings in "server_settings"
1903
##################################################################
1906
debug = server_settings["debug"]
1907
debuglevel = server_settings["debuglevel"]
1908
use_dbus = server_settings["use_dbus"]
1909
use_ipv6 = server_settings["use_ipv6"]
1911
if server_settings["servicename"] != "Mandos":
1912
syslogger.setFormatter(logging.Formatter
1913
('Mandos (%s) [%%(process)d]:'
1914
' %%(levelname)s: %%(message)s'
1915
% server_settings["servicename"]))
1917
# Parse config file with clients
1918
client_defaults = { "timeout": "5m",
1919
"extended_timeout": "15m",
1921
"checker": "fping -q -- %%(host)s",
1923
"approval_delay": "0s",
1924
"approval_duration": "1s",
1926
client_config = configparser.SafeConfigParser(client_defaults)
1927
client_config.read(os.path.join(server_settings["configdir"],
1930
global mandos_dbus_service
1931
mandos_dbus_service = None
1933
tcp_server = MandosServer((server_settings["address"],
1934
server_settings["port"]),
1936
interface=(server_settings["interface"]
1940
server_settings["priority"],
1943
pidfilename = "/var/run/mandos.pid"
1945
pidfile = open(pidfilename, "w")
1947
logger.error("Could not open file %r", pidfilename)
1950
uid = pwd.getpwnam("_mandos").pw_uid
1951
gid = pwd.getpwnam("_mandos").pw_gid
1954
uid = pwd.getpwnam("mandos").pw_uid
1955
gid = pwd.getpwnam("mandos").pw_gid
1958
uid = pwd.getpwnam("nobody").pw_uid
1959
gid = pwd.getpwnam("nobody").pw_gid
1966
except OSError as error:
1967
if error[0] != errno.EPERM:
1970
if not debug and not debuglevel:
1971
syslogger.setLevel(logging.WARNING)
1972
console.setLevel(logging.WARNING)
1974
level = getattr(logging, debuglevel.upper())
1975
syslogger.setLevel(level)
1976
console.setLevel(level)
1979
# Enable all possible GnuTLS debugging
1981
# "Use a log level over 10 to enable all debugging options."
1983
gnutls.library.functions.gnutls_global_set_log_level(11)
1985
@gnutls.library.types.gnutls_log_func
1986
def debug_gnutls(level, string):
1987
logger.debug("GnuTLS: %s", string[:-1])
1989
(gnutls.library.functions
1990
.gnutls_global_set_log_function(debug_gnutls))
1992
# Redirect stdin so all checkers get /dev/null
1993
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1994
os.dup2(null, sys.stdin.fileno())
1998
# No console logging
1999
logger.removeHandler(console)
2001
# Need to fork before connecting to D-Bus
2003
# Close all input and output, do double fork, etc.
2007
# From the Avahi example code
460
# Parse the time arguments
462
options.timeout = string_to_delta(options.timeout)
464
parser.error("option --timeout: Unparseable time")
466
options.interval = string_to_delta(options.interval)
468
parser.error("option --interval: Unparseable time")
470
cert = gnutls.crypto.X509Certificate(open(options.cert).read())
471
key = gnutls.crypto.X509PrivateKey(open(options.key).read())
472
ca = gnutls.crypto.X509Certificate(open(options.ca).read())
473
crl = gnutls.crypto.X509CRL(open(options.crl).read())
474
cred = gnutls.connection.X509Credentials(cert, key, [ca], [crl])
478
client_config = ConfigParser.SafeConfigParser(defaults)
479
#client_config.readfp(open("secrets.conf"), "secrets.conf")
480
client_config.read("mandos-clients.conf")
482
# From the Avahi server example code
2008
483
DBusGMainLoop(set_as_default=True )
2009
484
main_loop = gobject.MainLoop()
2010
485
bus = dbus.SystemBus()
2011
# End of Avahi example code
2014
bus_name = dbus.service.BusName("se.recompile.Mandos",
2015
bus, do_not_queue=True)
2016
old_bus_name = (dbus.service.BusName
2017
("se.bsnet.fukt.Mandos", bus,
2019
except dbus.exceptions.NameExistsException as e:
2020
logger.error(unicode(e) + ", disabling D-Bus")
2022
server_settings["use_dbus"] = False
2023
tcp_server.use_dbus = False
2024
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2025
service = AvahiService(name = server_settings["servicename"],
2026
servicetype = "_mandos._tcp",
2027
protocol = protocol, bus = bus)
2028
if server_settings["interface"]:
2029
service.interface = (if_nametoindex
2030
(str(server_settings["interface"])))
2032
global multiprocessing_manager
2033
multiprocessing_manager = multiprocessing.Manager()
2035
client_class = Client
2037
client_class = functools.partial(ClientDBusTransitional,
2039
def client_config_items(config, section):
2040
special_settings = {
2041
"approved_by_default":
2042
lambda: config.getboolean(section,
2043
"approved_by_default"),
2045
for name, value in config.items(section):
2047
yield (name, special_settings[name]())
2051
tcp_server.clients.update(set(
2052
client_class(name = section,
2053
config= dict(client_config_items(
2054
client_config, section)))
2055
for section in client_config.sections()))
2056
if not tcp_server.clients:
2057
logger.warning("No clients defined")
2063
pidfile.write(str(pid) + "\n".encode("utf-8"))
2066
logger.error("Could not write to file %r with PID %d",
2069
# "pidfile" was never created
2073
signal.signal(signal.SIGINT, signal.SIG_IGN)
2075
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2076
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2079
class MandosDBusService(dbus.service.Object):
2080
"""A D-Bus proxy object"""
2082
dbus.service.Object.__init__(self, bus, "/")
2083
_interface = "se.recompile.Mandos"
2085
@dbus.service.signal(_interface, signature="o")
2086
def ClientAdded(self, objpath):
2090
@dbus.service.signal(_interface, signature="ss")
2091
def ClientNotFound(self, fingerprint, address):
2095
@dbus.service.signal(_interface, signature="os")
2096
def ClientRemoved(self, objpath, name):
2100
@dbus.service.method(_interface, out_signature="ao")
2101
def GetAllClients(self):
2103
return dbus.Array(c.dbus_object_path
2104
for c in tcp_server.clients)
2106
@dbus.service.method(_interface,
2107
out_signature="a{oa{sv}}")
2108
def GetAllClientsWithProperties(self):
2110
return dbus.Dictionary(
2111
((c.dbus_object_path, c.GetAll(""))
2112
for c in tcp_server.clients),
2115
@dbus.service.method(_interface, in_signature="o")
2116
def RemoveClient(self, object_path):
2118
for c in tcp_server.clients:
2119
if c.dbus_object_path == object_path:
2120
tcp_server.clients.remove(c)
2121
c.remove_from_connection()
2122
# Don't signal anything except ClientRemoved
2123
c.disable(quiet=True)
2125
self.ClientRemoved(object_path, c.name)
2127
raise KeyError(object_path)
2131
class MandosDBusServiceTransitional(MandosDBusService):
2132
__metaclass__ = AlternateDBusNamesMetaclass
2133
mandos_dbus_service = MandosDBusServiceTransitional()
2136
"Cleanup function; run on exit"
2139
multiprocessing.active_children()
2140
while tcp_server.clients:
2141
client = tcp_server.clients.pop()
2143
client.remove_from_connection()
2144
client.disable_hook = None
2145
# Don't signal anything except ClientRemoved
2146
client.disable(quiet=True)
2149
mandos_dbus_service.ClientRemoved(client
2153
atexit.register(cleanup)
2155
for client in tcp_server.clients:
2158
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2162
tcp_server.server_activate()
2164
# Find out what port we got
2165
service.port = tcp_server.socket.getsockname()[1]
2167
logger.info("Now listening on address %r, port %d,"
2168
" flowinfo %d, scope_id %d"
2169
% tcp_server.socket.getsockname())
2171
logger.info("Now listening on address %r, port %d"
2172
% tcp_server.socket.getsockname())
2174
#service.interface = tcp_server.socket.getsockname()[3]
486
server = dbus.Interface(
487
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
488
avahi.DBUS_INTERFACE_SERVER )
489
# End of Avahi example code
492
def remove_from_clients(client):
493
clients.remove(client)
495
print "No clients left, exiting"
498
clients.update(Set(Client(name=section, options=options,
499
stop_hook = remove_from_clients,
500
**(dict(client_config\
502
for section in client_config.sections()))
503
for client in clients:
506
tcp_server = IPv6_TCPServer((None, options.port),
511
# Find out what random port we got
512
servicePort = tcp_server.socket.getsockname()[1]
513
#sys.stderr.write("Now listening on port %d\n" % servicePort)
515
if options.interface is not None:
516
serviceInterface = if_nametoindex(options.interface)
518
# From the Avahi server example code
519
server.connect_to_signal("StateChanged", server_state_changed)
520
server_state_changed(server.GetState())
521
# End of Avahi example code
523
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
524
lambda *args, **kwargs:
525
tcp_server.handle_request(*args[2:],
2177
# From the Avahi example code
2180
except dbus.exceptions.DBusException as error:
2181
logger.critical("DBusException: %s", error)
2184
# End of Avahi example code
2186
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2187
lambda *args, **kwargs:
2188
(tcp_server.handle_request
2189
(*args[2:], **kwargs) or True))
2191
logger.debug("Starting main loop")
2193
except AvahiError as error:
2194
logger.critical("AvahiError: %s", error)
2197
529
except KeyboardInterrupt:
2199
print("", file=sys.stderr)
2200
logger.debug("Server received KeyboardInterrupt")
2201
logger.debug("Server exiting")
2202
# Must run before the D-Bus bus name gets deregistered
2206
if __name__ == '__main__':
534
# From the Avahi server example code
535
if not group is None:
537
# End of Avahi example code
539
for client in clients:
540
client.stop_hook = None