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
6
6
# This program is partly derived from an example program for an Avahi
7
7
# service publisher, downloaded from
8
8
# <http://avahi.org/wiki/PythonPublishExample>. This includes the
9
# methods "add" and "remove" in the "AvahiService" class, the
10
# "server_state_changed" and "entry_group_state_changed" functions,
11
# and some lines in "main".
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".
12
12
#
13
13
# Everything else is
14
14
# Copyright © 2008,2009 Teddy Hogeborn
33
33
34
34
from __future__ import division, with_statement, absolute_import
35
35
36
import SocketServer
36
import SocketServer as socketserver
37
37
import socket
38
38
import optparse
39
39
import datetime
44
44
import gnutls.library.functions
45
45
import gnutls.library.constants
46
46
import gnutls.library.types
47
import ConfigParser
47
import ConfigParser as configparser
48
48
import sys
49
49
import re
50
50
import os
51
51
import signal
52
from sets import Set
53
52
import subprocess
54
53
import atexit
55
54
import stat
56
55
import logging
57
56
import logging.handlers
58
57
import pwd
59
from contextlib import closing
58
import contextlib
59
import struct
60
import fcntl
61
import functools
62
import cPickle as pickle
63
import multiprocessing
60
64
61
65
import dbus
62
66
import dbus.service
65
69
from dbus.mainloop.glib import DBusGMainLoop
66
70
import ctypes
67
71
import ctypes.util
72
import xml.dom.minidom
73
import inspect
68
74
69
75
try:
70
76
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
72
78
try:
73
79
from IN import SO_BINDTODEVICE
74
80
except ImportError:
75
# From /usr/include/asm/socket.h
76
SO_BINDTODEVICE = 25
77
78
79
version = "1.0.8"
80
81
logger = logging.Logger('mandos')
81
SO_BINDTODEVICE = None
82
83
84
version = "1.0.14"
85
86
#logger = logging.getLogger(u'mandos')
87
logger = logging.Logger(u'mandos')
82
88
syslogger = (logging.handlers.SysLogHandler
83
89
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
84
90
address = "/dev/log"))
85
91
syslogger.setFormatter(logging.Formatter
86
('Mandos [%(process)d]: %(levelname)s:'
87
' %(message)s'))
92
(u'Mandos [%(process)d]: %(levelname)s:'
93
u' %(message)s'))
88
94
logger.addHandler(syslogger)
89
95
90
96
console = logging.StreamHandler()
91
console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'
92
' %(levelname)s: %(message)s'))
97
console.setFormatter(logging.Formatter(u'%(name)s [%(process)d]:'
98
u' %(levelname)s:'
99
u' %(message)s'))
93
100
logger.addHandler(console)
94
101
95
102
class AvahiError(Exception):
112
119
Attributes:
113
120
interface: integer; avahi.IF_UNSPEC or an interface index.
114
121
Used to optionally bind to the specified interface.
115
name: string; Example: 'Mandos'
116
type: string; Example: '_mandos._tcp'.
122
name: string; Example: u'Mandos'
123
type: string; Example: u'_mandos._tcp'.
117
124
See <http://www.dns-sd.org/ServiceTypes.html>
118
125
port: integer; what port to announce
119
126
TXT: list of strings; TXT record for the service
122
129
max_renames: integer; maximum number of renames
123
130
rename_count: integer; counter so we only rename after collisions
124
131
a sensible number of times
132
group: D-Bus Entry Group
133
server: D-Bus Server
134
bus: dbus.SystemBus()
125
135
"""
126
136
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
127
137
servicetype = None, port = None, TXT = None,
128
domain = "", host = "", max_renames = 32768,
129
protocol = avahi.PROTO_UNSPEC):
138
domain = u"", host = u"", max_renames = 32768,
139
protocol = avahi.PROTO_UNSPEC, bus = None):
130
140
self.interface = interface
131
141
self.name = name
132
142
self.type = servicetype
137
147
self.rename_count = 0
138
148
self.max_renames = max_renames
139
149
self.protocol = protocol
150
self.group = None # our entry group
151
self.server = None
152
self.bus = bus
140
153
def rename(self):
141
154
"""Derived from the Avahi example code"""
142
155
if self.rename_count >= self.max_renames:
144
157
u" after %i retries, exiting.",
145
158
self.rename_count)
146
159
raise AvahiServiceError(u"Too many renames")
147
self.name = server.GetAlternativeServiceName(self.name)
160
self.name = unicode(self.server.GetAlternativeServiceName(self.name))
148
161
logger.info(u"Changing Zeroconf service name to %r ...",
149
str(self.name))
162
self.name)
150
163
syslogger.setFormatter(logging.Formatter
151
('Mandos (%s) [%%(process)d]:'
152
' %%(levelname)s: %%(message)s'
164
(u'Mandos (%s) [%%(process)d]:'
165
u' %%(levelname)s: %%(message)s'
153
166
% self.name))
154
167
self.remove()
155
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)
156
174
self.rename_count += 1
157
175
def remove(self):
158
176
"""Derived from the Avahi example code"""
159
if group is not None:
160
group.Reset()
177
if self.group is not None:
178
self.group.Reset()
161
179
def add(self):
162
180
"""Derived from the Avahi example code"""
163
global group
164
if group is None:
165
group = dbus.Interface(bus.get_object
166
(avahi.DBUS_NAME,
167
server.EntryGroupNew()),
168
avahi.DBUS_INTERFACE_ENTRY_GROUP)
169
group.connect_to_signal('StateChanged',
170
entry_group_state_changed)
181
if self.group is None:
182
self.group = dbus.Interface(
183
self.bus.get_object(avahi.DBUS_NAME,
184
self.server.EntryGroupNew()),
185
avahi.DBUS_INTERFACE_ENTRY_GROUP)
186
self.group.connect_to_signal('StateChanged',
187
self
188
.entry_group_state_changed)
171
189
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
172
service.name, service.type)
173
group.AddService(
174
self.interface, # interface
175
self.protocol, # protocol
176
dbus.UInt32(0), # flags
177
self.name, self.type,
178
self.domain, self.host,
179
dbus.UInt16(self.port),
180
avahi.string_array_to_txt_array(self.TXT))
181
group.Commit()
182
183
# From the Avahi example code:
184
group = None # our entry group
185
# End of Avahi example code
186
187
188
def _datetime_to_dbus(dt, variant_level=0):
189
"""Convert a UTC datetime.datetime() to a D-Bus type."""
190
return dbus.String(dt.isoformat(), variant_level=variant_level)
190
self.name, self.type)
191
self.group.AddService(
192
self.interface,
193
self.protocol,
194
dbus.UInt32(0), # flags
195
self.name, self.type,
196
self.domain, self.host,
197
dbus.UInt16(self.port),
198
avahi.string_array_to_txt_array(self.TXT))
199
self.group.Commit()
200
def entry_group_state_changed(self, state, error):
201
"""Derived from the Avahi example code"""
202
logger.debug(u"Avahi entry group state change: %i", state)
203
204
if state == avahi.ENTRY_GROUP_ESTABLISHED:
205
logger.debug(u"Zeroconf service established.")
206
elif state == avahi.ENTRY_GROUP_COLLISION:
207
logger.warning(u"Zeroconf service name collision.")
208
self.rename()
209
elif state == avahi.ENTRY_GROUP_FAILURE:
210
logger.critical(u"Avahi: Error in group state changed %s",
211
unicode(error))
212
raise AvahiGroupError(u"State changed: %s"
213
% unicode(error))
214
def cleanup(self):
215
"""Derived from the Avahi example code"""
216
if self.group is not None:
217
self.group.Free()
218
self.group = None
219
def server_state_changed(self, state):
220
"""Derived from the Avahi example code"""
221
logger.debug(u"Avahi server state change: %i", state)
222
if state == avahi.SERVER_COLLISION:
223
logger.error(u"Zeroconf server name collision")
224
self.remove()
225
elif state == avahi.SERVER_RUNNING:
226
self.add()
227
def activate(self):
228
"""Derived from the Avahi example code"""
229
if self.server is None:
230
self.server = dbus.Interface(
231
self.bus.get_object(avahi.DBUS_NAME,
232
avahi.DBUS_PATH_SERVER),
233
avahi.DBUS_INTERFACE_SERVER)
234
self.server.connect_to_signal(u"StateChanged",
235
self.server_state_changed)
236
self.server_state_changed(self.server.GetState())
191
237
192
238
193
239
class Client(object):
194
240
"""A representation of a client host served by this server.
195
241
196
242
Attributes:
197
name: string; from the config file, used in log messages and
198
D-Bus identifiers
199
fingerprint: string (40 or 32 hexadecimal digits); used to
200
uniquely identify the client
201
secret: bytestring; sent verbatim (over TLS) to client
202
host: string; available for use by the checker command
203
created: datetime.datetime(); (UTC) object creation
204
last_enabled: datetime.datetime(); (UTC)
205
enabled: bool()
206
last_checked_ok: datetime.datetime(); (UTC) or None
207
timeout: datetime.timedelta(); How long from last_checked_ok
208
until this client is invalid
209
interval: datetime.timedelta(); How often to start a new checker
210
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
211
246
checker: subprocess.Popen(); a running checker process used
212
247
to see if the client lives.
213
248
'None' if no process is running.
214
checker_initiator_tag: a gobject event source tag, or None
215
disable_initiator_tag: - '' -
216
249
checker_callback_tag: - '' -
217
checker_command: string; External command which is run to check if
218
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
219
252
runtime with vars(self) as dict, so that for
220
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
221
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.
222
272
"""
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
279
@staticmethod
280
def _timedelta_to_milliseconds(td):
281
"Convert a datetime.timedelta() to milliseconds"
282
return ((td.days * 24 * 60 * 60 * 1000)
283
+ (td.seconds * 1000)
284
+ (td.microseconds // 1000))
285
223
286
def timeout_milliseconds(self):
224
287
"Return the 'timeout' attribute in milliseconds"
225
return ((self.timeout.days * 24 * 60 * 60 * 1000)
226
+ (self.timeout.seconds * 1000)
227
+ (self.timeout.microseconds // 1000))
288
return self._timedelta_to_milliseconds(self.timeout)
228
289
229
290
def interval_milliseconds(self):
230
291
"Return the 'interval' attribute in milliseconds"
231
return ((self.interval.days * 24 * 60 * 60 * 1000)
232
+ (self.interval.seconds * 1000)
233
+ (self.interval.microseconds // 1000))
292
return self._timedelta_to_milliseconds(self.interval)
293
294
def approval_delay_milliseconds(self):
295
return self._timedelta_to_milliseconds(self.approval_delay)
234
296
235
297
def __init__(self, name = None, disable_hook=None, config=None):
236
298
"""Note: the 'checker' key in 'config' sets the
243
305
# Uppercase and remove spaces from fingerprint for later
244
306
# comparison purposes with return value from the fingerprint()
245
307
# function
246
self.fingerprint = (config["fingerprint"].upper()
308
self.fingerprint = (config[u"fingerprint"].upper()
247
309
.replace(u" ", u""))
248
310
logger.debug(u" Fingerprint: %s", self.fingerprint)
249
if "secret" in config:
250
self.secret = config["secret"].decode(u"base64")
251
elif "secfile" in config:
252
with closing(open(os.path.expanduser
253
(os.path.expandvars
254
(config["secfile"])))) as secfile:
311
if u"secret" in config:
312
self.secret = config[u"secret"].decode(u"base64")
313
elif u"secfile" in config:
314
with open(os.path.expanduser(os.path.expandvars
315
(config[u"secfile"])),
316
"rb") as secfile:
255
317
self.secret = secfile.read()
256
318
else:
257
319
raise TypeError(u"No secret or secfile for client %s"
258
320
% self.name)
259
self.host = config.get("host", "")
321
self.host = config.get(u"host", u"")
260
322
self.created = datetime.datetime.utcnow()
261
323
self.enabled = False
262
324
self.last_enabled = None
263
325
self.last_checked_ok = None
264
self.timeout = string_to_delta(config["timeout"])
265
self.interval = string_to_delta(config["interval"])
326
self.timeout = string_to_delta(config[u"timeout"])
327
self.interval = string_to_delta(config[u"interval"])
266
328
self.disable_hook = disable_hook
267
329
self.checker = None
268
330
self.checker_initiator_tag = None
269
331
self.disable_initiator_tag = None
270
332
self.checker_callback_tag = None
271
self.checker_command = config["checker"]
333
self.checker_command = config[u"checker"]
272
334
self.current_checker_command = None
273
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())
274
345
346
def send_changedstate(self):
347
self.changedstate.acquire()
348
self.changedstate.notify_all()
349
self.changedstate.release()
350
275
351
def enable(self):
276
352
"""Start this client's checker and timeout hooks"""
353
if getattr(self, u"enabled", False):
354
# Already enabled
355
return
356
self.send_changedstate()
277
357
self.last_enabled = datetime.datetime.utcnow()
278
358
# Schedule a new checker to be started an 'interval' from now,
279
359
# and every interval from then on.
280
360
self.checker_initiator_tag = (gobject.timeout_add
281
361
(self.interval_milliseconds(),
282
362
self.start_checker))
283
# Also start a new checker *right now*.
284
self.start_checker()
285
363
# Schedule a disable() when 'timeout' has passed
286
364
self.disable_initiator_tag = (gobject.timeout_add
287
365
(self.timeout_milliseconds(),
288
366
self.disable))
289
367
self.enabled = True
368
# Also start a new checker *right now*.
369
self.start_checker()
290
370
291
def disable(self):
371
def disable(self, quiet=True):
292
372
"""Disable this client."""
293
373
if not getattr(self, "enabled", False):
294
374
return False
295
logger.info(u"Disabling client %s", self.name)
296
if getattr(self, "disable_initiator_tag", False):
375
if not quiet:
376
self.send_changedstate()
377
if not quiet:
378
logger.info(u"Disabling client %s", self.name)
379
if getattr(self, u"disable_initiator_tag", False):
297
380
gobject.source_remove(self.disable_initiator_tag)
298
381
self.disable_initiator_tag = None
299
if getattr(self, "checker_initiator_tag", False):
382
if getattr(self, u"checker_initiator_tag", False):
300
383
gobject.source_remove(self.checker_initiator_tag)
301
384
self.checker_initiator_tag = None
302
385
self.stop_checker()
350
433
# client would inevitably timeout, since no checker would get
351
434
# a chance to run to completion. If we instead leave running
352
435
# checkers alone, the checker would have to take more time
353
# than 'timeout' for the client to be declared invalid, which
354
# is as it should be.
436
# than 'timeout' for the client to be disabled, which is as it
437
# should be.
355
438
356
439
# If a checker exists, make sure it is not a zombie
357
if self.checker is not None:
440
try:
358
441
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
442
except (AttributeError, OSError), error:
443
if (isinstance(error, OSError)
444
and error.errno != errno.ECHILD):
445
raise error
446
else:
359
447
if pid:
360
logger.warning("Checker was a zombie")
448
logger.warning(u"Checker was a zombie")
361
449
gobject.source_remove(self.checker_callback_tag)
362
450
self.checker_callback(pid, status,
363
451
self.current_checker_command)
368
456
command = self.checker_command % self.host
369
457
except TypeError:
370
458
# Escape attributes for the shell
371
escaped_attrs = dict((key, re.escape(str(val)))
372
for key, val in
373
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
374
467
try:
375
468
command = self.checker_command % escaped_attrs
376
469
except TypeError, error:
387
480
# always replaced by /dev/null.)
388
481
self.checker = subprocess.Popen(command,
389
482
close_fds=True,
390
shell=True, cwd="/")
483
shell=True, cwd=u"/")
391
484
self.checker_callback_tag = (gobject.child_watch_add
392
485
(self.checker.pid,
393
486
self.checker_callback,
409
502
if self.checker_callback_tag:
410
503
gobject.source_remove(self.checker_callback_tag)
411
504
self.checker_callback_tag = None
412
if getattr(self, "checker", None) is None:
505
if getattr(self, u"checker", None) is None:
413
506
return
414
507
logger.debug(u"Stopping checker for %(name)s", vars(self))
415
508
try:
416
509
os.kill(self.checker.pid, signal.SIGTERM)
417
#os.sleep(0.5)
510
#time.sleep(0.5)
418
511
#if self.checker.poll() is None:
419
512
# os.kill(self.checker.pid, signal.SIGKILL)
420
513
except OSError, error:
421
514
if error.errno != errno.ESRCH: # No such process
422
515
raise
423
516
self.checker = None
424
425
def still_valid(self):
426
"""Has the timeout not yet passed for this client?"""
427
if not getattr(self, "enabled", False):
428
return False
429
now = datetime.datetime.utcnow()
430
if self.last_checked_ok is None:
431
return now < (self.created + self.timeout)
432
else:
433
return now < (self.last_checked_ok + self.timeout)
434
435
436
class ClientDBus(Client, dbus.service.Object):
517
518
def dbus_service_property(dbus_interface, signature=u"v",
519
access=u"readwrite", byte_arrays=False):
520
"""Decorators for marking methods of a DBusObjectWithProperties to
521
become properties on the D-Bus.
522
523
The decorated method will be called with no arguments by "Get"
524
and with one argument by "Set".
525
526
The parameters, where they are supported, are the same as
527
dbus.service.method, except there is only "signature", since the
528
type from Get() and the type sent to Set() is the same.
529
"""
530
# Encoding deeply encoded byte arrays is not supported yet by the
531
# "Set" method, so we fail early here:
532
if byte_arrays and signature != u"ay":
533
raise ValueError(u"Byte arrays not supported for non-'ay'"
534
u" signature %r" % signature)
535
def decorator(func):
536
func._dbus_is_property = True
537
func._dbus_interface = dbus_interface
538
func._dbus_signature = signature
539
func._dbus_access = access
540
func._dbus_name = func.__name__
541
if func._dbus_name.endswith(u"_dbus_property"):
542
func._dbus_name = func._dbus_name[:-14]
543
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
544
return func
545
return decorator
546
547
548
class DBusPropertyException(dbus.exceptions.DBusException):
549
"""A base class for D-Bus property-related exceptions
550
"""
551
def __unicode__(self):
552
return unicode(str(self))
553
554
555
class DBusPropertyAccessException(DBusPropertyException):
556
"""A property's access permissions disallows an operation.
557
"""
558
pass
559
560
561
class DBusPropertyNotFound(DBusPropertyException):
562
"""An attempt was made to access a non-existing property.
563
"""
564
pass
565
566
567
class DBusObjectWithProperties(dbus.service.Object):
568
"""A D-Bus object with properties.
569
570
Classes inheriting from this can use the dbus_service_property
571
decorator to expose methods as D-Bus properties. It exposes the
572
standard Get(), Set(), and GetAll() methods on the D-Bus.
573
"""
574
575
@staticmethod
576
def _is_dbus_property(obj):
577
return getattr(obj, u"_dbus_is_property", False)
578
579
def _get_all_dbus_properties(self):
580
"""Returns a generator of (name, attribute) pairs
581
"""
582
return ((prop._dbus_name, prop)
583
for name, prop in
584
inspect.getmembers(self, self._is_dbus_property))
585
586
def _get_dbus_property(self, interface_name, property_name):
587
"""Returns a bound method if one exists which is a D-Bus
588
property with the specified name and interface.
589
"""
590
for name in (property_name,
591
property_name + u"_dbus_property"):
592
prop = getattr(self, name, None)
593
if (prop is None
594
or not self._is_dbus_property(prop)
595
or prop._dbus_name != property_name
596
or (interface_name and prop._dbus_interface
597
and interface_name != prop._dbus_interface)):
598
continue
599
return prop
600
# No such property
601
raise DBusPropertyNotFound(self.dbus_object_path + u":"
602
+ interface_name + u"."
603
+ property_name)
604
605
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
606
out_signature=u"v")
607
def Get(self, interface_name, property_name):
608
"""Standard D-Bus property Get() method, see D-Bus standard.
609
"""
610
prop = self._get_dbus_property(interface_name, property_name)
611
if prop._dbus_access == u"write":
612
raise DBusPropertyAccessException(property_name)
613
value = prop()
614
if not hasattr(value, u"variant_level"):
615
return value
616
return type(value)(value, variant_level=value.variant_level+1)
617
618
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
619
def Set(self, interface_name, property_name, value):
620
"""Standard D-Bus property Set() method, see D-Bus standard.
621
"""
622
prop = self._get_dbus_property(interface_name, property_name)
623
if prop._dbus_access == u"read":
624
raise DBusPropertyAccessException(property_name)
625
if prop._dbus_get_args_options[u"byte_arrays"]:
626
# The byte_arrays option is not supported yet on
627
# signatures other than "ay".
628
if prop._dbus_signature != u"ay":
629
raise ValueError
630
value = dbus.ByteArray(''.join(unichr(byte)
631
for byte in value))
632
prop(value)
633
634
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
635
out_signature=u"a{sv}")
636
def GetAll(self, interface_name):
637
"""Standard D-Bus property GetAll() method, see D-Bus
638
standard.
639
640
Note: Will not include properties with access="write".
641
"""
642
all = {}
643
for name, prop in self._get_all_dbus_properties():
644
if (interface_name
645
and interface_name != prop._dbus_interface):
646
# Interface non-empty but did not match
647
continue
648
# Ignore write-only properties
649
if prop._dbus_access == u"write":
650
continue
651
value = prop()
652
if not hasattr(value, u"variant_level"):
653
all[name] = value
654
continue
655
all[name] = type(value)(value, variant_level=
656
value.variant_level+1)
657
return dbus.Dictionary(all, signature=u"sv")
658
659
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
660
out_signature=u"s",
661
path_keyword='object_path',
662
connection_keyword='connection')
663
def Introspect(self, object_path, connection):
664
"""Standard D-Bus method, overloaded to insert property tags.
665
"""
666
xmlstring = dbus.service.Object.Introspect(self, object_path,
667
connection)
668
try:
669
document = xml.dom.minidom.parseString(xmlstring)
670
def make_tag(document, name, prop):
671
e = document.createElement(u"property")
672
e.setAttribute(u"name", name)
673
e.setAttribute(u"type", prop._dbus_signature)
674
e.setAttribute(u"access", prop._dbus_access)
675
return e
676
for if_tag in document.getElementsByTagName(u"interface"):
677
for tag in (make_tag(document, name, prop)
678
for name, prop
679
in self._get_all_dbus_properties()
680
if prop._dbus_interface
681
== if_tag.getAttribute(u"name")):
682
if_tag.appendChild(tag)
683
# Add the names to the return values for the
684
# "org.freedesktop.DBus.Properties" methods
685
if (if_tag.getAttribute(u"name")
686
== u"org.freedesktop.DBus.Properties"):
687
for cn in if_tag.getElementsByTagName(u"method"):
688
if cn.getAttribute(u"name") == u"Get":
689
for arg in cn.getElementsByTagName(u"arg"):
690
if (arg.getAttribute(u"direction")
691
== u"out"):
692
arg.setAttribute(u"name", u"value")
693
elif cn.getAttribute(u"name") == u"GetAll":
694
for arg in cn.getElementsByTagName(u"arg"):
695
if (arg.getAttribute(u"direction")
696
== u"out"):
697
arg.setAttribute(u"name", u"props")
698
xmlstring = document.toxml(u"utf-8")
699
document.unlink()
700
except (AttributeError, xml.dom.DOMException,
701
xml.parsers.expat.ExpatError), error:
702
logger.error(u"Failed to override Introspection method",
703
error)
704
return xmlstring
705
706
707
class ClientDBus(Client, DBusObjectWithProperties):
437
708
"""A Client class using D-Bus
438
709
439
710
Attributes:
440
dbus_object_path: dbus.ObjectPath ; only set if self.use_dbus
711
dbus_object_path: dbus.ObjectPath
712
bus: dbus.SystemBus()
441
713
"""
714
715
runtime_expansions = (Client.runtime_expansions
716
+ (u"dbus_object_path",))
717
442
718
# dbus.service.Object doesn't use super(), so we can't either.
443
719
444
def __init__(self, *args, **kwargs):
720
def __init__(self, bus = None, *args, **kwargs):
721
self._approvals_pending = 0
722
self.bus = bus
445
723
Client.__init__(self, *args, **kwargs)
446
724
# Only now, when this client is initialized, can it show up on
447
725
# the D-Bus
726
client_object_name = unicode(self.name).translate(
727
{ord(u"."): ord(u"_"),
728
ord(u"-"): ord(u"_")})
448
729
self.dbus_object_path = (dbus.ObjectPath
449
("/clients/"
450
+ self.name.replace(".", "_")))
451
dbus.service.Object.__init__(self, bus,
452
self.dbus_object_path)
730
(u"/clients/" + client_object_name))
731
DBusObjectWithProperties.__init__(self, self.bus,
732
self.dbus_object_path)
733
734
def _get_approvals_pending(self):
735
return self._approvals_pending
736
def _set_approvals_pending(self, value):
737
old_value = self._approvals_pending
738
self._approvals_pending = value
739
bval = bool(value)
740
if (hasattr(self, "dbus_object_path")
741
and bval is not bool(old_value)):
742
dbus_bool = dbus.Boolean(bval, variant_level=1)
743
self.PropertyChanged(dbus.String(u"ApprovalPending"),
744
dbus_bool)
745
746
approvals_pending = property(_get_approvals_pending,
747
_set_approvals_pending)
748
del _get_approvals_pending, _set_approvals_pending
749
750
@staticmethod
751
def _datetime_to_dbus(dt, variant_level=0):
752
"""Convert a UTC datetime.datetime() to a D-Bus type."""
753
return dbus.String(dt.isoformat(),
754
variant_level=variant_level)
755
453
756
def enable(self):
454
oldstate = getattr(self, "enabled", False)
757
oldstate = getattr(self, u"enabled", False)
455
758
r = Client.enable(self)
456
759
if oldstate != self.enabled:
457
760
# Emit D-Bus signals
458
self.PropertyChanged(dbus.String(u"enabled"),
761
self.PropertyChanged(dbus.String(u"Enabled"),
459
762
dbus.Boolean(True, variant_level=1))
460
self.PropertyChanged(dbus.String(u"last_enabled"),
461
(_datetime_to_dbus(self.last_enabled,
462
variant_level=1)))
763
self.PropertyChanged(
764
dbus.String(u"LastEnabled"),
765
self._datetime_to_dbus(self.last_enabled,
766
variant_level=1))
463
767
return r
464
768
465
def disable(self, signal = True):
466
oldstate = getattr(self, "enabled", False)
467
r = Client.disable(self)
468
if signal and oldstate != self.enabled:
769
def disable(self, quiet = False):
770
oldstate = getattr(self, u"enabled", False)
771
r = Client.disable(self, quiet=quiet)
772
if not quiet and oldstate != self.enabled:
469
773
# Emit D-Bus signal
470
self.PropertyChanged(dbus.String(u"enabled"),
774
self.PropertyChanged(dbus.String(u"Enabled"),
471
775
dbus.Boolean(False, variant_level=1))
472
776
return r
473
777
476
780
self.remove_from_connection()
477
781
except LookupError:
478
782
pass
479
if hasattr(dbus.service.Object, "__del__"):
480
dbus.service.Object.__del__(self, *args, **kwargs)
783
if hasattr(DBusObjectWithProperties, u"__del__"):
784
DBusObjectWithProperties.__del__(self, *args, **kwargs)
481
785
Client.__del__(self, *args, **kwargs)
482
786
483
787
def checker_callback(self, pid, condition, command,
485
789
self.checker_callback_tag = None
486
790
self.checker = None
487
791
# Emit D-Bus signal
488
self.PropertyChanged(dbus.String(u"checker_running"),
792
self.PropertyChanged(dbus.String(u"CheckerRunning"),
489
793
dbus.Boolean(False, variant_level=1))
490
794
if os.WIFEXITED(condition):
491
795
exitstatus = os.WEXITSTATUS(condition)
506
810
r = Client.checked_ok(self, *args, **kwargs)
507
811
# Emit D-Bus signal
508
812
self.PropertyChanged(
509
dbus.String(u"last_checked_ok"),
510
(_datetime_to_dbus(self.last_checked_ok,
511
variant_level=1)))
813
dbus.String(u"LastCheckedOK"),
814
(self._datetime_to_dbus(self.last_checked_ok,
815
variant_level=1)))
512
816
return r
513
817
514
818
def start_checker(self, *args, **kwargs):
524
828
# Emit D-Bus signal
525
829
self.CheckerStarted(self.current_checker_command)
526
830
self.PropertyChanged(
527
dbus.String("checker_running"),
831
dbus.String(u"CheckerRunning"),
528
832
dbus.Boolean(True, variant_level=1))
529
833
return r
530
834
531
835
def stop_checker(self, *args, **kwargs):
532
old_checker = getattr(self, "checker", None)
836
old_checker = getattr(self, u"checker", None)
533
837
r = Client.stop_checker(self, *args, **kwargs)
534
838
if (old_checker is not None
535
and getattr(self, "checker", None) is None):
536
self.PropertyChanged(dbus.String(u"checker_running"),
839
and getattr(self, u"checker", None) is None):
840
self.PropertyChanged(dbus.String(u"CheckerRunning"),
537
841
dbus.Boolean(False, variant_level=1))
538
842
return r
539
540
## 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
541
857
_interface = u"se.bsnet.fukt.Mandos.Client"
542
858
543
# CheckedOK - method
544
CheckedOK = dbus.service.method(_interface)(checked_ok)
545
CheckedOK.__name__ = "CheckedOK"
859
## Signals
546
860
547
861
# CheckerCompleted - signal
548
@dbus.service.signal(_interface, signature="nxs")
862
@dbus.service.signal(_interface, signature=u"nxs")
549
863
def CheckerCompleted(self, exitcode, waitstatus, command):
550
864
"D-Bus signal"
551
865
pass
552
866
553
867
# CheckerStarted - signal
554
@dbus.service.signal(_interface, signature="s")
868
@dbus.service.signal(_interface, signature=u"s")
555
869
def CheckerStarted(self, command):
556
870
"D-Bus signal"
557
871
pass
558
872
559
# GetAllProperties - method
560
@dbus.service.method(_interface, out_signature="a{sv}")
561
def GetAllProperties(self):
562
"D-Bus method"
563
return dbus.Dictionary({
564
dbus.String("name"):
565
dbus.String(self.name, variant_level=1),
566
dbus.String("fingerprint"):
567
dbus.String(self.fingerprint, variant_level=1),
568
dbus.String("host"):
569
dbus.String(self.host, variant_level=1),
570
dbus.String("created"):
571
_datetime_to_dbus(self.created, variant_level=1),
572
dbus.String("last_enabled"):
573
(_datetime_to_dbus(self.last_enabled,
574
variant_level=1)
575
if self.last_enabled is not None
576
else dbus.Boolean(False, variant_level=1)),
577
dbus.String("enabled"):
578
dbus.Boolean(self.enabled, variant_level=1),
579
dbus.String("last_checked_ok"):
580
(_datetime_to_dbus(self.last_checked_ok,
581
variant_level=1)
582
if self.last_checked_ok is not None
583
else dbus.Boolean (False, variant_level=1)),
584
dbus.String("timeout"):
585
dbus.UInt64(self.timeout_milliseconds(),
586
variant_level=1),
587
dbus.String("interval"):
588
dbus.UInt64(self.interval_milliseconds(),
589
variant_level=1),
590
dbus.String("checker"):
591
dbus.String(self.checker_command,
592
variant_level=1),
593
dbus.String("checker_running"):
594
dbus.Boolean(self.checker is not None,
595
variant_level=1),
596
dbus.String("object_path"):
597
dbus.ObjectPath(self.dbus_object_path,
598
variant_level=1)
599
}, signature="sv")
600
601
# IsStillValid - method
602
@dbus.service.method(_interface, out_signature="b")
603
def IsStillValid(self):
604
return self.still_valid()
605
606
873
# PropertyChanged - signal
607
@dbus.service.signal(_interface, signature="sv")
874
@dbus.service.signal(_interface, signature=u"sv")
608
875
def PropertyChanged(self, property, value):
609
876
"D-Bus signal"
610
877
pass
611
878
612
# ReceivedSecret - signal
879
# GotSecret - signal
613
880
@dbus.service.signal(_interface)
614
def ReceivedSecret(self):
615
"D-Bus signal"
881
def GotSecret(self):
882
"""D-Bus signal
883
Is sent after a successful transfer of secret from the Mandos
884
server to mandos-client
885
"""
616
886
pass
617
887
618
888
# Rejected - signal
619
@dbus.service.signal(_interface)
620
def Rejected(self):
621
"D-Bus signal"
622
pass
623
624
# SetChecker - method
625
@dbus.service.method(_interface, in_signature="s")
626
def SetChecker(self, checker):
627
"D-Bus setter method"
628
self.checker_command = checker
629
# Emit D-Bus signal
630
self.PropertyChanged(dbus.String(u"checker"),
631
dbus.String(self.checker_command,
632
variant_level=1))
633
634
# SetHost - method
635
@dbus.service.method(_interface, in_signature="s")
636
def SetHost(self, host):
637
"D-Bus setter method"
638
self.host = host
639
# Emit D-Bus signal
640
self.PropertyChanged(dbus.String(u"host"),
641
dbus.String(self.host, variant_level=1))
642
643
# SetInterval - method
644
@dbus.service.method(_interface, in_signature="t")
645
def SetInterval(self, milliseconds):
646
self.interval = datetime.timedelta(0, 0, 0, milliseconds)
647
# Emit D-Bus signal
648
self.PropertyChanged(dbus.String(u"interval"),
649
(dbus.UInt64(self.interval_milliseconds(),
650
variant_level=1)))
651
652
# SetSecret - method
653
@dbus.service.method(_interface, in_signature="ay",
654
byte_arrays=True)
655
def SetSecret(self, secret):
656
"D-Bus setter method"
657
self.secret = str(secret)
658
659
# SetTimeout - method
660
@dbus.service.method(_interface, in_signature="t")
661
def SetTimeout(self, milliseconds):
662
self.timeout = datetime.timedelta(0, 0, 0, milliseconds)
663
# Emit D-Bus signal
664
self.PropertyChanged(dbus.String(u"timeout"),
665
(dbus.UInt64(self.timeout_milliseconds(),
666
variant_level=1)))
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()
667
911
668
912
# Enable - method
669
Enable = dbus.service.method(_interface)(enable)
670
Enable.__name__ = "Enable"
913
@dbus.service.method(_interface)
914
def Enable(self):
915
"D-Bus method"
916
self.enable()
671
917
672
918
# StartChecker - method
673
919
@dbus.service.method(_interface)
682
928
self.disable()
683
929
684
930
# StopChecker - method
685
StopChecker = dbus.service.method(_interface)(stop_checker)
686
StopChecker.__name__ = "StopChecker"
931
@dbus.service.method(_interface)
932
def StopChecker(self):
933
self.stop_checker()
934
935
## Properties
936
937
# ApprovalPending - property
938
@dbus_service_property(_interface, signature=u"b", access=u"read")
939
def ApprovalPending_dbus_property(self):
940
return dbus.Boolean(bool(self.approvals_pending))
941
942
# ApprovedByDefault - property
943
@dbus_service_property(_interface, signature=u"b",
944
access=u"readwrite")
945
def ApprovedByDefault_dbus_property(self, value=None):
946
if value is None: # get
947
return dbus.Boolean(self.approved_by_default)
948
self.approved_by_default = bool(value)
949
# Emit D-Bus signal
950
self.PropertyChanged(dbus.String(u"ApprovedByDefault"),
951
dbus.Boolean(value, variant_level=1))
952
953
# ApprovalDelay - property
954
@dbus_service_property(_interface, signature=u"t",
955
access=u"readwrite")
956
def ApprovalDelay_dbus_property(self, value=None):
957
if value is None: # get
958
return dbus.UInt64(self.approval_delay_milliseconds())
959
self.approval_delay = datetime.timedelta(0, 0, 0, value)
960
# Emit D-Bus signal
961
self.PropertyChanged(dbus.String(u"ApprovalDelay"),
962
dbus.UInt64(value, variant_level=1))
963
964
# ApprovalDuration - property
965
@dbus_service_property(_interface, signature=u"t",
966
access=u"readwrite")
967
def ApprovalDuration_dbus_property(self, value=None):
968
if value is None: # get
969
return dbus.UInt64(self._timedelta_to_milliseconds(
970
self.approval_duration))
971
self.approval_duration = datetime.timedelta(0, 0, 0, value)
972
# Emit D-Bus signal
973
self.PropertyChanged(dbus.String(u"ApprovalDuration"),
974
dbus.UInt64(value, variant_level=1))
975
976
# Name - property
977
@dbus_service_property(_interface, signature=u"s", access=u"read")
978
def Name_dbus_property(self):
979
return dbus.String(self.name)
980
981
# Fingerprint - property
982
@dbus_service_property(_interface, signature=u"s", access=u"read")
983
def Fingerprint_dbus_property(self):
984
return dbus.String(self.fingerprint)
985
986
# Host - property
987
@dbus_service_property(_interface, signature=u"s",
988
access=u"readwrite")
989
def Host_dbus_property(self, value=None):
990
if value is None: # get
991
return dbus.String(self.host)
992
self.host = value
993
# Emit D-Bus signal
994
self.PropertyChanged(dbus.String(u"Host"),
995
dbus.String(value, variant_level=1))
996
997
# Created - property
998
@dbus_service_property(_interface, signature=u"s", access=u"read")
999
def Created_dbus_property(self):
1000
return dbus.String(self._datetime_to_dbus(self.created))
1001
1002
# LastEnabled - property
1003
@dbus_service_property(_interface, signature=u"s", access=u"read")
1004
def LastEnabled_dbus_property(self):
1005
if self.last_enabled is None:
1006
return dbus.String(u"")
1007
return dbus.String(self._datetime_to_dbus(self.last_enabled))
1008
1009
# Enabled - property
1010
@dbus_service_property(_interface, signature=u"b",
1011
access=u"readwrite")
1012
def Enabled_dbus_property(self, value=None):
1013
if value is None: # get
1014
return dbus.Boolean(self.enabled)
1015
if value:
1016
self.enable()
1017
else:
1018
self.disable()
1019
1020
# LastCheckedOK - property
1021
@dbus_service_property(_interface, signature=u"s",
1022
access=u"readwrite")
1023
def LastCheckedOK_dbus_property(self, value=None):
1024
if value is not None:
1025
self.checked_ok()
1026
return
1027
if self.last_checked_ok is None:
1028
return dbus.String(u"")
1029
return dbus.String(self._datetime_to_dbus(self
1030
.last_checked_ok))
1031
1032
# Timeout - property
1033
@dbus_service_property(_interface, signature=u"t",
1034
access=u"readwrite")
1035
def Timeout_dbus_property(self, value=None):
1036
if value is None: # get
1037
return dbus.UInt64(self.timeout_milliseconds())
1038
self.timeout = datetime.timedelta(0, 0, 0, value)
1039
# Emit D-Bus signal
1040
self.PropertyChanged(dbus.String(u"Timeout"),
1041
dbus.UInt64(value, variant_level=1))
1042
if getattr(self, u"disable_initiator_tag", None) is None:
1043
return
1044
# Reschedule timeout
1045
gobject.source_remove(self.disable_initiator_tag)
1046
self.disable_initiator_tag = None
1047
time_to_die = (self.
1048
_timedelta_to_milliseconds((self
1049
.last_checked_ok
1050
+ self.timeout)
1051
- datetime.datetime
1052
.utcnow()))
1053
if time_to_die <= 0:
1054
# The timeout has passed
1055
self.disable()
1056
else:
1057
self.disable_initiator_tag = (gobject.timeout_add
1058
(time_to_die, self.disable))
1059
1060
# Interval - property
1061
@dbus_service_property(_interface, signature=u"t",
1062
access=u"readwrite")
1063
def Interval_dbus_property(self, value=None):
1064
if value is None: # get
1065
return dbus.UInt64(self.interval_milliseconds())
1066
self.interval = datetime.timedelta(0, 0, 0, value)
1067
# Emit D-Bus signal
1068
self.PropertyChanged(dbus.String(u"Interval"),
1069
dbus.UInt64(value, variant_level=1))
1070
if getattr(self, u"checker_initiator_tag", None) is None:
1071
return
1072
# Reschedule checker run
1073
gobject.source_remove(self.checker_initiator_tag)
1074
self.checker_initiator_tag = (gobject.timeout_add
1075
(value, self.start_checker))
1076
self.start_checker() # Start one now, too
1077
1078
# Checker - property
1079
@dbus_service_property(_interface, signature=u"s",
1080
access=u"readwrite")
1081
def Checker_dbus_property(self, value=None):
1082
if value is None: # get
1083
return dbus.String(self.checker_command)
1084
self.checker_command = value
1085
# Emit D-Bus signal
1086
self.PropertyChanged(dbus.String(u"Checker"),
1087
dbus.String(self.checker_command,
1088
variant_level=1))
1089
1090
# CheckerRunning - property
1091
@dbus_service_property(_interface, signature=u"b",
1092
access=u"readwrite")
1093
def CheckerRunning_dbus_property(self, value=None):
1094
if value is None: # get
1095
return dbus.Boolean(self.checker is not None)
1096
if value:
1097
self.start_checker()
1098
else:
1099
self.stop_checker()
1100
1101
# ObjectPath - property
1102
@dbus_service_property(_interface, signature=u"o", access=u"read")
1103
def ObjectPath_dbus_property(self):
1104
return self.dbus_object_path # is already a dbus.ObjectPath
1105
1106
# Secret = property
1107
@dbus_service_property(_interface, signature=u"ay",
1108
access=u"write", byte_arrays=True)
1109
def Secret_dbus_property(self, value):
1110
self.secret = str(value)
687
1111
688
1112
del _interface
689
1113
690
1114
691
class ClientHandler(SocketServer.BaseRequestHandler, object):
1115
class ProxyClient(object):
1116
def __init__(self, child_pipe, fpr, address):
1117
self._pipe = child_pipe
1118
self._pipe.send(('init', fpr, address))
1119
if not self._pipe.recv():
1120
raise KeyError()
1121
1122
def __getattribute__(self, name):
1123
if(name == '_pipe'):
1124
return super(ProxyClient, self).__getattribute__(name)
1125
self._pipe.send(('getattr', name))
1126
data = self._pipe.recv()
1127
if data[0] == 'data':
1128
return data[1]
1129
if data[0] == 'function':
1130
def func(*args, **kwargs):
1131
self._pipe.send(('funcall', name, args, kwargs))
1132
return self._pipe.recv()[1]
1133
return func
1134
1135
def __setattr__(self, name, value):
1136
if(name == '_pipe'):
1137
return super(ProxyClient, self).__setattr__(name, value)
1138
self._pipe.send(('setattr', name, value))
1139
1140
1141
class ClientHandler(socketserver.BaseRequestHandler, object):
692
1142
"""A class to handle client connections.
693
1143
694
1144
Instantiated once for each connection to handle it.
695
1145
Note: This will run in its own forked process."""
696
1146
697
1147
def handle(self):
698
logger.info(u"TCP connection from: %s",
699
unicode(self.client_address))
700
logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])
701
# Open IPC pipe to parent process
702
with closing(os.fdopen(self.server.pipe[1], "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
703
1154
session = (gnutls.connection
704
1155
.ClientSession(self.request,
705
1156
gnutls.connection
706
1157
.X509Credentials()))
707
708
line = self.request.makefile().readline()
709
logger.debug(u"Protocol version: %r", line)
710
try:
711
if int(line.strip().split()[0]) > 1:
712
raise RuntimeError
713
except (ValueError, IndexError, RuntimeError), error:
714
logger.error(u"Unknown protocol version: %s", error)
715
return
716
1158
717
1159
# Note: gnutls.connection.X509Credentials is really a
718
1160
# generic GnuTLS certificate credentials object so long as
719
1161
# no X.509 keys are added to it. Therefore, we can use it
720
1162
# here despite using OpenPGP certificates.
721
722
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
723
# "+AES-256-CBC", "+SHA1",
724
# "+COMP-NULL", "+CTYPE-OPENPGP",
725
# "+DHE-DSS"))
1163
1164
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1165
# u"+AES-256-CBC", u"+SHA1",
1166
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1167
# u"+DHE-DSS"))
726
1168
# Use a fallback default, since this MUST be set.
727
1169
priority = self.server.gnutls_priority
728
1170
if priority is None:
729
priority = "NORMAL"
1171
priority = u"NORMAL"
730
1172
(gnutls.library.functions
731
1173
.gnutls_priority_set_direct(session._c_object,
732
1174
priority, None))
733
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
734
1188
try:
735
1189
session.handshake()
736
1190
except gnutls.errors.GNUTLSError, error:
739
1193
# established. Just abandon the request.
740
1194
return
741
1195
logger.debug(u"Handshake succeeded")
1196
1197
approval_required = False
742
1198
try:
743
fpr = self.fingerprint(self.peer_certificate(session))
744
except (TypeError, gnutls.errors.GNUTLSError), error:
745
logger.warning(u"Bad certificate: %s", error)
746
session.bye()
747
return
748
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()
749
1285
750
for c in self.server.clients:
751
if c.fingerprint == fpr:
752
client = c
753
break
754
else:
755
ipc.write("NOTFOUND %s\n" % fpr)
756
session.bye()
757
return
758
# Have to check if client.still_valid(), since it is
759
# possible that the client timed out while establishing
760
# the GnuTLS session.
761
if not client.still_valid():
762
ipc.write("INVALID %s\n" % client.name)
763
session.bye()
764
return
765
ipc.write("SENDING %s\n" % client.name)
766
sent_size = 0
767
while sent_size < len(client.secret):
768
sent = session.send(client.secret[sent_size:])
769
logger.debug(u"Sent: %d, remaining: %d",
770
sent, len(client.secret)
771
- (sent_size + sent))
772
sent_size += sent
773
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")
774
1293
775
1294
@staticmethod
776
1295
def peer_certificate(session):
786
1305
.gnutls_certificate_get_peers
787
1306
(session._c_object, ctypes.byref(list_size)))
788
1307
if not bool(cert_list) and list_size.value != 0:
789
raise gnutls.errors.GNUTLSError("error getting peer"
790
" certificate")
1308
raise gnutls.errors.GNUTLSError(u"error getting peer"
1309
u" certificate")
791
1310
if list_size.value == 0:
792
1311
return None
793
1312
cert = cert_list[0]
819
1338
if crtverify.value != 0:
820
1339
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
821
1340
raise (gnutls.errors.CertificateSecurityError
822
("Verify failed"))
1341
(u"Verify failed"))
823
1342
# New buffer for the fingerprint
824
1343
buf = ctypes.create_string_buffer(20)
825
1344
buf_len = ctypes.c_size_t()
836
1355
return hex_fpr
837
1356
838
1357
839
class ForkingMixInWithPipe(SocketServer.ForkingMixIn, object):
840
"""Like SocketServer.ForkingMixIn, but also pass a pipe.
841
842
Assumes a gobject.MainLoop event loop.
843
"""
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 """
844
1374
def process_request(self, request, client_address):
845
1375
"""Overrides and wraps the original process_request().
846
1376
847
This function creates a new pipe in self.pipe
1377
This function creates a new pipe in self.pipe
848
1378
"""
849
self.pipe = os.pipe()
850
super(ForkingMixInWithPipe,
1379
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1380
1381
super(MultiprocessingMixInWithPipe,
851
1382
self).process_request(request, client_address)
852
os.close(self.pipe[1]) # close write end
853
# Call "handle_ipc" for both data and EOF events
854
gobject.io_add_watch(self.pipe[0],
855
gobject.IO_IN | gobject.IO_HUP,
856
self.handle_ipc)
857
def handle_ipc(source, condition):
1383
self.child_pipe.close()
1384
self.add_pipe(parent_pipe)
1385
1386
def add_pipe(self, parent_pipe):
858
1387
"""Dummy function; override as necessary"""
859
os.close(source)
860
return False
861
862
863
class IPv6_TCPServer(ForkingMixInWithPipe,
864
SocketServer.TCPServer, object):
1388
pass
1389
1390
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1391
socketserver.TCPServer, object):
865
1392
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
866
1393
867
1394
Attributes:
868
1395
enabled: Boolean; whether this server is activated yet
869
1396
interface: None or a network interface name (string)
870
1397
use_ipv6: Boolean; to use IPv6 or not
871
----
872
clients: Set() of Client objects
873
gnutls_priority GnuTLS priority string
874
use_dbus: Boolean; to emit D-Bus signals or not
875
1398
"""
876
1399
def __init__(self, server_address, RequestHandlerClass,
877
interface=None, use_ipv6=True, clients=None,
878
gnutls_priority=None, use_dbus=True):
879
self.enabled = False
1400
interface=None, use_ipv6=True):
880
1401
self.interface = interface
881
1402
if use_ipv6:
882
1403
self.address_family = socket.AF_INET6
883
self.clients = clients
884
self.use_dbus = use_dbus
885
self.gnutls_priority = gnutls_priority
886
SocketServer.TCPServer.__init__(self, server_address,
1404
socketserver.TCPServer.__init__(self, server_address,
887
1405
RequestHandlerClass)
888
1406
def server_bind(self):
889
1407
"""This overrides the normal server_bind() function
890
1408
to bind to an interface if one was specified, and also NOT to
891
1409
bind to an address or port if they were not specified."""
892
1410
if self.interface is not None:
893
try:
894
self.socket.setsockopt(socket.SOL_SOCKET,
895
SO_BINDTODEVICE,
896
self.interface + '\0')
897
except socket.error, error:
898
if error[0] == errno.EPERM:
899
logger.error(u"No permission to"
900
u" bind to interface %s",
901
self.interface)
902
else:
903
raise
1411
if SO_BINDTODEVICE is None:
1412
logger.error(u"SO_BINDTODEVICE does not exist;"
1413
u" cannot bind to interface %s",
1414
self.interface)
1415
else:
1416
try:
1417
self.socket.setsockopt(socket.SOL_SOCKET,
1418
SO_BINDTODEVICE,
1419
str(self.interface
1420
+ u'\0'))
1421
except socket.error, error:
1422
if error[0] == errno.EPERM:
1423
logger.error(u"No permission to"
1424
u" bind to interface %s",
1425
self.interface)
1426
elif error[0] == errno.ENOPROTOOPT:
1427
logger.error(u"SO_BINDTODEVICE not available;"
1428
u" cannot bind to interface %s",
1429
self.interface)
1430
else:
1431
raise
904
1432
# Only bind(2) the socket if we really need to.
905
1433
if self.server_address[0] or self.server_address[1]:
906
1434
if not self.server_address[0]:
907
1435
if self.address_family == socket.AF_INET6:
908
any_address = "::" # in6addr_any
1436
any_address = u"::" # in6addr_any
909
1437
else:
910
1438
any_address = socket.INADDR_ANY
911
1439
self.server_address = (any_address,
919
1447
# 0, # flowinfo
920
1448
# if_nametoindex
921
1449
# (self.interface))
922
return SocketServer.TCPServer.server_bind(self)
1450
return socketserver.TCPServer.server_bind(self)
1451
1452
1453
class MandosServer(IPv6_TCPServer):
1454
"""Mandos server.
1455
1456
Attributes:
1457
clients: set of Client objects
1458
gnutls_priority GnuTLS priority string
1459
use_dbus: Boolean; to emit D-Bus signals or not
1460
1461
Assumes a gobject.MainLoop event loop.
1462
"""
1463
def __init__(self, server_address, RequestHandlerClass,
1464
interface=None, use_ipv6=True, clients=None,
1465
gnutls_priority=None, use_dbus=True):
1466
self.enabled = False
1467
self.clients = clients
1468
if self.clients is None:
1469
self.clients = set()
1470
self.use_dbus = use_dbus
1471
self.gnutls_priority = gnutls_priority
1472
IPv6_TCPServer.__init__(self, server_address,
1473
RequestHandlerClass,
1474
interface = interface,
1475
use_ipv6 = use_ipv6)
923
1476
def server_activate(self):
924
1477
if self.enabled:
925
return SocketServer.TCPServer.server_activate(self)
1478
return socketserver.TCPServer.server_activate(self)
926
1479
def enable(self):
927
1480
self.enabled = True
928
def handle_ipc(self, source, condition, file_objects={}):
1481
def add_pipe(self, parent_pipe):
1482
# Call "handle_ipc" for both data and EOF events
1483
gobject.io_add_watch(parent_pipe.fileno(),
1484
gobject.IO_IN | gobject.IO_HUP,
1485
functools.partial(self.handle_ipc,
1486
parent_pipe = parent_pipe))
1487
1488
def handle_ipc(self, source, condition, parent_pipe=None,
1489
client_object=None):
929
1490
condition_names = {
930
gobject.IO_IN: "IN", # There is data to read.
931
gobject.IO_OUT: "OUT", # Data can be written (without
932
# blocking).
933
gobject.IO_PRI: "PRI", # There is urgent data to read.
934
gobject.IO_ERR: "ERR", # Error condition.
935
gobject.IO_HUP: "HUP" # Hung up (the connection has been
936
# broken, usually for pipes and
937
# sockets).
1491
gobject.IO_IN: u"IN", # There is data to read.
1492
gobject.IO_OUT: u"OUT", # Data can be written (without
1493
# blocking).
1494
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1495
gobject.IO_ERR: u"ERR", # Error condition.
1496
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1497
# broken, usually for pipes and
1498
# sockets).
938
1499
}
939
1500
conditions_string = ' | '.join(name
940
1501
for cond, name in
941
1502
condition_names.iteritems()
942
1503
if cond & condition)
943
logger.debug("Handling IPC: FD = %d, condition = %s", source,
944
conditions_string)
945
946
# Turn the pipe file descriptor into a Python file object
947
if source not in file_objects:
948
file_objects[source] = os.fdopen(source, "r", 1)
949
950
# Read a line from the file object
951
cmdline = file_objects[source].readline()
952
if not cmdline: # Empty line means end of file
953
# close the IPC pipe
954
file_objects[source].close()
955
del file_objects[source]
956
957
# Stop calling this function
958
return False
959
960
logger.debug("IPC command: %r", cmdline)
961
962
# Parse and act on command
963
cmd, args = cmdline.rstrip("\r\n").split(None, 1)
964
965
if cmd == "NOTFOUND":
966
logger.warning(u"Client not found for fingerprint: %s",
967
args)
968
if self.use_dbus:
969
# Emit D-Bus signal
970
mandos_dbus_service.ClientNotFound(args)
971
elif cmd == "INVALID":
972
for client in self.clients:
973
if client.name == args:
974
logger.warning(u"Client %s is invalid", args)
975
if self.use_dbus:
976
# Emit D-Bus signal
977
client.Rejected()
978
break
979
else:
980
logger.error(u"Unknown client %s is invalid", args)
981
elif cmd == "SENDING":
982
for client in self.clients:
983
if client.name == args:
984
logger.info(u"Sending secret to %s", client.name)
985
client.checked_ok()
986
if self.use_dbus:
987
# Emit D-Bus signal
988
client.ReceivedSecret()
989
break
990
else:
991
logger.error(u"Sending secret to unknown client %s",
992
args)
993
else:
994
logger.error("Unknown IPC command: %r", cmdline)
995
996
# 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
997
1556
return True
998
1557
999
1558
1000
1559
def string_to_delta(interval):
1001
1560
"""Parse a string and return a datetime.timedelta
1002
1561
1003
>>> string_to_delta('7d')
1562
>>> string_to_delta(u'7d')
1004
1563
datetime.timedelta(7)
1005
>>> string_to_delta('60s')
1564
>>> string_to_delta(u'60s')
1006
1565
datetime.timedelta(0, 60)
1007
>>> string_to_delta('60m')
1566
>>> string_to_delta(u'60m')
1008
1567
datetime.timedelta(0, 3600)
1009
>>> string_to_delta('24h')
1568
>>> string_to_delta(u'24h')
1010
1569
datetime.timedelta(1)
1011
1570
>>> string_to_delta(u'1w')
1012
1571
datetime.timedelta(7)
1013
>>> string_to_delta('5m 30s')
1572
>>> string_to_delta(u'5m 30s')
1014
1573
datetime.timedelta(0, 330)
1015
1574
"""
1016
1575
timevalue = datetime.timedelta(0)
1029
1588
elif suffix == u"w":
1030
1589
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1031
1590
else:
1032
raise ValueError
1033
except (ValueError, IndexError):
1034
raise ValueError
1591
raise ValueError(u"Unknown suffix %r" % suffix)
1592
except (ValueError, IndexError), e:
1593
raise ValueError(e.message)
1035
1594
timevalue += delta
1036
1595
return timevalue
1037
1596
1038
1597
1039
def server_state_changed(state):
1040
"""Derived from the Avahi example code"""
1041
if state == avahi.SERVER_COLLISION:
1042
logger.error(u"Zeroconf server name collision")
1043
service.remove()
1044
elif state == avahi.SERVER_RUNNING:
1045
service.add()
1046
1047
1048
def entry_group_state_changed(state, error):
1049
"""Derived from the Avahi example code"""
1050
logger.debug(u"Avahi state change: %i", state)
1051
1052
if state == avahi.ENTRY_GROUP_ESTABLISHED:
1053
logger.debug(u"Zeroconf service established.")
1054
elif state == avahi.ENTRY_GROUP_COLLISION:
1055
logger.warning(u"Zeroconf service name collision.")
1056
service.rename()
1057
elif state == avahi.ENTRY_GROUP_FAILURE:
1058
logger.critical(u"Avahi: Error in group state changed %s",
1059
unicode(error))
1060
raise AvahiGroupError(u"State changed: %s" % unicode(error))
1061
1062
1598
def if_nametoindex(interface):
1063
"""Call the C function if_nametoindex(), or equivalent"""
1599
"""Call the C function if_nametoindex(), or equivalent
1600
1601
Note: This function cannot accept a unicode string."""
1064
1602
global if_nametoindex
1065
1603
try:
1066
1604
if_nametoindex = (ctypes.cdll.LoadLibrary
1067
(ctypes.util.find_library("c"))
1605
(ctypes.util.find_library(u"c"))
1068
1606
.if_nametoindex)
1069
1607
except (OSError, AttributeError):
1070
if "struct" not in sys.modules:
1071
import struct
1072
if "fcntl" not in sys.modules:
1073
import fcntl
1608
logger.warning(u"Doing if_nametoindex the hard way")
1074
1609
def if_nametoindex(interface):
1075
1610
"Get an interface index the hard way, i.e. using fcntl()"
1076
1611
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
1077
with closing(socket.socket()) as s:
1612
with contextlib.closing(socket.socket()) as s:
1078
1613
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
1079
struct.pack("16s16x", interface))
1080
interface_index = struct.unpack("I", ifreq[16:20])[0]
1614
struct.pack(str(u"16s16x"),
1615
interface))
1616
interface_index = struct.unpack(str(u"I"),
1617
ifreq[16:20])[0]
1081
1618
return interface_index
1082
1619
return if_nametoindex(interface)
1083
1620
1090
1627
sys.exit()
1091
1628
os.setsid()
1092
1629
if not nochdir:
1093
os.chdir("/")
1630
os.chdir(u"/")
1094
1631
if os.fork():
1095
1632
sys.exit()
1096
1633
if not noclose:
1098
1635
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1099
1636
if not stat.S_ISCHR(os.fstat(null).st_mode):
1100
1637
raise OSError(errno.ENODEV,
1101
"/dev/null not a character device")
1638
u"%s not a character device"
1639
% os.path.devnull)
1102
1640
os.dup2(null, sys.stdin.fileno())
1103
1641
os.dup2(null, sys.stdout.fileno())
1104
1642
os.dup2(null, sys.stderr.fileno())
1108
1646
1109
1647
def main():
1110
1648
1111
######################################################################
1649
##################################################################
1112
1650
# Parsing of options, both command line and config file
1113
1651
1114
1652
parser = optparse.OptionParser(version = "%%prog %s" % version)
1115
parser.add_option("-i", "--interface", type="string",
1116
metavar="IF", help="Bind to interface IF")
1117
parser.add_option("-a", "--address", type="string",
1118
help="Address to listen for requests on")
1119
parser.add_option("-p", "--port", type="int",
1120
help="Port number to receive requests on")
1121
parser.add_option("--check", action="store_true",
1122
help="Run self-test")
1123
parser.add_option("--debug", action="store_true",
1124
help="Debug mode; run in foreground and log to"
1125
" terminal")
1126
parser.add_option("--priority", type="string", help="GnuTLS"
1127
" priority string (see GnuTLS documentation)")
1128
parser.add_option("--servicename", type="string", metavar="NAME",
1129
help="Zeroconf service name")
1130
parser.add_option("--configdir", type="string",
1131
default="/etc/mandos", metavar="DIR",
1132
help="Directory to search for configuration"
1133
" files")
1134
parser.add_option("--no-dbus", action="store_false",
1135
dest="use_dbus",
1136
help="Do not provide D-Bus system bus"
1137
" interface")
1138
parser.add_option("--no-ipv6", action="store_false",
1139
dest="use_ipv6", help="Do not use IPv6")
1653
parser.add_option("-i", u"--interface", type=u"string",
1654
metavar="IF", help=u"Bind to interface IF")
1655
parser.add_option("-a", u"--address", type=u"string",
1656
help=u"Address to listen for requests on")
1657
parser.add_option("-p", u"--port", type=u"int",
1658
help=u"Port number to receive requests on")
1659
parser.add_option("--check", action=u"store_true",
1660
help=u"Run self-test")
1661
parser.add_option("--debug", action=u"store_true",
1662
help=u"Debug mode; run in foreground and log to"
1663
u" terminal")
1664
parser.add_option("--debuglevel", type=u"string", metavar="Level",
1665
help=u"Debug level for stdout output")
1666
parser.add_option("--priority", type=u"string", help=u"GnuTLS"
1667
u" priority string (see GnuTLS documentation)")
1668
parser.add_option("--servicename", type=u"string",
1669
metavar=u"NAME", help=u"Zeroconf service name")
1670
parser.add_option("--configdir", type=u"string",
1671
default=u"/etc/mandos", metavar=u"DIR",
1672
help=u"Directory to search for configuration"
1673
u" files")
1674
parser.add_option("--no-dbus", action=u"store_false",
1675
dest=u"use_dbus", help=u"Do not provide D-Bus"
1676
u" system bus interface")
1677
parser.add_option("--no-ipv6", action=u"store_false",
1678
dest=u"use_ipv6", help=u"Do not use IPv6")
1140
1679
options = parser.parse_args()[0]
1141
1680
1142
1681
if options.check:
1145
1684
sys.exit()
1146
1685
1147
1686
# Default values for config file for server-global settings
1148
server_defaults = { "interface": "",
1149
"address": "",
1150
"port": "",
1151
"debug": "False",
1152
"priority":
1153
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1154
"servicename": "Mandos",
1155
"use_dbus": "True",
1156
"use_ipv6": "True",
1687
server_defaults = { u"interface": u"",
1688
u"address": u"",
1689
u"port": u"",
1690
u"debug": u"False",
1691
u"priority":
1692
u"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
1693
u"servicename": u"Mandos",
1694
u"use_dbus": u"True",
1695
u"use_ipv6": u"True",
1696
u"debuglevel": u"",
1157
1697
}
1158
1698
1159
1699
# Parse config file for server-global settings
1160
server_config = ConfigParser.SafeConfigParser(server_defaults)
1700
server_config = configparser.SafeConfigParser(server_defaults)
1161
1701
del server_defaults
1162
server_config.read(os.path.join(options.configdir, "mandos.conf"))
1702
server_config.read(os.path.join(options.configdir,
1703
u"mandos.conf"))
1163
1704
# Convert the SafeConfigParser object to a dict
1164
1705
server_settings = server_config.defaults()
1165
1706
# Use the appropriate methods on the non-string config options
1166
server_settings["debug"] = server_config.getboolean("DEFAULT",
1167
"debug")
1168
server_settings["use_dbus"] = server_config.getboolean("DEFAULT",
1169
"use_dbus")
1170
server_settings["use_ipv6"] = server_config.getboolean("DEFAULT",
1171
"use_ipv6")
1707
for option in (u"debug", u"use_dbus", u"use_ipv6"):
1708
server_settings[option] = server_config.getboolean(u"DEFAULT",
1709
option)
1172
1710
if server_settings["port"]:
1173
server_settings["port"] = server_config.getint("DEFAULT",
1174
"port")
1711
server_settings["port"] = server_config.getint(u"DEFAULT",
1712
u"port")
1175
1713
del server_config
1176
1714
1177
1715
# Override the settings from the config file with command line
1178
1716
# options, if set.
1179
for option in ("interface", "address", "port", "debug",
1180
"priority", "servicename", "configdir",
1181
"use_dbus", "use_ipv6"):
1717
for option in (u"interface", u"address", u"port", u"debug",
1718
u"priority", u"servicename", u"configdir",
1719
u"use_dbus", u"use_ipv6", u"debuglevel"):
1182
1720
value = getattr(options, option)
1183
1721
if value is not None:
1184
1722
server_settings[option] = value
1185
1723
del options
1724
# Force all strings to be unicode
1725
for option in server_settings.keys():
1726
if type(server_settings[option]) is str:
1727
server_settings[option] = unicode(server_settings[option])
1186
1728
# Now we have our good server settings in "server_settings"
1187
1729
1188
1730
##################################################################
1189
1731
1190
1732
# For convenience
1191
debug = server_settings["debug"]
1192
use_dbus = server_settings["use_dbus"]
1193
use_ipv6 = server_settings["use_ipv6"]
1194
1195
if not debug:
1196
syslogger.setLevel(logging.WARNING)
1197
console.setLevel(logging.WARNING)
1198
1199
if server_settings["servicename"] != "Mandos":
1733
debug = server_settings[u"debug"]
1734
debuglevel = server_settings[u"debuglevel"]
1735
use_dbus = server_settings[u"use_dbus"]
1736
use_ipv6 = server_settings[u"use_ipv6"]
1737
1738
if server_settings[u"servicename"] != u"Mandos":
1200
1739
syslogger.setFormatter(logging.Formatter
1201
('Mandos (%s) [%%(process)d]:'
1202
' %%(levelname)s: %%(message)s'
1203
% server_settings["servicename"]))
1740
(u'Mandos (%s) [%%(process)d]:'
1741
u' %%(levelname)s: %%(message)s'
1742
% server_settings[u"servicename"]))
1204
1743
1205
1744
# Parse config file with clients
1206
client_defaults = { "timeout": "1h",
1207
"interval": "5m",
1208
"checker": "fping -q -- %%(host)s",
1209
"host": "",
1745
client_defaults = { u"timeout": u"1h",
1746
u"interval": u"5m",
1747
u"checker": u"fping -q -- %%(host)s",
1748
u"host": u"",
1749
u"approval_delay": u"0s",
1750
u"approval_duration": u"1s",
1210
1751
}
1211
client_config = ConfigParser.SafeConfigParser(client_defaults)
1212
client_config.read(os.path.join(server_settings["configdir"],
1213
"clients.conf"))
1214
1752
client_config = configparser.SafeConfigParser(client_defaults)
1753
client_config.read(os.path.join(server_settings[u"configdir"],
1754
u"clients.conf"))
1755
1215
1756
global mandos_dbus_service
1216
1757
mandos_dbus_service = None
1217
1758
1218
clients = Set()
1219
tcp_server = IPv6_TCPServer((server_settings["address"],
1220
server_settings["port"]),
1221
ClientHandler,
1222
interface=
1223
server_settings["interface"],
1224
use_ipv6=use_ipv6,
1225
clients=clients,
1226
gnutls_priority=
1227
server_settings["priority"],
1228
use_dbus=use_dbus)
1229
pidfilename = "/var/run/mandos.pid"
1230
try:
1231
pidfile = open(pidfilename, "w")
1232
except IOError:
1233
logger.error("Could not open file %r", pidfilename)
1759
tcp_server = MandosServer((server_settings[u"address"],
1760
server_settings[u"port"]),
1761
ClientHandler,
1762
interface=(server_settings[u"interface"]
1763
or None),
1764
use_ipv6=use_ipv6,
1765
gnutls_priority=
1766
server_settings[u"priority"],
1767
use_dbus=use_dbus)
1768
if not debug:
1769
pidfilename = u"/var/run/mandos.pid"
1770
try:
1771
pidfile = open(pidfilename, u"w")
1772
except IOError:
1773
logger.error(u"Could not open file %r", pidfilename)
1234
1774
1235
1775
try:
1236
uid = pwd.getpwnam("_mandos").pw_uid
1237
gid = pwd.getpwnam("_mandos").pw_gid
1776
uid = pwd.getpwnam(u"_mandos").pw_uid
1777
gid = pwd.getpwnam(u"_mandos").pw_gid
1238
1778
except KeyError:
1239
1779
try:
1240
uid = pwd.getpwnam("mandos").pw_uid
1241
gid = pwd.getpwnam("mandos").pw_gid
1780
uid = pwd.getpwnam(u"mandos").pw_uid
1781
gid = pwd.getpwnam(u"mandos").pw_gid
1242
1782
except KeyError:
1243
1783
try:
1244
uid = pwd.getpwnam("nobody").pw_uid
1245
gid = pwd.getpwnam("nogroup").pw_gid
1784
uid = pwd.getpwnam(u"nobody").pw_uid
1785
gid = pwd.getpwnam(u"nobody").pw_gid
1246
1786
except KeyError:
1247
1787
uid = 65534
1248
1788
gid = 65534
1253
1793
if error[0] != errno.EPERM:
1254
1794
raise error
1255
1795
1256
# 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
1257
1804
if debug:
1805
# Enable all possible GnuTLS debugging
1806
1258
1807
# "Use a log level over 10 to enable all debugging options."
1259
1808
# - GnuTLS manual
1260
1809
gnutls.library.functions.gnutls_global_set_log_level(11)
1261
1810
1262
1811
@gnutls.library.types.gnutls_log_func
1263
1812
def debug_gnutls(level, string):
1264
logger.debug("GnuTLS: %s", string[:-1])
1813
logger.debug(u"GnuTLS: %s", string[:-1])
1265
1814
1266
1815
(gnutls.library.functions
1267
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)
1268
1826
1269
global service
1270
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1271
service = AvahiService(name = server_settings["servicename"],
1272
servicetype = "_mandos._tcp",
1273
protocol = protocol)
1274
if server_settings["interface"]:
1275
service.interface = (if_nametoindex
1276
(server_settings["interface"]))
1277
1827
1278
1828
global main_loop
1279
global bus
1280
global server
1281
1829
# From the Avahi example code
1282
1830
DBusGMainLoop(set_as_default=True )
1283
1831
main_loop = gobject.MainLoop()
1284
1832
bus = dbus.SystemBus()
1285
server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
1286
avahi.DBUS_PATH_SERVER),
1287
avahi.DBUS_INTERFACE_SERVER)
1288
1833
# End of Avahi example code
1289
1834
if use_dbus:
1290
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos", bus)
1835
try:
1836
bus_name = dbus.service.BusName(u"se.bsnet.fukt.Mandos",
1837
bus, do_not_queue=True)
1838
except dbus.exceptions.NameExistsException, e:
1839
logger.error(unicode(e) + u", disabling D-Bus")
1840
use_dbus = False
1841
server_settings[u"use_dbus"] = False
1842
tcp_server.use_dbus = False
1843
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
1844
service = AvahiService(name = server_settings[u"servicename"],
1845
servicetype = u"_mandos._tcp",
1846
protocol = protocol, bus = bus)
1847
if server_settings["interface"]:
1848
service.interface = (if_nametoindex
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()
1291
1857
1292
1858
client_class = Client
1293
1859
if use_dbus:
1294
client_class = ClientDBus
1295
clients.update(Set(
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
1873
tcp_server.clients.update(set(
1296
1874
client_class(name = section,
1297
config= dict(client_config.items(section)))
1875
config= dict(client_config_items(
1876
client_config, section)))
1298
1877
for section in client_config.sections()))
1299
if not clients:
1878
if not tcp_server.clients:
1300
1879
logger.warning(u"No clients defined")
1301
1302
if debug:
1303
# Redirect stdin so all checkers get /dev/null
1304
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1305
os.dup2(null, sys.stdin.fileno())
1306
if null > 2:
1307
os.close(null)
1308
else:
1309
# No console logging
1310
logger.removeHandler(console)
1311
# Close all input and output, do double fork, etc.
1312
daemon()
1313
1314
try:
1315
with closing(pidfile):
1316
pid = os.getpid()
1317
pidfile.write(str(pid) + "\n")
1318
del pidfile
1319
except IOError:
1320
logger.error(u"Could not write to file %r with PID %d",
1321
pidfilename, pid)
1322
except NameError:
1323
# "pidfile" was never created
1324
pass
1325
del pidfilename
1326
1327
def cleanup():
1328
"Cleanup function; run on exit"
1329
global group
1330
# From the Avahi example code
1331
if not group is None:
1332
group.Free()
1333
group = None
1334
# End of Avahi example code
1335
1880
1336
while clients:
1337
client = clients.pop()
1338
client.disable_hook = None
1339
client.disable()
1340
1341
atexit.register(cleanup)
1342
1343
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
1344
1895
signal.signal(signal.SIGINT, signal.SIG_IGN)
1896
1345
1897
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
1346
1898
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
1347
1899
1349
1901
class MandosDBusService(dbus.service.Object):
1350
1902
"""A D-Bus proxy object"""
1351
1903
def __init__(self):
1352
dbus.service.Object.__init__(self, bus, "/")
1904
dbus.service.Object.__init__(self, bus, u"/")
1353
1905
_interface = u"se.bsnet.fukt.Mandos"
1354
1906
1355
@dbus.service.signal(_interface, signature="oa{sv}")
1356
def ClientAdded(self, objpath, properties):
1357
"D-Bus signal"
1358
pass
1359
1360
@dbus.service.signal(_interface, signature="s")
1361
def ClientNotFound(self, fingerprint):
1362
"D-Bus signal"
1363
pass
1364
1365
@dbus.service.signal(_interface, signature="os")
1907
@dbus.service.signal(_interface, signature=u"o")
1908
def ClientAdded(self, objpath):
1909
"D-Bus signal"
1910
pass
1911
1912
@dbus.service.signal(_interface, signature=u"ss")
1913
def ClientNotFound(self, fingerprint, address):
1914
"D-Bus signal"
1915
pass
1916
1917
@dbus.service.signal(_interface, signature=u"os")
1366
1918
def ClientRemoved(self, objpath, name):
1367
1919
"D-Bus signal"
1368
1920
pass
1369
1921
1370
@dbus.service.method(_interface, out_signature="ao")
1922
@dbus.service.method(_interface, out_signature=u"ao")
1371
1923
def GetAllClients(self):
1372
1924
"D-Bus method"
1373
return dbus.Array(c.dbus_object_path for c in clients)
1925
return dbus.Array(c.dbus_object_path
1926
for c in tcp_server.clients)
1374
1927
1375
@dbus.service.method(_interface, out_signature="a{oa{sv}}")
1928
@dbus.service.method(_interface,
1929
out_signature=u"a{oa{sv}}")
1376
1930
def GetAllClientsWithProperties(self):
1377
1931
"D-Bus method"
1378
1932
return dbus.Dictionary(
1379
((c.dbus_object_path, c.GetAllProperties())
1380
for c in clients),
1381
signature="oa{sv}")
1933
((c.dbus_object_path, c.GetAll(u""))
1934
for c in tcp_server.clients),
1935
signature=u"oa{sv}")
1382
1936
1383
@dbus.service.method(_interface, in_signature="o")
1937
@dbus.service.method(_interface, in_signature=u"o")
1384
1938
def RemoveClient(self, object_path):
1385
1939
"D-Bus method"
1386
for c in clients:
1940
for c in tcp_server.clients:
1387
1941
if c.dbus_object_path == object_path:
1388
clients.remove(c)
1942
tcp_server.clients.remove(c)
1389
1943
c.remove_from_connection()
1390
1944
# Don't signal anything except ClientRemoved
1391
c.disable(signal=False)
1945
c.disable(quiet=True)
1392
1946
# Emit D-Bus signal
1393
1947
self.ClientRemoved(object_path, c.name)
1394
1948
return
1395
raise KeyError
1949
raise KeyError(object_path)
1396
1950
1397
1951
del _interface
1398
1952
1399
1953
mandos_dbus_service = MandosDBusService()
1400
1954
1401
for client in clients:
1955
def cleanup():
1956
"Cleanup function; run on exit"
1957
service.cleanup()
1958
1959
while tcp_server.clients:
1960
client = tcp_server.clients.pop()
1961
if use_dbus:
1962
client.remove_from_connection()
1963
client.disable_hook = None
1964
# Don't signal anything except ClientRemoved
1965
client.disable(quiet=True)
1966
if use_dbus:
1967
# Emit D-Bus signal
1968
mandos_dbus_service.ClientRemoved(client.dbus_object_path,
1969
client.name)
1970
1971
atexit.register(cleanup)
1972
1973
for client in tcp_server.clients:
1402
1974
if use_dbus:
1403
1975
# Emit D-Bus signal
1404
mandos_dbus_service.ClientAdded(client.dbus_object_path,
1405
client.GetAllProperties())
1976
mandos_dbus_service.ClientAdded(client.dbus_object_path)
1406
1977
client.enable()
1407
1978
1408
1979
tcp_server.enable()
1422
1993
1423
1994
try:
1424
1995
# From the Avahi example code
1425
server.connect_to_signal("StateChanged", server_state_changed)
1426
1996
try:
1427
server_state_changed(server.GetState())
1997
service.activate()
1428
1998
except dbus.exceptions.DBusException, error:
1429
1999
logger.critical(u"DBusException: %s", error)
2000
cleanup()
1430
2001
sys.exit(1)
1431
2002
# End of Avahi example code
1432
2003
1439
2010
main_loop.run()
1440
2011
except AvahiError, error:
1441
2012
logger.critical(u"AvahiError: %s", error)
2013
cleanup()
1442
2014
sys.exit(1)
1443
2015
except KeyboardInterrupt:
1444
2016
if debug:
1445
2017
print >> sys.stderr
1446
logger.debug("Server received KeyboardInterrupt")
1447
logger.debug("Server exiting")
2018
logger.debug(u"Server received KeyboardInterrupt")
2019
logger.debug(u"Server exiting")
2020
# Must run before the D-Bus bus name gets deregistered
2021
cleanup()
1448
2022
1449
2023
if __name__ == '__main__':
1450
2024
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0