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