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 101
- compare with another revision
- download diff
- download tarball
- view history from revision 101
- Committer: Teddy Hogeborn
- Date: 2008-08-24 23:18:18 UTC
- Revision ID: teddy@fukt.bsnet.se-20080824231818-4cgr5zekodg4s0dl
* initramfs-tools-hook: Added "--enable-dsa2" and "--trust-model
always" options to gpg.
always" options to gpg.
- files added:
- plugins.d/usplash
- files removed:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- files renamed:
- plugins.d/mandos-client.c => plugins.d/password-request.c
- plugins.d/mandos-client.xml => plugins.d/password-request.xml
- files modified:
- Makefile
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", "remove", "server_state_changed",
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
# "AvahiService" class, and some lines in "main".
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".
12
12
#
13
13
# Everything else is
14
# Copyright © 2008-2011 Teddy Hogeborn
15
# Copyright © 2008-2011 Björn Påhlsson
14
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
16
15
#
17
16
# This program is free software: you can redistribute it and/or modify
18
17
# it under the terms of the GNU General Public License as published by
25
24
# GNU General Public License for more details.
26
25
#
27
26
# 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/>.
30
#
31
# Contact the authors at <mandos@recompile.se>.
32
#
33
34
from __future__ import (division, absolute_import, print_function,
35
unicode_literals)
36
37
import SocketServer as socketserver
27
# along with this program. If not, see <http://www.gnu.org/licenses/>.
28
#
29
# Contact the authors at <mandos@fukt.bsnet.se>.
30
#
31
32
from __future__ import division
33
34
import SocketServer
38
35
import socket
39
import argparse
36
import select
37
from optparse import OptionParser
40
38
import datetime
41
39
import errno
42
40
import gnutls.crypto
45
43
import gnutls.library.functions
46
44
import gnutls.library.constants
47
45
import gnutls.library.types
48
import ConfigParser as configparser
46
import ConfigParser
49
47
import sys
50
48
import re
51
49
import os
52
50
import signal
51
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
import pwd
59
import contextlib
60
import struct
61
import fcntl
62
import functools
63
import cPickle as pickle
64
import multiprocessing
65
import types
66
import binascii
67
import tempfile
68
57
69
58
import dbus
70
import dbus.service
71
59
import gobject
72
60
import avahi
73
61
from dbus.mainloop.glib import DBusGMainLoop
74
62
import ctypes
75
import ctypes.util
76
import xml.dom.minidom
77
import inspect
78
import GnuPGInterface
79
80
try:
81
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
82
except AttributeError:
83
try:
84
from IN import SO_BINDTODEVICE
85
except ImportError:
86
SO_BINDTODEVICE = None
87
88
89
version = "1.4.1"
90
stored_state_file = "clients.pickle"
91
92
logger = logging.getLogger()
93
syslogger = (logging.handlers.SysLogHandler
94
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
95
address = str("/dev/log")))
96
97
try:
98
if_nametoindex = (ctypes.cdll.LoadLibrary
99
(ctypes.util.find_library("c"))
100
.if_nametoindex)
101
except (OSError, AttributeError):
102
def if_nametoindex(interface):
103
"Get an interface index the hard way, i.e. using fcntl()"
104
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
105
with contextlib.closing(socket.socket()) as s:
106
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
107
struct.pack(str("16s16x"),
108
interface))
109
interface_index = struct.unpack(str("I"),
110
ifreq[16:20])[0]
111
return interface_index
112
113
114
def initlogger(level=logging.WARNING):
115
"""init logger and add loglevel"""
116
117
syslogger.setFormatter(logging.Formatter
118
('Mandos [%(process)d]: %(levelname)s:'
119
' %(message)s'))
120
logger.addHandler(syslogger)
121
122
console = logging.StreamHandler()
123
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
124
' [%(process)d]:'
125
' %(levelname)s:'
126
' %(message)s'))
127
logger.addHandler(console)
128
logger.setLevel(level)
129
130
131
class PGPError(Exception):
132
"""Exception if encryption/decryption fails"""
133
pass
134
135
136
class PGPEngine(object):
137
"""A simple class for OpenPGP symmetric encryption & decryption"""
138
def __init__(self):
139
self.gnupg = GnuPGInterface.GnuPG()
140
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
141
self.gnupg = GnuPGInterface.GnuPG()
142
self.gnupg.options.meta_interactive = False
143
self.gnupg.options.homedir = self.tempdir
144
self.gnupg.options.extra_args.extend(['--force-mdc',
145
'--quiet'])
146
147
def __enter__(self):
148
return self
149
150
def __exit__ (self, exc_type, exc_value, traceback):
151
self._cleanup()
152
return False
153
154
def __del__(self):
155
self._cleanup()
156
157
def _cleanup(self):
158
if self.tempdir is not None:
159
# Delete contents of tempdir
160
for root, dirs, files in os.walk(self.tempdir,
161
topdown = False):
162
for filename in files:
163
os.remove(os.path.join(root, filename))
164
for dirname in dirs:
165
os.rmdir(os.path.join(root, dirname))
166
# Remove tempdir
167
os.rmdir(self.tempdir)
168
self.tempdir = None
169
170
def password_encode(self, password):
171
# Passphrase can not be empty and can not contain newlines or
172
# NUL bytes. So we prefix it and hex encode it.
173
return b"mandos" + binascii.hexlify(password)
174
175
def encrypt(self, data, password):
176
self.gnupg.passphrase = self.password_encode(password)
177
with open(os.devnull) as devnull:
178
try:
179
proc = self.gnupg.run(['--symmetric'],
180
create_fhs=['stdin', 'stdout'],
181
attach_fhs={'stderr': devnull})
182
with contextlib.closing(proc.handles['stdin']) as f:
183
f.write(data)
184
with contextlib.closing(proc.handles['stdout']) as f:
185
ciphertext = f.read()
186
proc.wait()
187
except IOError as e:
188
raise PGPError(e)
189
self.gnupg.passphrase = None
190
return ciphertext
191
192
def decrypt(self, data, password):
193
self.gnupg.passphrase = self.password_encode(password)
194
with open(os.devnull) as devnull:
195
try:
196
proc = self.gnupg.run(['--decrypt'],
197
create_fhs=['stdin', 'stdout'],
198
attach_fhs={'stderr': devnull})
199
with contextlib.closing(proc.handles['stdin'] ) as f:
200
f.write(data)
201
with contextlib.closing(proc.handles['stdout']) as f:
202
decrypted_plaintext = f.read()
203
proc.wait()
204
except IOError as e:
205
raise PGPError(e)
206
self.gnupg.passphrase = None
207
return decrypted_plaintext
208
209
63
64
version = "1.0"
65
66
logger = logging.Logger('mandos')
67
syslogger = logging.handlers.SysLogHandler\
68
(facility = logging.handlers.SysLogHandler.LOG_DAEMON,
69
address = "/dev/log")
70
syslogger.setFormatter(logging.Formatter\
71
('Mandos: %(levelname)s: %(message)s'))
72
logger.addHandler(syslogger)
73
74
console = logging.StreamHandler()
75
console.setFormatter(logging.Formatter('%(name)s: %(levelname)s:'
76
' %(message)s'))
77
logger.addHandler(console)
210
78
211
79
class AvahiError(Exception):
212
def __init__(self, value, *args, **kwargs):
80
def __init__(self, value):
213
81
self.value = value
214
super(AvahiError, self).__init__(value, *args, **kwargs)
215
def __unicode__(self):
216
return unicode(repr(self.value))
82
def __str__(self):
83
return repr(self.value)
217
84
218
85
class AvahiServiceError(AvahiError):
219
86
pass
224
91
225
92
class AvahiService(object):
226
93
"""An Avahi (Zeroconf) service.
227
228
94
Attributes:
229
95
interface: integer; avahi.IF_UNSPEC or an interface index.
230
96
Used to optionally bind to the specified interface.
238
104
max_renames: integer; maximum number of renames
239
105
rename_count: integer; counter so we only rename after collisions
240
106
a sensible number of times
241
group: D-Bus Entry Group
242
server: D-Bus Server
243
bus: dbus.SystemBus()
244
107
"""
245
108
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
246
servicetype = None, port = None, TXT = None,
247
domain = "", host = "", max_renames = 32768,
248
protocol = avahi.PROTO_UNSPEC, bus = None):
109
type = None, port = None, TXT = None, domain = "",
110
host = "", max_renames = 32768):
249
111
self.interface = interface
250
112
self.name = name
251
self.type = servicetype
113
self.type = type
252
114
self.port = port
253
self.TXT = TXT if TXT is not None else []
115
if TXT is None:
116
self.TXT = []
117
else:
118
self.TXT = TXT
254
119
self.domain = domain
255
120
self.host = host
256
121
self.rename_count = 0
257
122
self.max_renames = max_renames
258
self.protocol = protocol
259
self.group = None # our entry group
260
self.server = None
261
self.bus = bus
262
self.entry_group_state_changed_match = None
263
123
def rename(self):
264
124
"""Derived from the Avahi example code"""
265
125
if self.rename_count >= self.max_renames:
266
logger.critical("No suitable Zeroconf service name found"
267
" after %i retries, exiting.",
268
self.rename_count)
126
logger.critical(u"No suitable service name found after %i"
127
u" retries, exiting.", rename_count)
269
128
raise AvahiServiceError("Too many renames")
270
self.name = unicode(self.server
271
.GetAlternativeServiceName(self.name))
272
logger.info("Changing Zeroconf service name to %r ...",
273
self.name)
129
self.name = server.GetAlternativeServiceName(self.name)
130
logger.info(u"Changing name to %r ...", str(self.name))
131
syslogger.setFormatter(logging.Formatter\
132
('Mandos (%s): %%(levelname)s:'
133
' %%(message)s' % self.name))
274
134
self.remove()
275
try:
276
self.add()
277
except dbus.exceptions.DBusException as error:
278
logger.critical("DBusException: %s", error)
279
self.cleanup()
280
os._exit(1)
135
self.add()
281
136
self.rename_count += 1
282
137
def remove(self):
283
138
"""Derived from the Avahi example code"""
284
if self.entry_group_state_changed_match is not None:
285
self.entry_group_state_changed_match.remove()
286
self.entry_group_state_changed_match = None
287
if self.group is not None:
288
self.group.Reset()
139
if group is not None:
140
group.Reset()
289
141
def add(self):
290
142
"""Derived from the Avahi example code"""
291
self.remove()
292
if self.group is None:
293
self.group = dbus.Interface(
294
self.bus.get_object(avahi.DBUS_NAME,
295
self.server.EntryGroupNew()),
296
avahi.DBUS_INTERFACE_ENTRY_GROUP)
297
self.entry_group_state_changed_match = (
298
self.group.connect_to_signal(
299
'StateChanged', self.entry_group_state_changed))
300
logger.debug("Adding Zeroconf service '%s' of type '%s' ...",
301
self.name, self.type)
302
self.group.AddService(
303
self.interface,
304
self.protocol,
305
dbus.UInt32(0), # flags
306
self.name, self.type,
307
self.domain, self.host,
308
dbus.UInt16(self.port),
309
avahi.string_array_to_txt_array(self.TXT))
310
self.group.Commit()
311
def entry_group_state_changed(self, state, error):
312
"""Derived from the Avahi example code"""
313
logger.debug("Avahi entry group state change: %i", state)
314
315
if state == avahi.ENTRY_GROUP_ESTABLISHED:
316
logger.debug("Zeroconf service established.")
317
elif state == avahi.ENTRY_GROUP_COLLISION:
318
logger.info("Zeroconf service name collision.")
319
self.rename()
320
elif state == avahi.ENTRY_GROUP_FAILURE:
321
logger.critical("Avahi: Error in group state changed %s",
322
unicode(error))
323
raise AvahiGroupError("State changed: %s"
324
% unicode(error))
325
def cleanup(self):
326
"""Derived from the Avahi example code"""
327
if self.group is not None:
328
try:
329
self.group.Free()
330
except (dbus.exceptions.UnknownMethodException,
331
dbus.exceptions.DBusException):
332
pass
333
self.group = None
334
self.remove()
335
def server_state_changed(self, state, error=None):
336
"""Derived from the Avahi example code"""
337
logger.debug("Avahi server state change: %i", state)
338
bad_states = { avahi.SERVER_INVALID:
339
"Zeroconf server invalid",
340
avahi.SERVER_REGISTERING: None,
341
avahi.SERVER_COLLISION:
342
"Zeroconf server name collision",
343
avahi.SERVER_FAILURE:
344
"Zeroconf server failure" }
345
if state in bad_states:
346
if bad_states[state] is not None:
347
if error is None:
348
logger.error(bad_states[state])
349
else:
350
logger.error(bad_states[state] + ": %r", error)
351
self.cleanup()
352
elif state == avahi.SERVER_RUNNING:
353
self.add()
354
else:
355
if error is None:
356
logger.debug("Unknown state: %r", state)
357
else:
358
logger.debug("Unknown state: %r: %r", state, error)
359
def activate(self):
360
"""Derived from the Avahi example code"""
361
if self.server is None:
362
self.server = dbus.Interface(
363
self.bus.get_object(avahi.DBUS_NAME,
364
avahi.DBUS_PATH_SERVER,
365
follow_name_owner_changes=True),
366
avahi.DBUS_INTERFACE_SERVER)
367
self.server.connect_to_signal("StateChanged",
368
self.server_state_changed)
369
self.server_state_changed(self.server.GetState())
370
371
class AvahiServiceToSyslog(AvahiService):
372
def rename(self):
373
"""Add the new name to the syslog messages"""
374
ret = AvahiService.rename(self)
375
syslogger.setFormatter(logging.Formatter
376
('Mandos (%s) [%%(process)d]:'
377
' %%(levelname)s: %%(message)s'
378
% self.name))
379
return ret
380
381
def _timedelta_to_milliseconds(td):
382
"Convert a datetime.timedelta() to milliseconds"
383
return ((td.days * 24 * 60 * 60 * 1000)
384
+ (td.seconds * 1000)
385
+ (td.microseconds // 1000))
386
143
global group
144
if group is None:
145
group = dbus.Interface\
146
(bus.get_object(avahi.DBUS_NAME,
147
server.EntryGroupNew()),
148
avahi.DBUS_INTERFACE_ENTRY_GROUP)
149
group.connect_to_signal('StateChanged',
150
entry_group_state_changed)
151
logger.debug(u"Adding service '%s' of type '%s' ...",
152
service.name, service.type)
153
group.AddService(
154
self.interface, # interface
155
avahi.PROTO_INET6, # protocol
156
dbus.UInt32(0), # flags
157
self.name, self.type,
158
self.domain, self.host,
159
dbus.UInt16(self.port),
160
avahi.string_array_to_txt_array(self.TXT))
161
group.Commit()
162
163
# From the Avahi example code:
164
group = None # our entry group
165
# End of Avahi example code
166
167
387
168
class Client(object):
388
169
"""A representation of a client host served by this server.
389
390
170
Attributes:
391
_approved: bool(); 'None' if not yet approved/disapproved
392
approval_delay: datetime.timedelta(); Time to wait for approval
393
approval_duration: datetime.timedelta(); Duration of one approval
394
checker: subprocess.Popen(); a running checker process used
395
to see if the client lives.
396
'None' if no process is running.
397
checker_callback_tag: a gobject event source tag, or None
398
checker_command: string; External command which is run to check
399
if client lives. %() expansions are done at
171
name: string; from the config file, used in log messages
172
fingerprint: string (40 or 32 hexadecimal digits); used to
173
uniquely identify the client
174
secret: bytestring; sent verbatim (over TLS) to client
175
host: string; available for use by the checker command
176
created: datetime.datetime(); object creation, not client host
177
last_checked_ok: datetime.datetime() or None if not yet checked OK
178
timeout: datetime.timedelta(); How long from last_checked_ok
179
until this client is invalid
180
interval: datetime.timedelta(); How often to start a new checker
181
stop_hook: If set, called by stop() as stop_hook(self)
182
checker: subprocess.Popen(); a running checker process used
183
to see if the client lives.
184
'None' if no process is running.
185
checker_initiator_tag: a gobject event source tag, or None
186
stop_initiator_tag: - '' -
187
checker_callback_tag: - '' -
188
checker_command: string; External command which is run to check if
189
client lives. %() expansions are done at
400
190
runtime with vars(self) as dict, so that for
401
191
instance %(name)s can be used in the command.
402
checker_initiator_tag: a gobject event source tag, or None
403
created: datetime.datetime(); (UTC) object creation
404
client_structure: Object describing what attributes a client has
405
and is used for storing the client at exit
406
current_checker_command: string; current running checker_command
407
disable_initiator_tag: a gobject event source tag, or None
408
enabled: bool()
409
fingerprint: string (40 or 32 hexadecimal digits); used to
410
uniquely identify the client
411
host: string; available for use by the checker command
412
interval: datetime.timedelta(); How often to start a new checker
413
last_approval_request: datetime.datetime(); (UTC) or None
414
last_checked_ok: datetime.datetime(); (UTC) or None
415
416
last_checker_status: integer between 0 and 255 reflecting exit
417
status of last checker. -1 reflects crashed
418
checker, or None.
419
last_enabled: datetime.datetime(); (UTC) or None
420
name: string; from the config file, used in log messages and
421
D-Bus identifiers
422
secret: bytestring; sent verbatim (over TLS) to client
423
timeout: datetime.timedelta(); How long from last_checked_ok
424
until this client is disabled
425
extended_timeout: extra long timeout when password has been sent
426
runtime_expansions: Allowed attributes for runtime expansion.
427
expires: datetime.datetime(); time (UTC) when a client will be
428
disabled, or None
192
Private attibutes:
193
_timeout: Real variable for 'timeout'
194
_interval: Real variable for 'interval'
195
_timeout_milliseconds: Used when calling gobject.timeout_add()
196
_interval_milliseconds: - '' -
429
197
"""
430
431
runtime_expansions = ("approval_delay", "approval_duration",
432
"created", "enabled", "fingerprint",
433
"host", "interval", "last_checked_ok",
434
"last_enabled", "name", "timeout")
435
436
def timeout_milliseconds(self):
437
"Return the 'timeout' attribute in milliseconds"
438
return _timedelta_to_milliseconds(self.timeout)
439
440
def extended_timeout_milliseconds(self):
441
"Return the 'extended_timeout' attribute in milliseconds"
442
return _timedelta_to_milliseconds(self.extended_timeout)
443
444
def interval_milliseconds(self):
445
"Return the 'interval' attribute in milliseconds"
446
return _timedelta_to_milliseconds(self.interval)
447
448
def approval_delay_milliseconds(self):
449
return _timedelta_to_milliseconds(self.approval_delay)
450
451
def __init__(self, name = None, config=None):
198
def _set_timeout(self, timeout):
199
"Setter function for 'timeout' attribute"
200
self._timeout = timeout
201
self._timeout_milliseconds = ((self.timeout.days
202
* 24 * 60 * 60 * 1000)
203
+ (self.timeout.seconds * 1000)
204
+ (self.timeout.microseconds
205
// 1000))
206
timeout = property(lambda self: self._timeout,
207
_set_timeout)
208
del _set_timeout
209
def _set_interval(self, interval):
210
"Setter function for 'interval' attribute"
211
self._interval = interval
212
self._interval_milliseconds = ((self.interval.days
213
* 24 * 60 * 60 * 1000)
214
+ (self.interval.seconds
215
* 1000)
216
+ (self.interval.microseconds
217
// 1000))
218
interval = property(lambda self: self._interval,
219
_set_interval)
220
del _set_interval
221
def __init__(self, name = None, stop_hook=None, config={}):
452
222
"""Note: the 'checker' key in 'config' sets the
453
223
'checker_command' attribute and *not* the 'checker'
454
224
attribute."""
455
225
self.name = name
456
if config is None:
457
config = {}
458
logger.debug("Creating client %r", self.name)
226
logger.debug(u"Creating client %r", self.name)
459
227
# Uppercase and remove spaces from fingerprint for later
460
228
# comparison purposes with return value from the fingerprint()
461
229
# function
462
self.fingerprint = (config["fingerprint"].upper()
463
.replace(" ", ""))
464
logger.debug(" Fingerprint: %s", self.fingerprint)
230
self.fingerprint = config["fingerprint"].upper()\
231
.replace(u" ", u"")
232
logger.debug(u" Fingerprint: %s", self.fingerprint)
465
233
if "secret" in config:
466
self.secret = config["secret"].decode("base64")
234
self.secret = config["secret"].decode(u"base64")
467
235
elif "secfile" in config:
468
with open(os.path.expanduser(os.path.expandvars
469
(config["secfile"])),
470
"rb") as secfile:
471
self.secret = secfile.read()
236
sf = open(config["secfile"])
237
self.secret = sf.read()
238
sf.close()
472
239
else:
473
raise TypeError("No secret or secfile for client %s"
240
raise TypeError(u"No secret or secfile for client %s"
474
241
% self.name)
475
242
self.host = config.get("host", "")
476
self.created = datetime.datetime.utcnow()
477
self.enabled = config.get("enabled", True)
478
self.last_approval_request = None
479
if self.enabled:
480
self.last_enabled = datetime.datetime.utcnow()
481
else:
482
self.last_enabled = None
243
self.created = datetime.datetime.now()
483
244
self.last_checked_ok = None
484
self.last_checker_status = None
485
245
self.timeout = string_to_delta(config["timeout"])
486
self.extended_timeout = string_to_delta(config
487
["extended_timeout"])
488
246
self.interval = string_to_delta(config["interval"])
247
self.stop_hook = stop_hook
489
248
self.checker = None
490
249
self.checker_initiator_tag = None
491
self.disable_initiator_tag = None
492
if self.enabled:
493
self.expires = datetime.datetime.utcnow() + self.timeout
494
else:
495
self.expires = None
250
self.stop_initiator_tag = None
496
251
self.checker_callback_tag = None
497
self.checker_command = config["checker"]
498
self.current_checker_command = None
499
self._approved = None
500
self.approved_by_default = config.get("approved_by_default",
501
True)
502
self.approvals_pending = 0
503
self.approval_delay = string_to_delta(
504
config["approval_delay"])
505
self.approval_duration = string_to_delta(
506
config["approval_duration"])
507
self.changedstate = (multiprocessing_manager
508
.Condition(multiprocessing_manager
509
.Lock()))
510
self.client_structure = [attr for attr in
511
self.__dict__.iterkeys()
512
if not attr.startswith("_")]
513
self.client_structure.append("client_structure")
514
515
for name, t in inspect.getmembers(type(self),
516
lambda obj:
517
isinstance(obj,
518
property)):
519
if not name.startswith("_"):
520
self.client_structure.append(name)
521
522
# Send notice to process children that client state has changed
523
def send_changedstate(self):
524
with self.changedstate:
525
self.changedstate.notify_all()
526
527
def enable(self):
252
self.check_command = config["checker"]
253
def start(self):
528
254
"""Start this client's checker and timeout hooks"""
529
if getattr(self, "enabled", False):
530
# Already enabled
531
return
532
self.send_changedstate()
533
self.expires = datetime.datetime.utcnow() + self.timeout
534
self.enabled = True
535
self.last_enabled = datetime.datetime.utcnow()
536
self.init_checker()
537
538
def disable(self, quiet=True):
539
"""Disable this client."""
540
if not getattr(self, "enabled", False):
255
# Schedule a new checker to be started an 'interval' from now,
256
# and every interval from then on.
257
self.checker_initiator_tag = gobject.timeout_add\
258
(self._interval_milliseconds,
259
self.start_checker)
260
# Also start a new checker *right now*.
261
self.start_checker()
262
# Schedule a stop() when 'timeout' has passed
263
self.stop_initiator_tag = gobject.timeout_add\
264
(self._timeout_milliseconds,
265
self.stop)
266
def stop(self):
267
"""Stop this client.
268
The possibility that a client might be restarted is left open,
269
but not currently used."""
270
# If this client doesn't have a secret, it is already stopped.
271
if hasattr(self, "secret") and self.secret:
272
logger.info(u"Stopping client %s", self.name)
273
self.secret = None
274
else:
541
275
return False
542
if not quiet:
543
self.send_changedstate()
544
if not quiet:
545
logger.info("Disabling client %s", self.name)
546
if getattr(self, "disable_initiator_tag", False):
547
gobject.source_remove(self.disable_initiator_tag)
548
self.disable_initiator_tag = None
549
self.expires = None
276
if getattr(self, "stop_initiator_tag", False):
277
gobject.source_remove(self.stop_initiator_tag)
278
self.stop_initiator_tag = None
550
279
if getattr(self, "checker_initiator_tag", False):
551
280
gobject.source_remove(self.checker_initiator_tag)
552
281
self.checker_initiator_tag = None
553
282
self.stop_checker()
554
self.enabled = False
283
if self.stop_hook:
284
self.stop_hook(self)
555
285
# Do not run this again if called by a gobject.timeout_add
556
286
return False
557
558
287
def __del__(self):
559
self.disable()
560
561
def init_checker(self):
562
# Schedule a new checker to be started an 'interval' from now,
563
# and every interval from then on.
564
self.checker_initiator_tag = (gobject.timeout_add
565
(self.interval_milliseconds(),
566
self.start_checker))
567
# Schedule a disable() when 'timeout' has passed
568
self.disable_initiator_tag = (gobject.timeout_add
569
(self.timeout_milliseconds(),
570
self.disable))
571
# Also start a new checker *right now*.
572
self.start_checker()
573
574
def checker_callback(self, pid, condition, command):
288
self.stop_hook = None
289
self.stop()
290
def checker_callback(self, pid, condition):
575
291
"""The checker has completed, so take appropriate actions."""
292
now = datetime.datetime.now()
576
293
self.checker_callback_tag = None
577
294
self.checker = None
578
if os.WIFEXITED(condition):
579
self.last_checker_status = os.WEXITSTATUS(condition)
580
if self.last_checker_status == 0:
581
logger.info("Checker for %(name)s succeeded",
582
vars(self))
583
self.checked_ok()
584
else:
585
logger.info("Checker for %(name)s failed",
586
vars(self))
587
else:
588
self.last_checker_status = -1
589
logger.warning("Checker for %(name)s crashed?",
295
if os.WIFEXITED(condition) \
296
and (os.WEXITSTATUS(condition) == 0):
297
logger.info(u"Checker for %(name)s succeeded",
298
vars(self))
299
self.last_checked_ok = now
300
gobject.source_remove(self.stop_initiator_tag)
301
self.stop_initiator_tag = gobject.timeout_add\
302
(self._timeout_milliseconds,
303
self.stop)
304
elif not os.WIFEXITED(condition):
305
logger.warning(u"Checker for %(name)s crashed?",
590
306
vars(self))
591
592
def checked_ok(self, timeout=None):
593
"""Bump up the timeout for this client.
594
595
This should only be called when the client has been seen,
596
alive and well.
597
"""
598
if timeout is None:
599
timeout = self.timeout
600
self.last_checked_ok = datetime.datetime.utcnow()
601
if self.disable_initiator_tag is not None:
602
gobject.source_remove(self.disable_initiator_tag)
603
if getattr(self, "enabled", False):
604
self.disable_initiator_tag = (gobject.timeout_add
605
(_timedelta_to_milliseconds
606
(timeout), self.disable))
607
self.expires = datetime.datetime.utcnow() + timeout
608
609
def need_approval(self):
610
self.last_approval_request = datetime.datetime.utcnow()
611
307
else:
308
logger.info(u"Checker for %(name)s failed",
309
vars(self))
612
310
def start_checker(self):
613
311
"""Start a new checker subprocess if one is not running.
614
615
312
If a checker already exists, leave it running and do
616
313
nothing."""
617
314
# The reason for not killing a running checker is that if we
620
317
# client would inevitably timeout, since no checker would get
621
318
# a chance to run to completion. If we instead leave running
622
319
# checkers alone, the checker would have to take more time
623
# than 'timeout' for the client to be disabled, which is as it
624
# should be.
625
626
# If a checker exists, make sure it is not a zombie
627
try:
628
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
629
except (AttributeError, OSError) as error:
630
if (isinstance(error, OSError)
631
and error.errno != errno.ECHILD):
632
raise error
633
else:
634
if pid:
635
logger.warning("Checker was a zombie")
636
gobject.source_remove(self.checker_callback_tag)
637
self.checker_callback(pid, status,
638
self.current_checker_command)
639
# Start a new checker if needed
320
# than 'timeout' for the client to be declared invalid, which
321
# is as it should be.
640
322
if self.checker is None:
641
323
try:
642
# In case checker_command has exactly one % operator
643
command = self.checker_command % self.host
324
# In case check_command has exactly one % operator
325
command = self.check_command % self.host
644
326
except TypeError:
645
327
# Escape attributes for the shell
646
escaped_attrs = dict(
647
(attr,
648
re.escape(unicode(str(getattr(self, attr, "")),
649
errors=
650
'replace')))
651
for attr in
652
self.runtime_expansions)
653
328
escaped_attrs = dict((key, re.escape(str(val)))
329
for key, val in
330
vars(self).iteritems())
654
331
try:
655
command = self.checker_command % escaped_attrs
656
except TypeError as error:
657
logger.error('Could not format string "%s":'
658
' %s', self.checker_command, error)
332
command = self.check_command % escaped_attrs
333
except TypeError, error:
334
logger.error(u'Could not format string "%s":'
335
u' %s', self.check_command, error)
659
336
return True # Try again later
660
self.current_checker_command = command
661
337
try:
662
logger.info("Starting checker %r for %s",
338
logger.info(u"Starting checker %r for %s",
663
339
command, self.name)
664
340
# We don't need to redirect stdout and stderr, since
665
341
# in normal mode, that is already done by daemon(),
668
344
self.checker = subprocess.Popen(command,
669
345
close_fds=True,
670
346
shell=True, cwd="/")
671
self.checker_callback_tag = (gobject.child_watch_add
672
(self.checker.pid,
673
self.checker_callback,
674
data=command))
675
# The checker may have completed before the gobject
676
# watch was added. Check for this.
677
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
678
if pid:
679
gobject.source_remove(self.checker_callback_tag)
680
self.checker_callback(pid, status, command)
681
except OSError as error:
682
logger.error("Failed to start subprocess: %s",
347
self.checker_callback_tag = gobject.child_watch_add\
348
(self.checker.pid,
349
self.checker_callback)
350
except OSError, error:
351
logger.error(u"Failed to start subprocess: %s",
683
352
error)
684
353
# Re-run this periodically if run by gobject.timeout_add
685
354
return True
686
687
355
def stop_checker(self):
688
356
"""Force the checker process, if any, to stop."""
689
357
if self.checker_callback_tag:
691
359
self.checker_callback_tag = None
692
360
if getattr(self, "checker", None) is None:
693
361
return
694
logger.debug("Stopping checker for %(name)s", vars(self))
362
logger.debug(u"Stopping checker for %(name)s", vars(self))
695
363
try:
696
364
os.kill(self.checker.pid, signal.SIGTERM)
697
#time.sleep(0.5)
365
#os.sleep(0.5)
698
366
#if self.checker.poll() is None:
699
367
# os.kill(self.checker.pid, signal.SIGKILL)
700
except OSError as error:
368
except OSError, error:
701
369
if error.errno != errno.ESRCH: # No such process
702
370
raise
703
371
self.checker = None
704
705
706
def dbus_service_property(dbus_interface, signature="v",
707
access="readwrite", byte_arrays=False):
708
"""Decorators for marking methods of a DBusObjectWithProperties to
709
become properties on the D-Bus.
710
711
The decorated method will be called with no arguments by "Get"
712
and with one argument by "Set".
713
714
The parameters, where they are supported, are the same as
715
dbus.service.method, except there is only "signature", since the
716
type from Get() and the type sent to Set() is the same.
717
"""
718
# Encoding deeply encoded byte arrays is not supported yet by the
719
# "Set" method, so we fail early here:
720
if byte_arrays and signature != "ay":
721
raise ValueError("Byte arrays not supported for non-'ay'"
722
" signature %r" % signature)
723
def decorator(func):
724
func._dbus_is_property = True
725
func._dbus_interface = dbus_interface
726
func._dbus_signature = signature
727
func._dbus_access = access
728
func._dbus_name = func.__name__
729
if func._dbus_name.endswith("_dbus_property"):
730
func._dbus_name = func._dbus_name[:-14]
731
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
732
return func
733
return decorator
734
735
736
class DBusPropertyException(dbus.exceptions.DBusException):
737
"""A base class for D-Bus property-related exceptions
738
"""
739
def __unicode__(self):
740
return unicode(str(self))
741
742
743
class DBusPropertyAccessException(DBusPropertyException):
744
"""A property's access permissions disallows an operation.
745
"""
746
pass
747
748
749
class DBusPropertyNotFound(DBusPropertyException):
750
"""An attempt was made to access a non-existing property.
751
"""
752
pass
753
754
755
class DBusObjectWithProperties(dbus.service.Object):
756
"""A D-Bus object with properties.
757
758
Classes inheriting from this can use the dbus_service_property
759
decorator to expose methods as D-Bus properties. It exposes the
760
standard Get(), Set(), and GetAll() methods on the D-Bus.
761
"""
762
763
@staticmethod
764
def _is_dbus_property(obj):
765
return getattr(obj, "_dbus_is_property", False)
766
767
def _get_all_dbus_properties(self):
768
"""Returns a generator of (name, attribute) pairs
769
"""
770
return ((prop.__get__(self)._dbus_name, prop.__get__(self))
771
for cls in self.__class__.__mro__
772
for name, prop in
773
inspect.getmembers(cls, self._is_dbus_property))
774
775
def _get_dbus_property(self, interface_name, property_name):
776
"""Returns a bound method if one exists which is a D-Bus
777
property with the specified name and interface.
778
"""
779
for cls in self.__class__.__mro__:
780
for name, value in (inspect.getmembers
781
(cls, self._is_dbus_property)):
782
if (value._dbus_name == property_name
783
and value._dbus_interface == interface_name):
784
return value.__get__(self)
785
786
# No such property
787
raise DBusPropertyNotFound(self.dbus_object_path + ":"
788
+ interface_name + "."
789
+ property_name)
790
791
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",
792
out_signature="v")
793
def Get(self, interface_name, property_name):
794
"""Standard D-Bus property Get() method, see D-Bus standard.
795
"""
796
prop = self._get_dbus_property(interface_name, property_name)
797
if prop._dbus_access == "write":
798
raise DBusPropertyAccessException(property_name)
799
value = prop()
800
if not hasattr(value, "variant_level"):
801
return value
802
return type(value)(value, variant_level=value.variant_level+1)
803
804
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
805
def Set(self, interface_name, property_name, value):
806
"""Standard D-Bus property Set() method, see D-Bus standard.
807
"""
808
prop = self._get_dbus_property(interface_name, property_name)
809
if prop._dbus_access == "read":
810
raise DBusPropertyAccessException(property_name)
811
if prop._dbus_get_args_options["byte_arrays"]:
812
# The byte_arrays option is not supported yet on
813
# signatures other than "ay".
814
if prop._dbus_signature != "ay":
815
raise ValueError
816
value = dbus.ByteArray(''.join(unichr(byte)
817
for byte in value))
818
prop(value)
819
820
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",
821
out_signature="a{sv}")
822
def GetAll(self, interface_name):
823
"""Standard D-Bus property GetAll() method, see D-Bus
824
standard.
825
826
Note: Will not include properties with access="write".
827
"""
828
properties = {}
829
for name, prop in self._get_all_dbus_properties():
830
if (interface_name
831
and interface_name != prop._dbus_interface):
832
# Interface non-empty but did not match
833
continue
834
# Ignore write-only properties
835
if prop._dbus_access == "write":
836
continue
837
value = prop()
838
if not hasattr(value, "variant_level"):
839
properties[name] = value
840
continue
841
properties[name] = type(value)(value, variant_level=
842
value.variant_level+1)
843
return dbus.Dictionary(properties, signature="sv")
844
845
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
846
out_signature="s",
847
path_keyword='object_path',
848
connection_keyword='connection')
849
def Introspect(self, object_path, connection):
850
"""Standard D-Bus method, overloaded to insert property tags.
851
"""
852
xmlstring = dbus.service.Object.Introspect(self, object_path,
853
connection)
854
try:
855
document = xml.dom.minidom.parseString(xmlstring)
856
def make_tag(document, name, prop):
857
e = document.createElement("property")
858
e.setAttribute("name", name)
859
e.setAttribute("type", prop._dbus_signature)
860
e.setAttribute("access", prop._dbus_access)
861
return e
862
for if_tag in document.getElementsByTagName("interface"):
863
for tag in (make_tag(document, name, prop)
864
for name, prop
865
in self._get_all_dbus_properties()
866
if prop._dbus_interface
867
== if_tag.getAttribute("name")):
868
if_tag.appendChild(tag)
869
# Add the names to the return values for the
870
# "org.freedesktop.DBus.Properties" methods
871
if (if_tag.getAttribute("name")
872
== "org.freedesktop.DBus.Properties"):
873
for cn in if_tag.getElementsByTagName("method"):
874
if cn.getAttribute("name") == "Get":
875
for arg in cn.getElementsByTagName("arg"):
876
if (arg.getAttribute("direction")
877
== "out"):
878
arg.setAttribute("name", "value")
879
elif cn.getAttribute("name") == "GetAll":
880
for arg in cn.getElementsByTagName("arg"):
881
if (arg.getAttribute("direction")
882
== "out"):
883
arg.setAttribute("name", "props")
884
xmlstring = document.toxml("utf-8")
885
document.unlink()
886
except (AttributeError, xml.dom.DOMException,
887
xml.parsers.expat.ExpatError) as error:
888
logger.error("Failed to override Introspection method",
889
error)
890
return xmlstring
891
892
893
def datetime_to_dbus (dt, variant_level=0):
894
"""Convert a UTC datetime.datetime() to a D-Bus type."""
895
if dt is None:
896
return dbus.String("", variant_level = variant_level)
897
return dbus.String(dt.isoformat(),
898
variant_level=variant_level)
899
900
901
class AlternateDBusNamesMetaclass(DBusObjectWithProperties
902
.__metaclass__):
903
"""Applied to an empty subclass of a D-Bus object, this metaclass
904
will add additional D-Bus attributes matching a certain pattern.
905
"""
906
def __new__(mcs, name, bases, attr):
907
# Go through all the base classes which could have D-Bus
908
# methods, signals, or properties in them
909
for base in (b for b in bases
910
if issubclass(b, dbus.service.Object)):
911
# Go though all attributes of the base class
912
for attrname, attribute in inspect.getmembers(base):
913
# Ignore non-D-Bus attributes, and D-Bus attributes
914
# with the wrong interface name
915
if (not hasattr(attribute, "_dbus_interface")
916
or not attribute._dbus_interface
917
.startswith("se.recompile.Mandos")):
918
continue
919
# Create an alternate D-Bus interface name based on
920
# the current name
921
alt_interface = (attribute._dbus_interface
922
.replace("se.recompile.Mandos",
923
"se.bsnet.fukt.Mandos"))
924
# Is this a D-Bus signal?
925
if getattr(attribute, "_dbus_is_signal", False):
926
# Extract the original non-method function by
927
# black magic
928
nonmethod_func = (dict(
929
zip(attribute.func_code.co_freevars,
930
attribute.__closure__))["func"]
931
.cell_contents)
932
# Create a new, but exactly alike, function
933
# object, and decorate it to be a new D-Bus signal
934
# with the alternate D-Bus interface name
935
new_function = (dbus.service.signal
936
(alt_interface,
937
attribute._dbus_signature)
938
(types.FunctionType(
939
nonmethod_func.func_code,
940
nonmethod_func.func_globals,
941
nonmethod_func.func_name,
942
nonmethod_func.func_defaults,
943
nonmethod_func.func_closure)))
944
# Define a creator of a function to call both the
945
# old and new functions, so both the old and new
946
# signals gets sent when the function is called
947
def fixscope(func1, func2):
948
"""This function is a scope container to pass
949
func1 and func2 to the "call_both" function
950
outside of its arguments"""
951
def call_both(*args, **kwargs):
952
"""This function will emit two D-Bus
953
signals by calling func1 and func2"""
954
func1(*args, **kwargs)
955
func2(*args, **kwargs)
956
return call_both
957
# Create the "call_both" function and add it to
958
# the class
959
attr[attrname] = fixscope(attribute,
960
new_function)
961
# Is this a D-Bus method?
962
elif getattr(attribute, "_dbus_is_method", False):
963
# Create a new, but exactly alike, function
964
# object. Decorate it to be a new D-Bus method
965
# with the alternate D-Bus interface name. Add it
966
# to the class.
967
attr[attrname] = (dbus.service.method
968
(alt_interface,
969
attribute._dbus_in_signature,
970
attribute._dbus_out_signature)
971
(types.FunctionType
972
(attribute.func_code,
973
attribute.func_globals,
974
attribute.func_name,
975
attribute.func_defaults,
976
attribute.func_closure)))
977
# Is this a D-Bus property?
978
elif getattr(attribute, "_dbus_is_property", False):
979
# Create a new, but exactly alike, function
980
# object, and decorate it to be a new D-Bus
981
# property with the alternate D-Bus interface
982
# name. Add it to the class.
983
attr[attrname] = (dbus_service_property
984
(alt_interface,
985
attribute._dbus_signature,
986
attribute._dbus_access,
987
attribute
988
._dbus_get_args_options
989
["byte_arrays"])
990
(types.FunctionType
991
(attribute.func_code,
992
attribute.func_globals,
993
attribute.func_name,
994
attribute.func_defaults,
995
attribute.func_closure)))
996
return type.__new__(mcs, name, bases, attr)
997
998
999
class ClientDBus(Client, DBusObjectWithProperties):
1000
"""A Client class using D-Bus
1001
1002
Attributes:
1003
dbus_object_path: dbus.ObjectPath
1004
bus: dbus.SystemBus()
1005
"""
1006
1007
runtime_expansions = (Client.runtime_expansions
1008
+ ("dbus_object_path",))
1009
1010
# dbus.service.Object doesn't use super(), so we can't either.
1011
1012
def __init__(self, bus = None, *args, **kwargs):
1013
self.bus = bus
1014
Client.__init__(self, *args, **kwargs)
1015
1016
self._approvals_pending = 0
1017
# Only now, when this client is initialized, can it show up on
1018
# the D-Bus
1019
client_object_name = unicode(self.name).translate(
1020
{ord("."): ord("_"),
1021
ord("-"): ord("_")})
1022
self.dbus_object_path = (dbus.ObjectPath
1023
("/clients/" + client_object_name))
1024
DBusObjectWithProperties.__init__(self, self.bus,
1025
self.dbus_object_path)
1026
1027
def notifychangeproperty(transform_func,
1028
dbus_name, type_func=lambda x: x,
1029
variant_level=1):
1030
""" Modify a variable so that it's a property which announces
1031
its changes to DBus.
1032
1033
transform_fun: Function that takes a value and a variant_level
1034
and transforms it to a D-Bus type.
1035
dbus_name: D-Bus name of the variable
1036
type_func: Function that transform the value before sending it
1037
to the D-Bus. Default: no transform
1038
variant_level: D-Bus variant level. Default: 1
1039
"""
1040
attrname = "_{0}".format(dbus_name)
1041
def setter(self, value):
1042
if hasattr(self, "dbus_object_path"):
1043
if (not hasattr(self, attrname) or
1044
type_func(getattr(self, attrname, None))
1045
!= type_func(value)):
1046
dbus_value = transform_func(type_func(value),
1047
variant_level
1048
=variant_level)
1049
self.PropertyChanged(dbus.String(dbus_name),
1050
dbus_value)
1051
setattr(self, attrname, value)
1052
1053
return property(lambda self: getattr(self, attrname), setter)
1054
1055
1056
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1057
approvals_pending = notifychangeproperty(dbus.Boolean,
1058
"ApprovalPending",
1059
type_func = bool)
1060
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1061
last_enabled = notifychangeproperty(datetime_to_dbus,
1062
"LastEnabled")
1063
checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",
1064
type_func = lambda checker:
1065
checker is not None)
1066
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1067
"LastCheckedOK")
1068
last_approval_request = notifychangeproperty(
1069
datetime_to_dbus, "LastApprovalRequest")
1070
approved_by_default = notifychangeproperty(dbus.Boolean,
1071
"ApprovedByDefault")
1072
approval_delay = notifychangeproperty(dbus.UInt16,
1073
"ApprovalDelay",
1074
type_func =
1075
_timedelta_to_milliseconds)
1076
approval_duration = notifychangeproperty(
1077
dbus.UInt16, "ApprovalDuration",
1078
type_func = _timedelta_to_milliseconds)
1079
host = notifychangeproperty(dbus.String, "Host")
1080
timeout = notifychangeproperty(dbus.UInt16, "Timeout",
1081
type_func =
1082
_timedelta_to_milliseconds)
1083
extended_timeout = notifychangeproperty(
1084
dbus.UInt16, "ExtendedTimeout",
1085
type_func = _timedelta_to_milliseconds)
1086
interval = notifychangeproperty(dbus.UInt16,
1087
"Interval",
1088
type_func =
1089
_timedelta_to_milliseconds)
1090
checker_command = notifychangeproperty(dbus.String, "Checker")
1091
1092
del notifychangeproperty
1093
1094
def __del__(self, *args, **kwargs):
1095
try:
1096
self.remove_from_connection()
1097
except LookupError:
1098
pass
1099
if hasattr(DBusObjectWithProperties, "__del__"):
1100
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1101
Client.__del__(self, *args, **kwargs)
1102
1103
def checker_callback(self, pid, condition, command,
1104
*args, **kwargs):
1105
self.checker_callback_tag = None
1106
self.checker = None
1107
if os.WIFEXITED(condition):
1108
exitstatus = os.WEXITSTATUS(condition)
1109
# Emit D-Bus signal
1110
self.CheckerCompleted(dbus.Int16(exitstatus),
1111
dbus.Int64(condition),
1112
dbus.String(command))
1113
else:
1114
# Emit D-Bus signal
1115
self.CheckerCompleted(dbus.Int16(-1),
1116
dbus.Int64(condition),
1117
dbus.String(command))
1118
1119
return Client.checker_callback(self, pid, condition, command,
1120
*args, **kwargs)
1121
1122
def start_checker(self, *args, **kwargs):
1123
old_checker = self.checker
1124
if self.checker is not None:
1125
old_checker_pid = self.checker.pid
1126
else:
1127
old_checker_pid = None
1128
r = Client.start_checker(self, *args, **kwargs)
1129
# Only if new checker process was started
1130
if (self.checker is not None
1131
and old_checker_pid != self.checker.pid):
1132
# Emit D-Bus signal
1133
self.CheckerStarted(self.current_checker_command)
1134
return r
1135
1136
def _reset_approved(self):
1137
self._approved = None
1138
return False
1139
1140
def approve(self, value=True):
1141
self.send_changedstate()
1142
self._approved = value
1143
gobject.timeout_add(_timedelta_to_milliseconds
1144
(self.approval_duration),
1145
self._reset_approved)
1146
1147
1148
## D-Bus methods, signals & properties
1149
_interface = "se.recompile.Mandos.Client"
1150
1151
## Signals
1152
1153
# CheckerCompleted - signal
1154
@dbus.service.signal(_interface, signature="nxs")
1155
def CheckerCompleted(self, exitcode, waitstatus, command):
1156
"D-Bus signal"
1157
pass
1158
1159
# CheckerStarted - signal
1160
@dbus.service.signal(_interface, signature="s")
1161
def CheckerStarted(self, command):
1162
"D-Bus signal"
1163
pass
1164
1165
# PropertyChanged - signal
1166
@dbus.service.signal(_interface, signature="sv")
1167
def PropertyChanged(self, property, value):
1168
"D-Bus signal"
1169
pass
1170
1171
# GotSecret - signal
1172
@dbus.service.signal(_interface)
1173
def GotSecret(self):
1174
"""D-Bus signal
1175
Is sent after a successful transfer of secret from the Mandos
1176
server to mandos-client
1177
"""
1178
pass
1179
1180
# Rejected - signal
1181
@dbus.service.signal(_interface, signature="s")
1182
def Rejected(self, reason):
1183
"D-Bus signal"
1184
pass
1185
1186
# NeedApproval - signal
1187
@dbus.service.signal(_interface, signature="tb")
1188
def NeedApproval(self, timeout, default):
1189
"D-Bus signal"
1190
return self.need_approval()
1191
1192
# NeRwequest - signal
1193
@dbus.service.signal(_interface, signature="s")
1194
def NewRequest(self, ip):
1195
"""D-Bus signal
1196
Is sent after a client request a password.
1197
"""
1198
pass
1199
1200
## Methods
1201
1202
# Approve - method
1203
@dbus.service.method(_interface, in_signature="b")
1204
def Approve(self, value):
1205
self.approve(value)
1206
1207
# CheckedOK - method
1208
@dbus.service.method(_interface)
1209
def CheckedOK(self):
1210
self.checked_ok()
1211
1212
# Enable - method
1213
@dbus.service.method(_interface)
1214
def Enable(self):
1215
"D-Bus method"
1216
self.enable()
1217
1218
# StartChecker - method
1219
@dbus.service.method(_interface)
1220
def StartChecker(self):
1221
"D-Bus method"
1222
self.start_checker()
1223
1224
# Disable - method
1225
@dbus.service.method(_interface)
1226
def Disable(self):
1227
"D-Bus method"
1228
self.disable()
1229
1230
# StopChecker - method
1231
@dbus.service.method(_interface)
1232
def StopChecker(self):
1233
self.stop_checker()
1234
1235
## Properties
1236
1237
# ApprovalPending - property
1238
@dbus_service_property(_interface, signature="b", access="read")
1239
def ApprovalPending_dbus_property(self):
1240
return dbus.Boolean(bool(self.approvals_pending))
1241
1242
# ApprovedByDefault - property
1243
@dbus_service_property(_interface, signature="b",
1244
access="readwrite")
1245
def ApprovedByDefault_dbus_property(self, value=None):
1246
if value is None: # get
1247
return dbus.Boolean(self.approved_by_default)
1248
self.approved_by_default = bool(value)
1249
1250
# ApprovalDelay - property
1251
@dbus_service_property(_interface, signature="t",
1252
access="readwrite")
1253
def ApprovalDelay_dbus_property(self, value=None):
1254
if value is None: # get
1255
return dbus.UInt64(self.approval_delay_milliseconds())
1256
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1257
1258
# ApprovalDuration - property
1259
@dbus_service_property(_interface, signature="t",
1260
access="readwrite")
1261
def ApprovalDuration_dbus_property(self, value=None):
1262
if value is None: # get
1263
return dbus.UInt64(_timedelta_to_milliseconds(
1264
self.approval_duration))
1265
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1266
1267
# Name - property
1268
@dbus_service_property(_interface, signature="s", access="read")
1269
def Name_dbus_property(self):
1270
return dbus.String(self.name)
1271
1272
# Fingerprint - property
1273
@dbus_service_property(_interface, signature="s", access="read")
1274
def Fingerprint_dbus_property(self):
1275
return dbus.String(self.fingerprint)
1276
1277
# Host - property
1278
@dbus_service_property(_interface, signature="s",
1279
access="readwrite")
1280
def Host_dbus_property(self, value=None):
1281
if value is None: # get
1282
return dbus.String(self.host)
1283
self.host = value
1284
1285
# Created - property
1286
@dbus_service_property(_interface, signature="s", access="read")
1287
def Created_dbus_property(self):
1288
return datetime_to_dbus(self.created)
1289
1290
# LastEnabled - property
1291
@dbus_service_property(_interface, signature="s", access="read")
1292
def LastEnabled_dbus_property(self):
1293
return datetime_to_dbus(self.last_enabled)
1294
1295
# Enabled - property
1296
@dbus_service_property(_interface, signature="b",
1297
access="readwrite")
1298
def Enabled_dbus_property(self, value=None):
1299
if value is None: # get
1300
return dbus.Boolean(self.enabled)
1301
if value:
1302
self.enable()
1303
else:
1304
self.disable()
1305
1306
# LastCheckedOK - property
1307
@dbus_service_property(_interface, signature="s",
1308
access="readwrite")
1309
def LastCheckedOK_dbus_property(self, value=None):
1310
if value is not None:
1311
self.checked_ok()
1312
return
1313
return datetime_to_dbus(self.last_checked_ok)
1314
1315
# Expires - property
1316
@dbus_service_property(_interface, signature="s", access="read")
1317
def Expires_dbus_property(self):
1318
return datetime_to_dbus(self.expires)
1319
1320
# LastApprovalRequest - property
1321
@dbus_service_property(_interface, signature="s", access="read")
1322
def LastApprovalRequest_dbus_property(self):
1323
return datetime_to_dbus(self.last_approval_request)
1324
1325
# Timeout - property
1326
@dbus_service_property(_interface, signature="t",
1327
access="readwrite")
1328
def Timeout_dbus_property(self, value=None):
1329
if value is None: # get
1330
return dbus.UInt64(self.timeout_milliseconds())
1331
self.timeout = datetime.timedelta(0, 0, 0, value)
1332
if getattr(self, "disable_initiator_tag", None) is None:
1333
return
1334
# Reschedule timeout
1335
gobject.source_remove(self.disable_initiator_tag)
1336
self.disable_initiator_tag = None
1337
self.expires = None
1338
time_to_die = _timedelta_to_milliseconds((self
1339
.last_checked_ok
1340
+ self.timeout)
1341
- datetime.datetime
1342
.utcnow())
1343
if time_to_die <= 0:
1344
# The timeout has passed
1345
self.disable()
1346
else:
1347
self.expires = (datetime.datetime.utcnow()
1348
+ datetime.timedelta(milliseconds =
1349
time_to_die))
1350
self.disable_initiator_tag = (gobject.timeout_add
1351
(time_to_die, self.disable))
1352
1353
# ExtendedTimeout - property
1354
@dbus_service_property(_interface, signature="t",
1355
access="readwrite")
1356
def ExtendedTimeout_dbus_property(self, value=None):
1357
if value is None: # get
1358
return dbus.UInt64(self.extended_timeout_milliseconds())
1359
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
1360
1361
# Interval - property
1362
@dbus_service_property(_interface, signature="t",
1363
access="readwrite")
1364
def Interval_dbus_property(self, value=None):
1365
if value is None: # get
1366
return dbus.UInt64(self.interval_milliseconds())
1367
self.interval = datetime.timedelta(0, 0, 0, value)
1368
if getattr(self, "checker_initiator_tag", None) is None:
1369
return
1370
if self.enabled:
1371
# Reschedule checker run
1372
gobject.source_remove(self.checker_initiator_tag)
1373
self.checker_initiator_tag = (gobject.timeout_add
1374
(value, self.start_checker))
1375
self.start_checker() # Start one now, too
1376
1377
# Checker - property
1378
@dbus_service_property(_interface, signature="s",
1379
access="readwrite")
1380
def Checker_dbus_property(self, value=None):
1381
if value is None: # get
1382
return dbus.String(self.checker_command)
1383
self.checker_command = value
1384
1385
# CheckerRunning - property
1386
@dbus_service_property(_interface, signature="b",
1387
access="readwrite")
1388
def CheckerRunning_dbus_property(self, value=None):
1389
if value is None: # get
1390
return dbus.Boolean(self.checker is not None)
1391
if value:
1392
self.start_checker()
1393
else:
1394
self.stop_checker()
1395
1396
# ObjectPath - property
1397
@dbus_service_property(_interface, signature="o", access="read")
1398
def ObjectPath_dbus_property(self):
1399
return self.dbus_object_path # is already a dbus.ObjectPath
1400
1401
# Secret = property
1402
@dbus_service_property(_interface, signature="ay",
1403
access="write", byte_arrays=True)
1404
def Secret_dbus_property(self, value):
1405
self.secret = str(value)
1406
1407
del _interface
1408
1409
1410
class ProxyClient(object):
1411
def __init__(self, child_pipe, fpr, address):
1412
self._pipe = child_pipe
1413
self._pipe.send(('init', fpr, address))
1414
if not self._pipe.recv():
1415
raise KeyError()
1416
1417
def __getattribute__(self, name):
1418
if(name == '_pipe'):
1419
return super(ProxyClient, self).__getattribute__(name)
1420
self._pipe.send(('getattr', name))
1421
data = self._pipe.recv()
1422
if data[0] == 'data':
1423
return data[1]
1424
if data[0] == 'function':
1425
def func(*args, **kwargs):
1426
self._pipe.send(('funcall', name, args, kwargs))
1427
return self._pipe.recv()[1]
1428
return func
1429
1430
def __setattr__(self, name, value):
1431
if(name == '_pipe'):
1432
return super(ProxyClient, self).__setattr__(name, value)
1433
self._pipe.send(('setattr', name, value))
1434
1435
1436
class ClientDBusTransitional(ClientDBus):
1437
__metaclass__ = AlternateDBusNamesMetaclass
1438
1439
1440
class ClientHandler(socketserver.BaseRequestHandler, object):
1441
"""A class to handle client connections.
1442
1443
Instantiated once for each connection to handle it.
372
def still_valid(self):
373
"""Has the timeout not yet passed for this client?"""
374
now = datetime.datetime.now()
375
if self.last_checked_ok is None:
376
return now < (self.created + self.timeout)
377
else:
378
return now < (self.last_checked_ok + self.timeout)
379
380
381
def peer_certificate(session):
382
"Return the peer's OpenPGP certificate as a bytestring"
383
# If not an OpenPGP certificate...
384
if gnutls.library.functions.gnutls_certificate_type_get\
385
(session._c_object) \
386
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
387
# ...do the normal thing
388
return session.peer_certificate
389
list_size = ctypes.c_uint()
390
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
391
(session._c_object, ctypes.byref(list_size))
392
if list_size.value == 0:
393
return None
394
cert = cert_list[0]
395
return ctypes.string_at(cert.data, cert.size)
396
397
398
def fingerprint(openpgp):
399
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
400
# New GnuTLS "datum" with the OpenPGP public key
401
datum = gnutls.library.types.gnutls_datum_t\
402
(ctypes.cast(ctypes.c_char_p(openpgp),
403
ctypes.POINTER(ctypes.c_ubyte)),
404
ctypes.c_uint(len(openpgp)))
405
# New empty GnuTLS certificate
406
crt = gnutls.library.types.gnutls_openpgp_crt_t()
407
gnutls.library.functions.gnutls_openpgp_crt_init\
408
(ctypes.byref(crt))
409
# Import the OpenPGP public key into the certificate
410
gnutls.library.functions.gnutls_openpgp_crt_import\
411
(crt, ctypes.byref(datum),
412
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
413
# Verify the self signature in the key
414
crtverify = ctypes.c_uint();
415
gnutls.library.functions.gnutls_openpgp_crt_verify_self\
416
(crt, ctypes.c_uint(0), ctypes.byref(crtverify))
417
if crtverify.value != 0:
418
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
419
raise gnutls.errors.CertificateSecurityError("Verify failed")
420
# New buffer for the fingerprint
421
buffer = ctypes.create_string_buffer(20)
422
buffer_length = ctypes.c_size_t()
423
# Get the fingerprint from the certificate into the buffer
424
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
425
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
426
# Deinit the certificate
427
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
428
# Convert the buffer to a Python bytestring
429
fpr = ctypes.string_at(buffer, buffer_length.value)
430
# Convert the bytestring to hexadecimal notation
431
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
432
return hex_fpr
433
434
435
class tcp_handler(SocketServer.BaseRequestHandler, object):
436
"""A TCP request handler class.
437
Instantiated by IPv6_TCPServer for each request to handle it.
1444
438
Note: This will run in its own forked process."""
1445
439
1446
440
def handle(self):
1447
with contextlib.closing(self.server.child_pipe) as child_pipe:
1448
logger.info("TCP connection from: %s",
1449
unicode(self.client_address))
1450
logger.debug("Pipe FD: %d",
1451
self.server.child_pipe.fileno())
1452
1453
session = (gnutls.connection
1454
.ClientSession(self.request,
1455
gnutls.connection
1456
.X509Credentials()))
1457
1458
# Note: gnutls.connection.X509Credentials is really a
1459
# generic GnuTLS certificate credentials object so long as
1460
# no X.509 keys are added to it. Therefore, we can use it
1461
# here despite using OpenPGP certificates.
1462
1463
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
1464
# "+AES-256-CBC", "+SHA1",
1465
# "+COMP-NULL", "+CTYPE-OPENPGP",
1466
# "+DHE-DSS"))
1467
# Use a fallback default, since this MUST be set.
1468
priority = self.server.gnutls_priority
1469
if priority is None:
1470
priority = "NORMAL"
1471
(gnutls.library.functions
1472
.gnutls_priority_set_direct(session._c_object,
1473
priority, None))
1474
1475
# Start communication using the Mandos protocol
1476
# Get protocol number
1477
line = self.request.makefile().readline()
1478
logger.debug("Protocol version: %r", line)
1479
try:
1480
if int(line.strip().split()[0]) > 1:
1481
raise RuntimeError
1482
except (ValueError, IndexError, RuntimeError) as error:
1483
logger.error("Unknown protocol version: %s", error)
1484
return
1485
1486
# Start GnuTLS connection
1487
try:
1488
session.handshake()
1489
except gnutls.errors.GNUTLSError as error:
1490
logger.warning("Handshake failed: %s", error)
1491
# Do not run session.bye() here: the session is not
1492
# established. Just abandon the request.
1493
return
1494
logger.debug("Handshake succeeded")
1495
1496
approval_required = False
1497
try:
1498
try:
1499
fpr = self.fingerprint(self.peer_certificate
1500
(session))
1501
except (TypeError,
1502
gnutls.errors.GNUTLSError) as error:
1503
logger.warning("Bad certificate: %s", error)
1504
return
1505
logger.debug("Fingerprint: %s", fpr)
1506
if self.server.use_dbus:
1507
# Emit D-Bus signal
1508
client.NewRequest(str(self.client_address))
1509
1510
try:
1511
client = ProxyClient(child_pipe, fpr,
1512
self.client_address)
1513
except KeyError:
1514
return
1515
1516
if client.approval_delay:
1517
delay = client.approval_delay
1518
client.approvals_pending += 1
1519
approval_required = True
1520
1521
while True:
1522
if not client.enabled:
1523
logger.info("Client %s is disabled",
1524
client.name)
1525
if self.server.use_dbus:
1526
# Emit D-Bus signal
1527
client.Rejected("Disabled")
1528
return
1529
1530
if client._approved or not client.approval_delay:
1531
#We are approved or approval is disabled
1532
break
1533
elif client._approved is None:
1534
logger.info("Client %s needs approval",
1535
client.name)
1536
if self.server.use_dbus:
1537
# Emit D-Bus signal
1538
client.NeedApproval(
1539
client.approval_delay_milliseconds(),
1540
client.approved_by_default)
1541
else:
1542
logger.warning("Client %s was not approved",
1543
client.name)
1544
if self.server.use_dbus:
1545
# Emit D-Bus signal
1546
client.Rejected("Denied")
1547
return
1548
1549
#wait until timeout or approved
1550
time = datetime.datetime.now()
1551
client.changedstate.acquire()
1552
(client.changedstate.wait
1553
(float(client._timedelta_to_milliseconds(delay)
1554
/ 1000)))
1555
client.changedstate.release()
1556
time2 = datetime.datetime.now()
1557
if (time2 - time) >= delay:
1558
if not client.approved_by_default:
1559
logger.warning("Client %s timed out while"
1560
" waiting for approval",
1561
client.name)
1562
if self.server.use_dbus:
1563
# Emit D-Bus signal
1564
client.Rejected("Approval timed out")
1565
return
1566
else:
1567
break
1568
else:
1569
delay -= time2 - time
1570
1571
sent_size = 0
1572
while sent_size < len(client.secret):
1573
try:
1574
sent = session.send(client.secret[sent_size:])
1575
except gnutls.errors.GNUTLSError as error:
1576
logger.warning("gnutls send failed")
1577
return
1578
logger.debug("Sent: %d, remaining: %d",
1579
sent, len(client.secret)
1580
- (sent_size + sent))
1581
sent_size += sent
1582
1583
logger.info("Sending secret to %s", client.name)
1584
# bump the timeout using extended_timeout
1585
client.checked_ok(client.extended_timeout)
1586
if self.server.use_dbus:
1587
# Emit D-Bus signal
1588
client.GotSecret()
1589
1590
finally:
1591
if approval_required:
1592
client.approvals_pending -= 1
1593
try:
1594
session.bye()
1595
except gnutls.errors.GNUTLSError as error:
1596
logger.warning("GnuTLS bye failed")
1597
1598
@staticmethod
1599
def peer_certificate(session):
1600
"Return the peer's OpenPGP certificate as a bytestring"
1601
# If not an OpenPGP certificate...
1602
if (gnutls.library.functions
1603
.gnutls_certificate_type_get(session._c_object)
1604
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1605
# ...do the normal thing
1606
return session.peer_certificate
1607
list_size = ctypes.c_uint(1)
1608
cert_list = (gnutls.library.functions
1609
.gnutls_certificate_get_peers
1610
(session._c_object, ctypes.byref(list_size)))
1611
if not bool(cert_list) and list_size.value != 0:
1612
raise gnutls.errors.GNUTLSError("error getting peer"
1613
" certificate")
1614
if list_size.value == 0:
1615
return None
1616
cert = cert_list[0]
1617
return ctypes.string_at(cert.data, cert.size)
1618
1619
@staticmethod
1620
def fingerprint(openpgp):
1621
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1622
# New GnuTLS "datum" with the OpenPGP public key
1623
datum = (gnutls.library.types
1624
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1625
ctypes.POINTER
1626
(ctypes.c_ubyte)),
1627
ctypes.c_uint(len(openpgp))))
1628
# New empty GnuTLS certificate
1629
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1630
(gnutls.library.functions
1631
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1632
# Import the OpenPGP public key into the certificate
1633
(gnutls.library.functions
1634
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1635
gnutls.library.constants
1636
.GNUTLS_OPENPGP_FMT_RAW))
1637
# Verify the self signature in the key
1638
crtverify = ctypes.c_uint()
1639
(gnutls.library.functions
1640
.gnutls_openpgp_crt_verify_self(crt, 0,
1641
ctypes.byref(crtverify)))
1642
if crtverify.value != 0:
1643
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1644
raise (gnutls.errors.CertificateSecurityError
1645
("Verify failed"))
1646
# New buffer for the fingerprint
1647
buf = ctypes.create_string_buffer(20)
1648
buf_len = ctypes.c_size_t()
1649
# Get the fingerprint from the certificate into the buffer
1650
(gnutls.library.functions
1651
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1652
ctypes.byref(buf_len)))
1653
# Deinit the certificate
1654
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1655
# Convert the buffer to a Python bytestring
1656
fpr = ctypes.string_at(buf, buf_len.value)
1657
# Convert the bytestring to hexadecimal notation
1658
hex_fpr = binascii.hexlify(fpr).upper()
1659
return hex_fpr
1660
1661
1662
class MultiprocessingMixIn(object):
1663
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
1664
def sub_process_main(self, request, address):
1665
try:
1666
self.finish_request(request, address)
1667
except:
1668
self.handle_error(request, address)
1669
self.close_request(request)
1670
1671
def process_request(self, request, address):
1672
"""Start a new process to process the request."""
1673
proc = multiprocessing.Process(target = self.sub_process_main,
1674
args = (request,
1675
address))
1676
proc.start()
1677
return proc
1678
1679
1680
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
1681
""" adds a pipe to the MixIn """
1682
def process_request(self, request, client_address):
1683
"""Overrides and wraps the original process_request().
1684
1685
This function creates a new pipe in self.pipe
1686
"""
1687
parent_pipe, self.child_pipe = multiprocessing.Pipe()
1688
1689
proc = MultiprocessingMixIn.process_request(self, request,
1690
client_address)
1691
self.child_pipe.close()
1692
self.add_pipe(parent_pipe, proc)
1693
1694
def add_pipe(self, parent_pipe, proc):
1695
"""Dummy function; override as necessary"""
1696
raise NotImplementedError
1697
1698
1699
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
1700
socketserver.TCPServer, object):
1701
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
1702
441
logger.info(u"TCP connection from: %s",
442
unicode(self.client_address))
443
session = gnutls.connection.ClientSession\
444
(self.request, gnutls.connection.X509Credentials())
445
446
line = self.request.makefile().readline()
447
logger.debug(u"Protocol version: %r", line)
448
try:
449
if int(line.strip().split()[0]) > 1:
450
raise RuntimeError
451
except (ValueError, IndexError, RuntimeError), error:
452
logger.error(u"Unknown protocol version: %s", error)
453
return
454
455
# Note: gnutls.connection.X509Credentials is really a generic
456
# GnuTLS certificate credentials object so long as no X.509
457
# keys are added to it. Therefore, we can use it here despite
458
# using OpenPGP certificates.
459
460
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
461
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
462
# "+DHE-DSS"))
463
priority = "NORMAL" # Fallback default, since this
464
# MUST be set.
465
if self.server.settings["priority"]:
466
priority = self.server.settings["priority"]
467
gnutls.library.functions.gnutls_priority_set_direct\
468
(session._c_object, priority, None);
469
470
try:
471
session.handshake()
472
except gnutls.errors.GNUTLSError, error:
473
logger.warning(u"Handshake failed: %s", error)
474
# Do not run session.bye() here: the session is not
475
# established. Just abandon the request.
476
return
477
try:
478
fpr = fingerprint(peer_certificate(session))
479
except (TypeError, gnutls.errors.GNUTLSError), error:
480
logger.warning(u"Bad certificate: %s", error)
481
session.bye()
482
return
483
logger.debug(u"Fingerprint: %s", fpr)
484
client = None
485
for c in self.server.clients:
486
if c.fingerprint == fpr:
487
client = c
488
break
489
if not client:
490
logger.warning(u"Client not found for fingerprint: %s",
491
fpr)
492
session.bye()
493
return
494
# Have to check if client.still_valid(), since it is possible
495
# that the client timed out while establishing the GnuTLS
496
# session.
497
if not client.still_valid():
498
logger.warning(u"Client %(name)s is invalid",
499
vars(client))
500
session.bye()
501
return
502
sent_size = 0
503
while sent_size < len(client.secret):
504
sent = session.send(client.secret[sent_size:])
505
logger.debug(u"Sent: %d, remaining: %d",
506
sent, len(client.secret)
507
- (sent_size + sent))
508
sent_size += sent
509
session.bye()
510
511
512
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
513
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1703
514
Attributes:
1704
enabled: Boolean; whether this server is activated yet
1705
interface: None or a network interface name (string)
1706
use_ipv6: Boolean; to use IPv6 or not
515
settings: Server settings
516
clients: Set() of Client objects
1707
517
"""
1708
def __init__(self, server_address, RequestHandlerClass,
1709
interface=None, use_ipv6=True):
1710
self.interface = interface
1711
if use_ipv6:
1712
self.address_family = socket.AF_INET6
1713
socketserver.TCPServer.__init__(self, server_address,
1714
RequestHandlerClass)
518
address_family = socket.AF_INET6
519
def __init__(self, *args, **kwargs):
520
if "settings" in kwargs:
521
self.settings = kwargs["settings"]
522
del kwargs["settings"]
523
if "clients" in kwargs:
524
self.clients = kwargs["clients"]
525
del kwargs["clients"]
526
return super(type(self), self).__init__(*args, **kwargs)
1715
527
def server_bind(self):
1716
528
"""This overrides the normal server_bind() function
1717
529
to bind to an interface if one was specified, and also NOT to
1718
530
bind to an address or port if they were not specified."""
1719
if self.interface is not None:
1720
if SO_BINDTODEVICE is None:
1721
logger.error("SO_BINDTODEVICE does not exist;"
1722
" cannot bind to interface %s",
1723
self.interface)
1724
else:
1725
try:
1726
self.socket.setsockopt(socket.SOL_SOCKET,
1727
SO_BINDTODEVICE,
1728
str(self.interface
1729
+ '\0'))
1730
except socket.error as error:
1731
if error[0] == errno.EPERM:
1732
logger.error("No permission to"
1733
" bind to interface %s",
1734
self.interface)
1735
elif error[0] == errno.ENOPROTOOPT:
1736
logger.error("SO_BINDTODEVICE not available;"
1737
" cannot bind to interface %s",
1738
self.interface)
1739
else:
1740
raise
531
if self.settings["interface"]:
532
# 25 is from /usr/include/asm-i486/socket.h
533
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
534
try:
535
self.socket.setsockopt(socket.SOL_SOCKET,
536
SO_BINDTODEVICE,
537
self.settings["interface"])
538
except socket.error, error:
539
if error[0] == errno.EPERM:
540
logger.error(u"No permission to"
541
u" bind to interface %s",
542
self.settings["interface"])
543
else:
544
raise error
1741
545
# Only bind(2) the socket if we really need to.
1742
546
if self.server_address[0] or self.server_address[1]:
1743
547
if not self.server_address[0]:
1744
if self.address_family == socket.AF_INET6:
1745
any_address = "::" # in6addr_any
1746
else:
1747
any_address = socket.INADDR_ANY
1748
self.server_address = (any_address,
548
in6addr_any = "::"
549
self.server_address = (in6addr_any,
1749
550
self.server_address[1])
1750
551
elif not self.server_address[1]:
1751
552
self.server_address = (self.server_address[0],
1752
553
0)
1753
# if self.interface:
554
# if self.settings["interface"]:
1754
555
# self.server_address = (self.server_address[0],
1755
556
# 0, # port
1756
557
# 0, # flowinfo
1757
558
# if_nametoindex
1758
# (self.interface))
1759
return socketserver.TCPServer.server_bind(self)
1760
1761
1762
class MandosServer(IPv6_TCPServer):
1763
"""Mandos server.
1764
1765
Attributes:
1766
clients: set of Client objects
1767
gnutls_priority GnuTLS priority string
1768
use_dbus: Boolean; to emit D-Bus signals or not
1769
1770
Assumes a gobject.MainLoop event loop.
1771
"""
1772
def __init__(self, server_address, RequestHandlerClass,
1773
interface=None, use_ipv6=True, clients=None,
1774
gnutls_priority=None, use_dbus=True):
1775
self.enabled = False
1776
self.clients = clients
1777
if self.clients is None:
1778
self.clients = {}
1779
self.use_dbus = use_dbus
1780
self.gnutls_priority = gnutls_priority
1781
IPv6_TCPServer.__init__(self, server_address,
1782
RequestHandlerClass,
1783
interface = interface,
1784
use_ipv6 = use_ipv6)
1785
def server_activate(self):
1786
if self.enabled:
1787
return socketserver.TCPServer.server_activate(self)
1788
1789
def enable(self):
1790
self.enabled = True
1791
1792
def add_pipe(self, parent_pipe, proc):
1793
# Call "handle_ipc" for both data and EOF events
1794
gobject.io_add_watch(parent_pipe.fileno(),
1795
gobject.IO_IN | gobject.IO_HUP,
1796
functools.partial(self.handle_ipc,
1797
parent_pipe =
1798
parent_pipe,
1799
proc = proc))
1800
1801
def handle_ipc(self, source, condition, parent_pipe=None,
1802
proc = None, client_object=None):
1803
condition_names = {
1804
gobject.IO_IN: "IN", # There is data to read.
1805
gobject.IO_OUT: "OUT", # Data can be written (without
1806
# blocking).
1807
gobject.IO_PRI: "PRI", # There is urgent data to read.
1808
gobject.IO_ERR: "ERR", # Error condition.
1809
gobject.IO_HUP: "HUP" # Hung up (the connection has been
1810
# broken, usually for pipes and
1811
# sockets).
1812
}
1813
conditions_string = ' | '.join(name
1814
for cond, name in
1815
condition_names.iteritems()
1816
if cond & condition)
1817
# error, or the other end of multiprocessing.Pipe has closed
1818
if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):
1819
# Wait for other process to exit
1820
proc.join()
1821
return False
1822
1823
# Read a request from the child
1824
request = parent_pipe.recv()
1825
command = request[0]
1826
1827
if command == 'init':
1828
fpr = request[1]
1829
address = request[2]
1830
1831
for c in self.clients.itervalues():
1832
if c.fingerprint == fpr:
1833
client = c
1834
break
1835
else:
1836
logger.info("Client not found for fingerprint: %s, ad"
1837
"dress: %s", fpr, address)
1838
if self.use_dbus:
1839
# Emit D-Bus signal
1840
mandos_dbus_service.ClientNotFound(fpr,
1841
address[0])
1842
parent_pipe.send(False)
1843
return False
1844
1845
gobject.io_add_watch(parent_pipe.fileno(),
1846
gobject.IO_IN | gobject.IO_HUP,
1847
functools.partial(self.handle_ipc,
1848
parent_pipe =
1849
parent_pipe,
1850
proc = proc,
1851
client_object =
1852
client))
1853
parent_pipe.send(True)
1854
# remove the old hook in favor of the new above hook on
1855
# same fileno
1856
return False
1857
if command == 'funcall':
1858
funcname = request[1]
1859
args = request[2]
1860
kwargs = request[3]
1861
1862
parent_pipe.send(('data', getattr(client_object,
1863
funcname)(*args,
1864
**kwargs)))
1865
1866
if command == 'getattr':
1867
attrname = request[1]
1868
if callable(client_object.__getattribute__(attrname)):
1869
parent_pipe.send(('function',))
1870
else:
1871
parent_pipe.send(('data', client_object
1872
.__getattribute__(attrname)))
1873
1874
if command == 'setattr':
1875
attrname = request[1]
1876
value = request[2]
1877
setattr(client_object, attrname, value)
1878
1879
return True
559
# (self.settings
560
# ["interface"]))
561
return super(type(self), self).server_bind()
1880
562
1881
563
1882
564
def string_to_delta(interval):
1883
565
"""Parse a string and return a datetime.timedelta
1884
566
1885
567
>>> string_to_delta('7d')
1886
568
datetime.timedelta(7)
1887
569
>>> string_to_delta('60s')
1890
572
datetime.timedelta(0, 3600)
1891
573
>>> string_to_delta('24h')
1892
574
datetime.timedelta(1)
1893
>>> string_to_delta('1w')
575
>>> string_to_delta(u'1w')
1894
576
datetime.timedelta(7)
1895
577
>>> string_to_delta('5m 30s')
1896
578
datetime.timedelta(0, 330)
1898
580
timevalue = datetime.timedelta(0)
1899
581
for s in interval.split():
1900
582
try:
1901
suffix = unicode(s[-1])
1902
value = int(s[:-1])
1903
if suffix == "d":
583
suffix=unicode(s[-1])
584
value=int(s[:-1])
585
if suffix == u"d":
1904
586
delta = datetime.timedelta(value)
1905
elif suffix == "s":
587
elif suffix == u"s":
1906
588
delta = datetime.timedelta(0, value)
1907
elif suffix == "m":
589
elif suffix == u"m":
1908
590
delta = datetime.timedelta(0, 0, 0, 0, value)
1909
elif suffix == "h":
591
elif suffix == u"h":
1910
592
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
1911
elif suffix == "w":
593
elif suffix == u"w":
1912
594
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
1913
595
else:
1914
raise ValueError("Unknown suffix %r" % suffix)
1915
except (ValueError, IndexError) as e:
1916
raise ValueError(*(e.args))
596
raise ValueError
597
except (ValueError, IndexError):
598
raise ValueError
1917
599
timevalue += delta
1918
600
return timevalue
1919
601
1920
602
603
def server_state_changed(state):
604
"""Derived from the Avahi example code"""
605
if state == avahi.SERVER_COLLISION:
606
logger.error(u"Server name collision")
607
service.remove()
608
elif state == avahi.SERVER_RUNNING:
609
service.add()
610
611
612
def entry_group_state_changed(state, error):
613
"""Derived from the Avahi example code"""
614
logger.debug(u"state change: %i", state)
615
616
if state == avahi.ENTRY_GROUP_ESTABLISHED:
617
logger.debug(u"Service established.")
618
elif state == avahi.ENTRY_GROUP_COLLISION:
619
logger.warning(u"Service name collision.")
620
service.rename()
621
elif state == avahi.ENTRY_GROUP_FAILURE:
622
logger.critical(u"Error in group state changed %s",
623
unicode(error))
624
raise AvahiGroupError("State changed: %s", str(error))
625
626
def if_nametoindex(interface):
627
"""Call the C function if_nametoindex(), or equivalent"""
628
global if_nametoindex
629
try:
630
if "ctypes.util" not in sys.modules:
631
import ctypes.util
632
if_nametoindex = ctypes.cdll.LoadLibrary\
633
(ctypes.util.find_library("c")).if_nametoindex
634
except (OSError, AttributeError):
635
if "struct" not in sys.modules:
636
import struct
637
if "fcntl" not in sys.modules:
638
import fcntl
639
def if_nametoindex(interface):
640
"Get an interface index the hard way, i.e. using fcntl()"
641
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
642
s = socket.socket()
643
ifreq = fcntl.ioctl(s, SIOCGIFINDEX,
644
struct.pack("16s16x", interface))
645
s.close()
646
interface_index = struct.unpack("I", ifreq[16:20])[0]
647
return interface_index
648
return if_nametoindex(interface)
649
650
1921
651
def daemon(nochdir = False, noclose = False):
1922
652
"""See daemon(3). Standard BSD Unix function.
1923
1924
653
This should really exist as os.daemon, but it doesn't (yet)."""
1925
654
if os.fork():
1926
655
sys.exit()
1934
663
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
1935
664
if not stat.S_ISCHR(os.fstat(null).st_mode):
1936
665
raise OSError(errno.ENODEV,
1937
"%s not a character device"
1938
% os.path.devnull)
666
"/dev/null not a character device")
1939
667
os.dup2(null, sys.stdin.fileno())
1940
668
os.dup2(null, sys.stdout.fileno())
1941
669
os.dup2(null, sys.stderr.fileno())
1944
672
1945
673
1946
674
def main():
1947
1948
##################################################################
1949
# Parsing of options, both command line and config file
1950
1951
parser = argparse.ArgumentParser()
1952
parser.add_argument("-v", "--version", action="version",
1953
version = "%%(prog)s %s" % version,
1954
help="show version number and exit")
1955
parser.add_argument("-i", "--interface", metavar="IF",
1956
help="Bind to interface IF")
1957
parser.add_argument("-a", "--address",
1958
help="Address to listen for requests on")
1959
parser.add_argument("-p", "--port", type=int,
1960
help="Port number to receive requests on")
1961
parser.add_argument("--check", action="store_true",
1962
help="Run self-test")
1963
parser.add_argument("--debug", action="store_true",
1964
help="Debug mode; run in foreground and log"
1965
" to terminal")
1966
parser.add_argument("--debuglevel", metavar="LEVEL",
1967
help="Debug level for stdout output")
1968
parser.add_argument("--priority", help="GnuTLS"
1969
" priority string (see GnuTLS documentation)")
1970
parser.add_argument("--servicename",
1971
metavar="NAME", help="Zeroconf service name")
1972
parser.add_argument("--configdir",
1973
default="/etc/mandos", metavar="DIR",
1974
help="Directory to search for configuration"
1975
" files")
1976
parser.add_argument("--no-dbus", action="store_false",
1977
dest="use_dbus", help="Do not provide D-Bus"
1978
" system bus interface")
1979
parser.add_argument("--no-ipv6", action="store_false",
1980
dest="use_ipv6", help="Do not use IPv6")
1981
parser.add_argument("--no-restore", action="store_false",
1982
dest="restore", help="Do not restore stored"
1983
" state")
1984
parser.add_argument("--statedir", metavar="DIR",
1985
help="Directory to save/restore state in")
1986
1987
options = parser.parse_args()
675
global main_loop_started
676
main_loop_started = False
677
678
parser = OptionParser(version = "%%prog %s" % version)
679
parser.add_option("-i", "--interface", type="string",
680
metavar="IF", help="Bind to interface IF")
681
parser.add_option("-a", "--address", type="string",
682
help="Address to listen for requests on")
683
parser.add_option("-p", "--port", type="int",
684
help="Port number to receive requests on")
685
parser.add_option("--check", action="store_true", default=False,
686
help="Run self-test")
687
parser.add_option("--debug", action="store_true",
688
help="Debug mode; run in foreground and log to"
689
" terminal")
690
parser.add_option("--priority", type="string", help="GnuTLS"
691
" priority string (see GnuTLS documentation)")
692
parser.add_option("--servicename", type="string", metavar="NAME",
693
help="Zeroconf service name")
694
parser.add_option("--configdir", type="string",
695
default="/etc/mandos", metavar="DIR",
696
help="Directory to search for configuration"
697
" files")
698
(options, args) = parser.parse_args()
1988
699
1989
700
if options.check:
1990
701
import doctest
1999
710
"priority":
2000
711
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",
2001
712
"servicename": "Mandos",
2002
"use_dbus": "True",
2003
"use_ipv6": "True",
2004
"debuglevel": "",
2005
"restore": "True",
2006
"statedir": "/var/lib/mandos"
2007
713
}
2008
714
2009
715
# Parse config file for server-global settings
2010
server_config = configparser.SafeConfigParser(server_defaults)
716
server_config = ConfigParser.SafeConfigParser(server_defaults)
2011
717
del server_defaults
2012
server_config.read(os.path.join(options.configdir,
2013
"mandos.conf"))
718
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2014
719
# Convert the SafeConfigParser object to a dict
2015
720
server_settings = server_config.defaults()
2016
# Use the appropriate methods on the non-string config options
2017
for option in ("debug", "use_dbus", "use_ipv6"):
2018
server_settings[option] = server_config.getboolean("DEFAULT",
2019
option)
2020
if server_settings["port"]:
2021
server_settings["port"] = server_config.getint("DEFAULT",
2022
"port")
721
# Use getboolean on the boolean config option
722
server_settings["debug"] = server_config.getboolean\
723
("DEFAULT", "debug")
2023
724
del server_config
2024
725
2025
726
# Override the settings from the config file with command line
2026
727
# options, if set.
2027
728
for option in ("interface", "address", "port", "debug",
2028
"priority", "servicename", "configdir",
2029
"use_dbus", "use_ipv6", "debuglevel", "restore",
2030
"statedir"):
729
"priority", "servicename", "configdir"):
2031
730
value = getattr(options, option)
2032
731
if value is not None:
2033
732
server_settings[option] = value
2034
733
del options
2035
# Force all strings to be unicode
2036
for option in server_settings.keys():
2037
if type(server_settings[option]) is str:
2038
server_settings[option] = unicode(server_settings[option])
2039
734
# Now we have our good server settings in "server_settings"
2040
735
2041
##################################################################
2042
2043
# For convenience
2044
736
debug = server_settings["debug"]
2045
debuglevel = server_settings["debuglevel"]
2046
use_dbus = server_settings["use_dbus"]
2047
use_ipv6 = server_settings["use_ipv6"]
2048
stored_state_path = os.path.join(server_settings["statedir"],
2049
stored_state_file)
2050
737
2051
if debug:
2052
initlogger(logging.DEBUG)
2053
else:
2054
if not debuglevel:
2055
initlogger()
2056
else:
2057
level = getattr(logging, debuglevel.upper())
2058
initlogger(level)
738
if not debug:
739
syslogger.setLevel(logging.WARNING)
740
console.setLevel(logging.WARNING)
2059
741
2060
742
if server_settings["servicename"] != "Mandos":
2061
syslogger.setFormatter(logging.Formatter
2062
('Mandos (%s) [%%(process)d]:'
2063
' %%(levelname)s: %%(message)s'
743
syslogger.setFormatter(logging.Formatter\
744
('Mandos (%s): %%(levelname)s:'
745
' %%(message)s'
2064
746
% server_settings["servicename"]))
2065
747
2066
748
# Parse config file with clients
2067
client_defaults = { "timeout": "5m",
2068
"extended_timeout": "15m",
2069
"interval": "2m",
2070
"checker": "fping -q -- %%(host)s",
749
client_defaults = { "timeout": "1h",
750
"interval": "5m",
751
"checker": "fping -q -- %(host)s",
2071
752
"host": "",
2072
"approval_delay": "0s",
2073
"approval_duration": "1s",
2074
753
}
2075
client_config = configparser.SafeConfigParser(client_defaults)
754
client_config = ConfigParser.SafeConfigParser(client_defaults)
2076
755
client_config.read(os.path.join(server_settings["configdir"],
2077
756
"clients.conf"))
2078
757
2079
global mandos_dbus_service
2080
mandos_dbus_service = None
2081
2082
tcp_server = MandosServer((server_settings["address"],
2083
server_settings["port"]),
2084
ClientHandler,
2085
interface=(server_settings["interface"]
2086
or None),
2087
use_ipv6=use_ipv6,
2088
gnutls_priority=
2089
server_settings["priority"],
2090
use_dbus=use_dbus)
2091
if not debug:
2092
pidfilename = "/var/run/mandos.pid"
2093
try:
2094
pidfile = open(pidfilename, "w")
2095
except IOError:
2096
logger.error("Could not open file %r", pidfilename)
2097
2098
try:
2099
uid = pwd.getpwnam("_mandos").pw_uid
2100
gid = pwd.getpwnam("_mandos").pw_gid
2101
except KeyError:
2102
try:
2103
uid = pwd.getpwnam("mandos").pw_uid
2104
gid = pwd.getpwnam("mandos").pw_gid
2105
except KeyError:
2106
try:
2107
uid = pwd.getpwnam("nobody").pw_uid
2108
gid = pwd.getpwnam("nobody").pw_gid
2109
except KeyError:
2110
uid = 65534
2111
gid = 65534
2112
try:
2113
os.setgid(gid)
2114
os.setuid(uid)
2115
except OSError as error:
2116
if error[0] != errno.EPERM:
2117
raise error
2118
2119
if debug:
2120
# Enable all possible GnuTLS debugging
2121
2122
# "Use a log level over 10 to enable all debugging options."
2123
# - GnuTLS manual
2124
gnutls.library.functions.gnutls_global_set_log_level(11)
2125
2126
@gnutls.library.types.gnutls_log_func
2127
def debug_gnutls(level, string):
2128
logger.debug("GnuTLS: %s", string[:-1])
2129
2130
(gnutls.library.functions
2131
.gnutls_global_set_log_function(debug_gnutls))
2132
2133
# Redirect stdin so all checkers get /dev/null
2134
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
2135
os.dup2(null, sys.stdin.fileno())
2136
if null > 2:
2137
os.close(null)
2138
else:
2139
# No console logging
2140
logger.removeHandler(console)
2141
2142
# Need to fork before connecting to D-Bus
2143
if not debug:
2144
# Close all input and output, do double fork, etc.
2145
daemon()
758
global service
759
service = AvahiService(name = server_settings["servicename"],
760
type = "_mandos._tcp", );
761
if server_settings["interface"]:
762
service.interface = if_nametoindex(server_settings["interface"])
2146
763
2147
764
global main_loop
765
global bus
766
global server
2148
767
# From the Avahi example code
2149
768
DBusGMainLoop(set_as_default=True )
2150
769
main_loop = gobject.MainLoop()
2151
770
bus = dbus.SystemBus()
771
server = dbus.Interface(
772
bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),
773
avahi.DBUS_INTERFACE_SERVER )
2152
774
# End of Avahi example code
2153
if use_dbus:
2154
try:
2155
bus_name = dbus.service.BusName("se.recompile.Mandos",
2156
bus, do_not_queue=True)
2157
old_bus_name = (dbus.service.BusName
2158
("se.bsnet.fukt.Mandos", bus,
2159
do_not_queue=True))
2160
except dbus.exceptions.NameExistsException as e:
2161
logger.error(unicode(e) + ", disabling D-Bus")
2162
use_dbus = False
2163
server_settings["use_dbus"] = False
2164
tcp_server.use_dbus = False
2165
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2166
service = AvahiServiceToSyslog(name =
2167
server_settings["servicename"],
2168
servicetype = "_mandos._tcp",
2169
protocol = protocol, bus = bus)
2170
if server_settings["interface"]:
2171
service.interface = (if_nametoindex
2172
(str(server_settings["interface"])))
2173
2174
global multiprocessing_manager
2175
multiprocessing_manager = multiprocessing.Manager()
2176
2177
client_class = Client
2178
if use_dbus:
2179
client_class = functools.partial(ClientDBusTransitional,
2180
bus = bus)
2181
2182
special_settings = {
2183
# Some settings need to be accessd by special methods;
2184
# booleans need .getboolean(), etc. Here is a list of them:
2185
"approved_by_default":
2186
lambda section:
2187
client_config.getboolean(section, "approved_by_default"),
2188
"enabled":
2189
lambda section:
2190
client_config.getboolean(section, "enabled"),
2191
}
2192
# Construct a new dict of client settings of this form:
2193
# { client_name: {setting_name: value, ...}, ...}
2194
# with exceptions for any special settings as defined above
2195
client_settings = dict((clientname,
2196
dict((setting,
2197
(value
2198
if setting not in special_settings
2199
else special_settings[setting]
2200
(clientname)))
2201
for setting, value in
2202
client_config.items(clientname)))
2203
for clientname in client_config.sections())
2204
2205
old_client_settings = {}
2206
clients_data = []
2207
2208
# Get client data and settings from last running state.
2209
if server_settings["restore"]:
2210
try:
2211
with open(stored_state_path, "rb") as stored_state:
2212
clients_data, old_client_settings = (pickle.load
2213
(stored_state))
2214
os.remove(stored_state_path)
2215
except IOError as e:
2216
logger.warning("Could not load persistent state: {0}"
2217
.format(e))
2218
if e.errno != errno.ENOENT:
2219
raise
2220
2221
with PGPEngine() as pgp:
2222
for client in clients_data:
2223
client_name = client["name"]
2224
2225
# Decide which value to use after restoring saved state.
2226
# We have three different values: Old config file,
2227
# new config file, and saved state.
2228
# New config value takes precedence if it differs from old
2229
# config value, otherwise use saved state.
2230
for name, value in client_settings[client_name].items():
2231
try:
2232
# For each value in new config, check if it
2233
# differs from the old config value (Except for
2234
# the "secret" attribute)
2235
if (name != "secret" and
2236
value != old_client_settings[client_name]
2237
[name]):
2238
setattr(client, name, value)
2239
except KeyError:
2240
pass
2241
2242
# Clients who has passed its expire date can still be
2243
# enabled if its last checker was sucessful. Clients
2244
# whose checker failed before we stored its state is
2245
# assumed to have failed all checkers during downtime.
2246
if client["enabled"] and client["last_checked_ok"]:
2247
if ((datetime.datetime.utcnow()
2248
- client["last_checked_ok"])
2249
> client["interval"]):
2250
if client["last_checker_status"] != 0:
2251
client["enabled"] = False
2252
else:
2253
client["expires"] = (datetime.datetime
2254
.utcnow()
2255
+ client["timeout"])
2256
2257
client["changedstate"] = (multiprocessing_manager
2258
.Condition
2259
(multiprocessing_manager
2260
.Lock()))
2261
if use_dbus:
2262
new_client = (ClientDBusTransitional.__new__
2263
(ClientDBusTransitional))
2264
tcp_server.clients[client_name] = new_client
2265
new_client.bus = bus
2266
for name, value in client.iteritems():
2267
setattr(new_client, name, value)
2268
client_object_name = unicode(client_name).translate(
2269
{ord("."): ord("_"),
2270
ord("-"): ord("_")})
2271
new_client.dbus_object_path = (dbus.ObjectPath
2272
("/clients/"
2273
+ client_object_name))
2274
DBusObjectWithProperties.__init__(new_client,
2275
new_client.bus,
2276
new_client
2277
.dbus_object_path)
2278
else:
2279
tcp_server.clients[client_name] = (Client.__new__
2280
(Client))
2281
for name, value in client.iteritems():
2282
setattr(tcp_server.clients[client_name],
2283
name, value)
2284
2285
try:
2286
tcp_server.clients[client_name].secret = (
2287
pgp.decrypt(tcp_server.clients[client_name]
2288
.encrypted_secret,
2289
client_settings[client_name]
2290
["secret"]))
2291
except PGPError:
2292
# If decryption fails, we use secret from new settings
2293
logger.debug("Failed to decrypt {0} old secret"
2294
.format(client_name))
2295
tcp_server.clients[client_name].secret = (
2296
client_settings[client_name]["secret"])
2297
2298
# Create/remove clients based on new changes made to config
2299
for clientname in set(old_client_settings) - set(client_settings):
2300
del tcp_server.clients[clientname]
2301
for clientname in set(client_settings) - set(old_client_settings):
2302
tcp_server.clients[clientname] = (client_class(name
2303
= clientname,
2304
config =
2305
client_settings
2306
[clientname]))
2307
2308
if not tcp_server.clients:
2309
logger.warning("No clients defined")
775
776
clients = Set()
777
def remove_from_clients(client):
778
clients.remove(client)
779
if not clients:
780
logger.critical(u"No clients left, exiting")
781
sys.exit()
782
783
clients.update(Set(Client(name = section,
784
stop_hook = remove_from_clients,
785
config
786
= dict(client_config.items(section)))
787
for section in client_config.sections()))
788
if not clients:
789
logger.critical(u"No clients defined")
790
sys.exit(1)
791
792
if debug:
793
# Redirect stdin so all checkers get /dev/null
794
null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)
795
os.dup2(null, sys.stdin.fileno())
796
if null > 2:
797
os.close(null)
798
else:
799
# No console logging
800
logger.removeHandler(console)
801
# Close all input and output, do double fork, etc.
802
daemon()
803
804
pidfilename = "/var/run/mandos/mandos.pid"
805
pid = os.getpid()
806
try:
807
pidfile = open(pidfilename, "w")
808
pidfile.write(str(pid) + "\n")
809
pidfile.close()
810
del pidfile
811
except IOError, err:
812
logger.error(u"Could not write %s file with PID %d",
813
pidfilename, os.getpid())
814
815
def cleanup():
816
"Cleanup function; run on exit"
817
global group
818
# From the Avahi example code
819
if not group is None:
820
group.Free()
821
group = None
822
# End of Avahi example code
2310
823
824
while clients:
825
client = clients.pop()
826
client.stop_hook = None
827
client.stop()
828
829
atexit.register(cleanup)
830
2311
831
if not debug:
2312
try:
2313
with pidfile:
2314
pid = os.getpid()
2315
pidfile.write(str(pid) + "\n".encode("utf-8"))
2316
del pidfile
2317
except IOError:
2318
logger.error("Could not write to file %r with PID %d",
2319
pidfilename, pid)
2320
except NameError:
2321
# "pidfile" was never created
2322
pass
2323
del pidfilename
2324
2325
832
signal.signal(signal.SIGINT, signal.SIG_IGN)
2326
2327
833
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
2328
834
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
2329
835
2330
if use_dbus:
2331
class MandosDBusService(dbus.service.Object):
2332
"""A D-Bus proxy object"""
2333
def __init__(self):
2334
dbus.service.Object.__init__(self, bus, "/")
2335
_interface = "se.recompile.Mandos"
2336
2337
@dbus.service.signal(_interface, signature="o")
2338
def ClientAdded(self, objpath):
2339
"D-Bus signal"
2340
pass
2341
2342
@dbus.service.signal(_interface, signature="ss")
2343
def ClientNotFound(self, fingerprint, address):
2344
"D-Bus signal"
2345
pass
2346
2347
@dbus.service.signal(_interface, signature="os")
2348
def ClientRemoved(self, objpath, name):
2349
"D-Bus signal"
2350
pass
2351
2352
@dbus.service.method(_interface, out_signature="ao")
2353
def GetAllClients(self):
2354
"D-Bus method"
2355
return dbus.Array(c.dbus_object_path
2356
for c in
2357
tcp_server.clients.itervalues())
2358
2359
@dbus.service.method(_interface,
2360
out_signature="a{oa{sv}}")
2361
def GetAllClientsWithProperties(self):
2362
"D-Bus method"
2363
return dbus.Dictionary(
2364
((c.dbus_object_path, c.GetAll(""))
2365
for c in tcp_server.clients.itervalues()),
2366
signature="oa{sv}")
2367
2368
@dbus.service.method(_interface, in_signature="o")
2369
def RemoveClient(self, object_path):
2370
"D-Bus method"
2371
for c in tcp_server.clients.itervalues():
2372
if c.dbus_object_path == object_path:
2373
del tcp_server.clients[c.name]
2374
c.remove_from_connection()
2375
# Don't signal anything except ClientRemoved
2376
c.disable(quiet=True)
2377
# Emit D-Bus signal
2378
self.ClientRemoved(object_path, c.name)
2379
return
2380
raise KeyError(object_path)
2381
2382
del _interface
2383
2384
class MandosDBusServiceTransitional(MandosDBusService):
2385
__metaclass__ = AlternateDBusNamesMetaclass
2386
mandos_dbus_service = MandosDBusServiceTransitional()
2387
2388
def cleanup():
2389
"Cleanup function; run on exit"
2390
service.cleanup()
2391
2392
multiprocessing.active_children()
2393
if not (tcp_server.clients or client_settings):
2394
return
2395
2396
# Store client before exiting. Secrets are encrypted with key
2397
# based on what config file has. If config file is
2398
# removed/edited, old secret will thus be unrecovable.
2399
clients = []
2400
with PGPEngine() as pgp:
2401
for client in tcp_server.clients.itervalues():
2402
key = client_settings[client.name]["secret"]
2403
client.encrypted_secret = pgp.encrypt(client.secret,
2404
key)
2405
client_dict = {}
2406
2407
# A list of attributes that will not be stored when
2408
# shutting down.
2409
exclude = set(("bus", "changedstate", "secret"))
2410
for name, typ in (inspect.getmembers
2411
(dbus.service.Object)):
2412
exclude.add(name)
2413
2414
client_dict["encrypted_secret"] = (client
2415
.encrypted_secret)
2416
for attr in client.client_structure:
2417
if attr not in exclude:
2418
client_dict[attr] = getattr(client, attr)
2419
2420
clients.append(client_dict)
2421
del client_settings[client.name]["secret"]
2422
2423
try:
2424
with os.fdopen(os.open(stored_state_path,
2425
os.O_CREAT|os.O_WRONLY|os.O_TRUNC,
2426
0600), "wb") as stored_state:
2427
pickle.dump((clients, client_settings), stored_state)
2428
except (IOError, OSError) as e:
2429
logger.warning("Could not save persistent state: {0}"
2430
.format(e))
2431
if e.errno not in (errno.ENOENT, errno.EACCES):
2432
raise
2433
2434
# Delete all clients, and settings from config
2435
while tcp_server.clients:
2436
name, client = tcp_server.clients.popitem()
2437
if use_dbus:
2438
client.remove_from_connection()
2439
# Don't signal anything except ClientRemoved
2440
client.disable(quiet=True)
2441
if use_dbus:
2442
# Emit D-Bus signal
2443
mandos_dbus_service.ClientRemoved(client
2444
.dbus_object_path,
2445
client.name)
2446
client_settings.clear()
2447
2448
atexit.register(cleanup)
2449
2450
for client in tcp_server.clients.itervalues():
2451
if use_dbus:
2452
# Emit D-Bus signal
2453
mandos_dbus_service.ClientAdded(client.dbus_object_path)
2454
# Need to initiate checking of clients
2455
if client.enabled:
2456
client.init_checker()
2457
2458
tcp_server.enable()
2459
tcp_server.server_activate()
2460
836
for client in clients:
837
client.start()
838
839
tcp_server = IPv6_TCPServer((server_settings["address"],
840
server_settings["port"]),
841
tcp_handler,
842
settings=server_settings,
843
clients=clients)
2461
844
# Find out what port we got
2462
845
service.port = tcp_server.socket.getsockname()[1]
2463
if use_ipv6:
2464
logger.info("Now listening on address %r, port %d,"
2465
" flowinfo %d, scope_id %d"
2466
% tcp_server.socket.getsockname())
2467
else: # IPv4
2468
logger.info("Now listening on address %r, port %d"
2469
% tcp_server.socket.getsockname())
846
logger.info(u"Now listening on address %r, port %d, flowinfo %d,"
847
u" scope_id %d" % tcp_server.socket.getsockname())
2470
848
2471
849
#service.interface = tcp_server.socket.getsockname()[3]
2472
850
2473
851
try:
2474
852
# From the Avahi example code
853
server.connect_to_signal("StateChanged", server_state_changed)
2475
854
try:
2476
service.activate()
2477
except dbus.exceptions.DBusException as error:
2478
logger.critical("DBusException: %s", error)
2479
cleanup()
855
server_state_changed(server.GetState())
856
except dbus.exceptions.DBusException, error:
857
logger.critical(u"DBusException: %s", error)
2480
858
sys.exit(1)
2481
859
# End of Avahi example code
2482
860
2483
861
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
2484
862
lambda *args, **kwargs:
2485
(tcp_server.handle_request
2486
(*args[2:], **kwargs) or True))
863
tcp_server.handle_request\
864
(*args[2:], **kwargs) or True)
2487
865
2488
logger.debug("Starting main loop")
866
logger.debug(u"Starting main loop")
867
main_loop_started = True
2489
868
main_loop.run()
2490
except AvahiError as error:
2491
logger.critical("AvahiError: %s", error)
2492
cleanup()
869
except AvahiError, error:
870
logger.critical(u"AvahiError: %s" + unicode(error))
2493
871
sys.exit(1)
2494
872
except KeyboardInterrupt:
2495
873
if debug:
2496
print("", file=sys.stderr)
2497
logger.debug("Server received KeyboardInterrupt")
2498
logger.debug("Server exiting")
2499
# Must run before the D-Bus bus name gets deregistered
2500
cleanup()
2501
874
print
2502
875
2503
876
if __name__ == '__main__':
2504
877
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0