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 1194
- compare with another revision
- download diff
- download tarball
- view history from revision 1194
- Committer: teddy at recompile
- Date: 2019-12-05 03:38:07 UTC
- Revision ID: teddy@recompile.se-20191205033807-6awt45zpgp194vl1
From: Frans Spiesschaert <Frans.Spiesschaert@yucom.be>
Add Dutch debconf translation
* debian/po/nl.po: New.
Acked-by: Teddy Hogeborn <teddy@recompile.se>
Add Dutch debconf translation
* debian/po/nl.po: New.
Acked-by: Teddy Hogeborn <teddy@recompile.se>
- files added:
- bugs.xml
- debian/tests
- dracut-module
- files removed:
- initramfs-tools-hook-conf
- files modified:
- .bzrignore
added
removed
mandos
1
#!/usr/bin/python
2
# -*- mode: python; coding: utf-8 -*-
3
#
1
#!/usr/bin/python3 -bI
2
# -*- mode: python; after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
5
#
5
#
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
9
# methods "add", "remove", "server_state_changed",
10
10
# "entry_group_state_changed", "cleanup", and "activate" in the
11
11
# "AvahiService" class, and some lines in "main".
12
#
12
#
13
13
# Everything else is
14
# Copyright © 2008-2016 Teddy Hogeborn
15
# Copyright © 2008-2016 Björn Påhlsson
16
#
17
# This program is free software: you can redistribute it and/or modify
18
# it under the terms of the GNU General Public License as published by
14
# Copyright © 2008-2019 Teddy Hogeborn
15
# Copyright © 2008-2019 Björn Påhlsson
16
#
17
# This file is part of Mandos.
18
#
19
# Mandos is free software: you can redistribute it and/or modify it
20
# under the terms of the GNU General Public License as published by
19
21
# the Free Software Foundation, either version 3 of the License, or
20
22
# (at your option) any later version.
21
23
#
22
# This program is distributed in the hope that it will be useful,
23
# but WITHOUT ANY WARRANTY; without even the implied warranty of
24
# Mandos is distributed in the hope that it will be useful, but
25
# WITHOUT ANY WARRANTY; without even the implied warranty of
24
26
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25
27
# GNU General Public License for more details.
26
#
28
#
27
29
# You should have received a copy of the GNU General Public License
28
# along with this program. If not, see
29
# <http://www.gnu.org/licenses/>.
30
#
30
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
31
#
31
32
# Contact the authors at <mandos@recompile.se>.
32
#
33
#
33
34
34
35
from __future__ import (division, absolute_import, print_function,
35
36
unicode_literals)
36
37
37
from future_builtins import *
38
try:
39
from future_builtins import *
40
except ImportError:
41
pass
38
42
39
43
try:
40
44
import SocketServer as socketserver
73
77
import itertools
74
78
import collections
75
79
import codecs
80
import unittest
76
81
77
82
import dbus
78
83
import dbus.service
79
try:
80
import gobject
81
except ImportError:
82
from gi.repository import GObject as gobject
83
import avahi
84
import gi
85
from gi.repository import GLib
84
86
from dbus.mainloop.glib import DBusGMainLoop
85
87
import ctypes
86
88
import ctypes.util
87
89
import xml.dom.minidom
88
90
import inspect
89
91
92
if sys.version_info.major == 2:
93
__metaclass__ = type
94
str = unicode
95
96
# Show warnings by default
97
if not sys.warnoptions:
98
import warnings
99
warnings.simplefilter("default")
100
101
# Try to find the value of SO_BINDTODEVICE:
90
102
try:
103
# This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and
104
# newer, and it is also the most natural place for it:
91
105
SO_BINDTODEVICE = socket.SO_BINDTODEVICE
92
106
except AttributeError:
93
107
try:
108
# This is where SO_BINDTODEVICE was up to and including Python
109
# 2.6, and also 3.2:
94
110
from IN import SO_BINDTODEVICE
95
111
except ImportError:
96
SO_BINDTODEVICE = None
97
98
if sys.version_info.major == 2:
99
str = unicode
100
101
version = "1.7.2"
112
# In Python 2.7 it seems to have been removed entirely.
113
# Try running the C preprocessor:
114
try:
115
cc = subprocess.Popen(["cc", "--language=c", "-E",
116
"/dev/stdin"],
117
stdin=subprocess.PIPE,
118
stdout=subprocess.PIPE)
119
stdout = cc.communicate(
120
"#include <sys/socket.h>\nSO_BINDTODEVICE\n")[0]
121
SO_BINDTODEVICE = int(stdout.splitlines()[-1])
122
except (OSError, ValueError, IndexError):
123
# No value found
124
SO_BINDTODEVICE = None
125
126
if sys.version_info < (3, 2):
127
configparser.Configparser = configparser.SafeConfigParser
128
129
version = "1.8.9"
102
130
stored_state_file = "clients.pickle"
103
131
104
132
logger = logging.getLogger()
133
logging.captureWarnings(True) # Show warnings via the logging system
105
134
syslogger = None
106
135
107
136
try:
108
137
if_nametoindex = ctypes.cdll.LoadLibrary(
109
138
ctypes.util.find_library("c")).if_nametoindex
110
139
except (OSError, AttributeError):
111
140
112
141
def if_nametoindex(interface):
113
142
"Get an interface index the hard way, i.e. using fcntl()"
114
143
SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h
119
148
return interface_index
120
149
121
150
151
def copy_function(func):
152
"""Make a copy of a function"""
153
if sys.version_info.major == 2:
154
return types.FunctionType(func.func_code,
155
func.func_globals,
156
func.func_name,
157
func.func_defaults,
158
func.func_closure)
159
else:
160
return types.FunctionType(func.__code__,
161
func.__globals__,
162
func.__name__,
163
func.__defaults__,
164
func.__closure__)
165
166
122
167
def initlogger(debug, level=logging.WARNING):
123
168
"""init logger and add loglevel"""
124
169
125
170
global syslogger
126
171
syslogger = (logging.handlers.SysLogHandler(
127
facility = logging.handlers.SysLogHandler.LOG_DAEMON,
128
address = "/dev/log"))
172
facility=logging.handlers.SysLogHandler.LOG_DAEMON,
173
address="/dev/log"))
129
174
syslogger.setFormatter(logging.Formatter
130
175
('Mandos [%(process)d]: %(levelname)s:'
131
176
' %(message)s'))
132
177
logger.addHandler(syslogger)
133
178
134
179
if debug:
135
180
console = logging.StreamHandler()
136
181
console.setFormatter(logging.Formatter('%(asctime)s %(name)s'
146
191
pass
147
192
148
193
149
class PGPEngine(object):
194
class PGPEngine:
150
195
"""A simple class for OpenPGP symmetric encryption & decryption"""
151
196
152
197
def __init__(self):
153
198
self.tempdir = tempfile.mkdtemp(prefix="mandos-")
154
199
self.gpg = "gpg"
155
200
try:
156
201
output = subprocess.check_output(["gpgconf"])
157
202
for line in output.splitlines():
158
name, text, path = line.split(":")
159
if name == "gpg":
203
name, text, path = line.split(b":")
204
if name == b"gpg":
160
205
self.gpg = path
161
206
break
162
207
except OSError as e:
165
210
self.gnupgargs = ['--batch',
166
211
'--homedir', self.tempdir,
167
212
'--force-mdc',
168
'--quiet',
169
'--no-use-agent']
170
213
'--quiet']
214
# Only GPG version 1 has the --no-use-agent option.
215
if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
216
self.gnupgargs.append("--no-use-agent")
217
171
218
def __enter__(self):
172
219
return self
173
220
174
221
def __exit__(self, exc_type, exc_value, traceback):
175
222
self._cleanup()
176
223
return False
177
224
178
225
def __del__(self):
179
226
self._cleanup()
180
227
181
228
def _cleanup(self):
182
229
if self.tempdir is not None:
183
230
# Delete contents of tempdir
184
231
for root, dirs, files in os.walk(self.tempdir,
185
topdown = False):
232
topdown=False):
186
233
for filename in files:
187
234
os.remove(os.path.join(root, filename))
188
235
for dirname in dirs:
190
237
# Remove tempdir
191
238
os.rmdir(self.tempdir)
192
239
self.tempdir = None
193
240
194
241
def password_encode(self, password):
195
242
# Passphrase can not be empty and can not contain newlines or
196
243
# NUL bytes. So we prefix it and hex encode it.
201
248
.replace(b"\n", b"\\n")
202
249
.replace(b"\0", b"\\x00"))
203
250
return encoded
204
251
205
252
def encrypt(self, data, password):
206
253
passphrase = self.password_encode(password)
207
254
with tempfile.NamedTemporaryFile(
212
259
'--passphrase-file',
213
260
passfile.name]
214
261
+ self.gnupgargs,
215
stdin = subprocess.PIPE,
216
stdout = subprocess.PIPE,
217
stderr = subprocess.PIPE)
218
ciphertext, err = proc.communicate(input = data)
262
stdin=subprocess.PIPE,
263
stdout=subprocess.PIPE,
264
stderr=subprocess.PIPE)
265
ciphertext, err = proc.communicate(input=data)
219
266
if proc.returncode != 0:
220
267
raise PGPError(err)
221
268
return ciphertext
222
269
223
270
def decrypt(self, data, password):
224
271
passphrase = self.password_encode(password)
225
272
with tempfile.NamedTemporaryFile(
226
dir = self.tempdir) as passfile:
273
dir=self.tempdir) as passfile:
227
274
passfile.write(passphrase)
228
275
passfile.flush()
229
276
proc = subprocess.Popen([self.gpg, '--decrypt',
230
277
'--passphrase-file',
231
278
passfile.name]
232
279
+ self.gnupgargs,
233
stdin = subprocess.PIPE,
234
stdout = subprocess.PIPE,
235
stderr = subprocess.PIPE)
236
decrypted_plaintext, err = proc.communicate(input = data)
280
stdin=subprocess.PIPE,
281
stdout=subprocess.PIPE,
282
stderr=subprocess.PIPE)
283
decrypted_plaintext, err = proc.communicate(input=data)
237
284
if proc.returncode != 0:
238
285
raise PGPError(err)
239
286
return decrypted_plaintext
240
287
241
288
289
# Pretend that we have an Avahi module
290
class avahi:
291
"""This isn't so much a class as it is a module-like namespace."""
292
IF_UNSPEC = -1 # avahi-common/address.h
293
PROTO_UNSPEC = -1 # avahi-common/address.h
294
PROTO_INET = 0 # avahi-common/address.h
295
PROTO_INET6 = 1 # avahi-common/address.h
296
DBUS_NAME = "org.freedesktop.Avahi"
297
DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"
298
DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"
299
DBUS_PATH_SERVER = "/"
300
301
@staticmethod
302
def string_array_to_txt_array(t):
303
return dbus.Array((dbus.ByteArray(s.encode("utf-8"))
304
for s in t), signature="ay")
305
ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h
306
ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h
307
ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h
308
SERVER_INVALID = 0 # avahi-common/defs.h
309
SERVER_REGISTERING = 1 # avahi-common/defs.h
310
SERVER_RUNNING = 2 # avahi-common/defs.h
311
SERVER_COLLISION = 3 # avahi-common/defs.h
312
SERVER_FAILURE = 4 # avahi-common/defs.h
313
314
242
315
class AvahiError(Exception):
243
316
def __init__(self, value, *args, **kwargs):
244
317
self.value = value
254
327
pass
255
328
256
329
257
class AvahiService(object):
330
class AvahiService:
258
331
"""An Avahi (Zeroconf) service.
259
332
260
333
Attributes:
261
334
interface: integer; avahi.IF_UNSPEC or an interface index.
262
335
Used to optionally bind to the specified interface.
274
347
server: D-Bus Server
275
348
bus: dbus.SystemBus()
276
349
"""
277
350
278
351
def __init__(self,
279
interface = avahi.IF_UNSPEC,
280
name = None,
281
servicetype = None,
282
port = None,
283
TXT = None,
284
domain = "",
285
host = "",
286
max_renames = 32768,
287
protocol = avahi.PROTO_UNSPEC,
288
bus = None):
352
interface=avahi.IF_UNSPEC,
353
name=None,
354
servicetype=None,
355
port=None,
356
TXT=None,
357
domain="",
358
host="",
359
max_renames=32768,
360
protocol=avahi.PROTO_UNSPEC,
361
bus=None):
289
362
self.interface = interface
290
363
self.name = name
291
364
self.type = servicetype
300
373
self.server = None
301
374
self.bus = bus
302
375
self.entry_group_state_changed_match = None
303
376
304
377
def rename(self, remove=True):
305
378
"""Derived from the Avahi example code"""
306
379
if self.rename_count >= self.max_renames:
326
399
logger.critical("D-Bus Exception", exc_info=error)
327
400
self.cleanup()
328
401
os._exit(1)
329
402
330
403
def remove(self):
331
404
"""Derived from the Avahi example code"""
332
405
if self.entry_group_state_changed_match is not None:
334
407
self.entry_group_state_changed_match = None
335
408
if self.group is not None:
336
409
self.group.Reset()
337
410
338
411
def add(self):
339
412
"""Derived from the Avahi example code"""
340
413
self.remove()
357
430
dbus.UInt16(self.port),
358
431
avahi.string_array_to_txt_array(self.TXT))
359
432
self.group.Commit()
360
433
361
434
def entry_group_state_changed(self, state, error):
362
435
"""Derived from the Avahi example code"""
363
436
logger.debug("Avahi entry group state change: %i", state)
364
437
365
438
if state == avahi.ENTRY_GROUP_ESTABLISHED:
366
439
logger.debug("Zeroconf service established.")
367
440
elif state == avahi.ENTRY_GROUP_COLLISION:
371
444
logger.critical("Avahi: Error in group state changed %s",
372
445
str(error))
373
446
raise AvahiGroupError("State changed: {!s}".format(error))
374
447
375
448
def cleanup(self):
376
449
"""Derived from the Avahi example code"""
377
450
if self.group is not None:
382
455
pass
383
456
self.group = None
384
457
self.remove()
385
458
386
459
def server_state_changed(self, state, error=None):
387
460
"""Derived from the Avahi example code"""
388
461
logger.debug("Avahi server state change: %i", state)
417
490
logger.debug("Unknown state: %r", state)
418
491
else:
419
492
logger.debug("Unknown state: %r: %r", state, error)
420
493
421
494
def activate(self):
422
495
"""Derived from the Avahi example code"""
423
496
if self.server is None:
434
507
class AvahiServiceToSyslog(AvahiService):
435
508
def rename(self, *args, **kwargs):
436
509
"""Add the new name to the syslog messages"""
437
ret = AvahiService.rename(self, *args, **kwargs)
510
ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)
438
511
syslogger.setFormatter(logging.Formatter(
439
512
'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'
440
513
.format(self.name)))
441
514
return ret
442
515
516
443
517
# Pretend that we have a GnuTLS module
444
class GnuTLS(object):
445
"""This isn't so much a class as it is a module-like namespace.
446
It is instantiated once, and simulates having a GnuTLS module."""
447
448
_library = ctypes.cdll.LoadLibrary(
449
ctypes.util.find_library("gnutls"))
450
_need_version = "3.3.0"
451
def __init__(self):
452
# Need to use class name "GnuTLS" here, since this method is
453
# called before the assignment to the "gnutls" global variable
454
# happens.
455
if GnuTLS.check_version(self._need_version) is None:
456
raise GnuTLS.Error("Needs GnuTLS {} or later"
457
.format(self._need_version))
458
518
class gnutls:
519
"""This isn't so much a class as it is a module-like namespace."""
520
521
library = ctypes.util.find_library("gnutls")
522
if library is None:
523
library = ctypes.util.find_library("gnutls-deb0")
524
_library = ctypes.cdll.LoadLibrary(library)
525
del library
526
459
527
# Unless otherwise indicated, the constants and types below are
460
528
# all from the gnutls/gnutls.h C header file.
461
529
462
530
# Constants
463
531
E_SUCCESS = 0
464
532
E_INTERRUPTED = -52
465
533
E_AGAIN = -28
466
534
CRT_OPENPGP = 2
535
CRT_RAWPK = 3
467
536
CLIENT = 2
468
537
SHUT_RDWR = 0
469
538
CRD_CERTIFICATE = 1
470
539
E_NO_CERTIFICATE_FOUND = -49
540
X509_FMT_DER = 0
541
NO_TICKETS = 1<<10
542
ENABLE_RAWPK = 1<<18
543
CTYPE_PEERS = 3
544
KEYID_USE_SHA256 = 1 # gnutls/x509.h
471
545
OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h
472
546
473
547
# Types
474
548
class session_int(ctypes.Structure):
475
549
_fields_ = []
476
550
session_t = ctypes.POINTER(session_int)
551
477
552
class certificate_credentials_st(ctypes.Structure):
478
553
_fields_ = []
479
554
certificate_credentials_t = ctypes.POINTER(
480
555
certificate_credentials_st)
481
556
certificate_type_t = ctypes.c_int
557
482
558
class datum_t(ctypes.Structure):
483
559
_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),
484
560
('size', ctypes.c_uint)]
561
485
562
class openpgp_crt_int(ctypes.Structure):
486
563
_fields_ = []
487
564
openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)
488
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
565
openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h
489
566
log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)
490
credentials_type_t = ctypes.c_int #
567
credentials_type_t = ctypes.c_int
491
568
transport_ptr_t = ctypes.c_void_p
492
569
close_request_t = ctypes.c_int
493
570
494
571
# Exceptions
495
572
class Error(Exception):
496
# We need to use the class name "GnuTLS" here, since this
497
# exception might be raised from within GnuTLS.__init__,
498
# which is called before the assignment to the "gnutls"
499
# global variable has happened.
500
def __init__(self, message = None, code = None, args=()):
573
def __init__(self, message=None, code=None, args=()):
501
574
# Default usage is by a message string, but if a return
502
575
# code is passed, convert it to a string with
503
576
# gnutls.strerror()
504
577
self.code = code
505
578
if message is None and code is not None:
506
message = GnuTLS.strerror(code)
507
return super(GnuTLS.Error, self).__init__(
579
message = gnutls.strerror(code)
580
return super(gnutls.Error, self).__init__(
508
581
message, *args)
509
582
510
583
class CertificateSecurityError(Error):
511
584
pass
512
585
513
586
# Classes
514
class Credentials(object):
587
class Credentials:
515
588
def __init__(self):
516
589
self._c_object = gnutls.certificate_credentials_t()
517
590
gnutls.certificate_allocate_credentials(
518
591
ctypes.byref(self._c_object))
519
592
self.type = gnutls.CRD_CERTIFICATE
520
593
521
594
def __del__(self):
522
595
gnutls.certificate_free_credentials(self._c_object)
523
524
class ClientSession(object):
525
def __init__(self, socket, credentials = None):
596
597
class ClientSession:
598
def __init__(self, socket, credentials=None):
526
599
self._c_object = gnutls.session_t()
527
gnutls.init(ctypes.byref(self._c_object), gnutls.CLIENT)
600
gnutls_flags = gnutls.CLIENT
601
if gnutls.check_version(b"3.5.6"):
602
gnutls_flags |= gnutls.NO_TICKETS
603
if gnutls.has_rawpk:
604
gnutls_flags |= gnutls.ENABLE_RAWPK
605
gnutls.init(ctypes.byref(self._c_object), gnutls_flags)
606
del gnutls_flags
528
607
gnutls.set_default_priority(self._c_object)
529
608
gnutls.transport_set_ptr(self._c_object, socket.fileno())
530
609
gnutls.handshake_set_private_extensions(self._c_object,
536
615
ctypes.cast(credentials._c_object,
537
616
ctypes.c_void_p))
538
617
self.credentials = credentials
539
618
540
619
def __del__(self):
541
620
gnutls.deinit(self._c_object)
542
621
543
622
def handshake(self):
544
623
return gnutls.handshake(self._c_object)
545
624
546
625
def send(self, data):
547
626
data = bytes(data)
548
627
data_len = len(data)
550
629
data_len -= gnutls.record_send(self._c_object,
551
630
data[-data_len:],
552
631
data_len)
553
632
554
633
def bye(self):
555
634
return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)
556
635
557
636
# Error handling functions
558
637
def _error_code(result):
559
638
"""A function to raise exceptions on errors, suitable
561
640
if result >= 0:
562
641
return result
563
642
if result == gnutls.E_NO_CERTIFICATE_FOUND:
564
raise gnutls.CertificateSecurityError(code = result)
565
raise gnutls.Error(code = result)
566
643
raise gnutls.CertificateSecurityError(code=result)
644
raise gnutls.Error(code=result)
645
567
646
def _retry_on_error(result, func, arguments):
568
647
"""A function to retry on some errors, suitable
569
648
for the 'errcheck' attribute on ctypes functions"""
572
651
return _error_code(result)
573
652
result = func(*arguments)
574
653
return result
575
654
576
655
# Unless otherwise indicated, the function declarations below are
577
656
# all from the gnutls/gnutls.h C header file.
578
657
579
658
# Functions
580
659
priority_set_direct = _library.gnutls_priority_set_direct
581
660
priority_set_direct.argtypes = [session_t, ctypes.c_char_p,
582
661
ctypes.POINTER(ctypes.c_char_p)]
583
662
priority_set_direct.restype = _error_code
584
663
585
664
init = _library.gnutls_init
586
665
init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]
587
666
init.restype = _error_code
588
667
589
668
set_default_priority = _library.gnutls_set_default_priority
590
669
set_default_priority.argtypes = [session_t]
591
670
set_default_priority.restype = _error_code
592
671
593
672
record_send = _library.gnutls_record_send
594
673
record_send.argtypes = [session_t, ctypes.c_void_p,
595
674
ctypes.c_size_t]
596
675
record_send.restype = ctypes.c_ssize_t
597
676
record_send.errcheck = _retry_on_error
598
677
599
678
certificate_allocate_credentials = (
600
679
_library.gnutls_certificate_allocate_credentials)
601
680
certificate_allocate_credentials.argtypes = [
602
681
ctypes.POINTER(certificate_credentials_t)]
603
682
certificate_allocate_credentials.restype = _error_code
604
683
605
684
certificate_free_credentials = (
606
685
_library.gnutls_certificate_free_credentials)
607
certificate_free_credentials.argtypes = [certificate_credentials_t]
686
certificate_free_credentials.argtypes = [
687
certificate_credentials_t]
608
688
certificate_free_credentials.restype = None
609
689
610
690
handshake_set_private_extensions = (
611
691
_library.gnutls_handshake_set_private_extensions)
612
692
handshake_set_private_extensions.argtypes = [session_t,
613
693
ctypes.c_int]
614
694
handshake_set_private_extensions.restype = None
615
695
616
696
credentials_set = _library.gnutls_credentials_set
617
697
credentials_set.argtypes = [session_t, credentials_type_t,
618
698
ctypes.c_void_p]
619
699
credentials_set.restype = _error_code
620
700
621
701
strerror = _library.gnutls_strerror
622
702
strerror.argtypes = [ctypes.c_int]
623
703
strerror.restype = ctypes.c_char_p
624
704
625
705
certificate_type_get = _library.gnutls_certificate_type_get
626
706
certificate_type_get.argtypes = [session_t]
627
707
certificate_type_get.restype = _error_code
628
708
629
709
certificate_get_peers = _library.gnutls_certificate_get_peers
630
710
certificate_get_peers.argtypes = [session_t,
631
711
ctypes.POINTER(ctypes.c_uint)]
632
712
certificate_get_peers.restype = ctypes.POINTER(datum_t)
633
713
634
714
global_set_log_level = _library.gnutls_global_set_log_level
635
715
global_set_log_level.argtypes = [ctypes.c_int]
636
716
global_set_log_level.restype = None
637
717
638
718
global_set_log_function = _library.gnutls_global_set_log_function
639
719
global_set_log_function.argtypes = [log_func]
640
720
global_set_log_function.restype = None
641
721
642
722
deinit = _library.gnutls_deinit
643
723
deinit.argtypes = [session_t]
644
724
deinit.restype = None
645
725
646
726
handshake = _library.gnutls_handshake
647
727
handshake.argtypes = [session_t]
648
728
handshake.restype = _error_code
649
729
handshake.errcheck = _retry_on_error
650
730
651
731
transport_set_ptr = _library.gnutls_transport_set_ptr
652
732
transport_set_ptr.argtypes = [session_t, transport_ptr_t]
653
733
transport_set_ptr.restype = None
654
734
655
735
bye = _library.gnutls_bye
656
736
bye.argtypes = [session_t, close_request_t]
657
737
bye.restype = _error_code
658
738
bye.errcheck = _retry_on_error
659
739
660
740
check_version = _library.gnutls_check_version
661
741
check_version.argtypes = [ctypes.c_char_p]
662
742
check_version.restype = ctypes.c_char_p
663
664
# All the function declarations below are from gnutls/openpgp.h
665
666
openpgp_crt_init = _library.gnutls_openpgp_crt_init
667
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
668
openpgp_crt_init.restype = _error_code
669
670
openpgp_crt_import = _library.gnutls_openpgp_crt_import
671
openpgp_crt_import.argtypes = [openpgp_crt_t,
672
ctypes.POINTER(datum_t),
673
openpgp_crt_fmt_t]
674
openpgp_crt_import.restype = _error_code
675
676
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
677
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
678
ctypes.POINTER(ctypes.c_uint)]
679
openpgp_crt_verify_self.restype = _error_code
680
681
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
682
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
683
openpgp_crt_deinit.restype = None
684
685
openpgp_crt_get_fingerprint = (
686
_library.gnutls_openpgp_crt_get_fingerprint)
687
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
688
ctypes.c_void_p,
689
ctypes.POINTER(
690
ctypes.c_size_t)]
691
openpgp_crt_get_fingerprint.restype = _error_code
692
743
744
_need_version = b"3.3.0"
745
if check_version(_need_version) is None:
746
raise self.Error("Needs GnuTLS {} or later"
747
.format(_need_version))
748
749
_tls_rawpk_version = b"3.6.6"
750
has_rawpk = bool(check_version(_tls_rawpk_version))
751
752
if has_rawpk:
753
# Types
754
class pubkey_st(ctypes.Structure):
755
_fields = []
756
pubkey_t = ctypes.POINTER(pubkey_st)
757
758
x509_crt_fmt_t = ctypes.c_int
759
760
# All the function declarations below are from gnutls/abstract.h
761
pubkey_init = _library.gnutls_pubkey_init
762
pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]
763
pubkey_init.restype = _error_code
764
765
pubkey_import = _library.gnutls_pubkey_import
766
pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),
767
x509_crt_fmt_t]
768
pubkey_import.restype = _error_code
769
770
pubkey_get_key_id = _library.gnutls_pubkey_get_key_id
771
pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,
772
ctypes.POINTER(ctypes.c_ubyte),
773
ctypes.POINTER(ctypes.c_size_t)]
774
pubkey_get_key_id.restype = _error_code
775
776
pubkey_deinit = _library.gnutls_pubkey_deinit
777
pubkey_deinit.argtypes = [pubkey_t]
778
pubkey_deinit.restype = None
779
else:
780
# All the function declarations below are from gnutls/openpgp.h
781
782
openpgp_crt_init = _library.gnutls_openpgp_crt_init
783
openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]
784
openpgp_crt_init.restype = _error_code
785
786
openpgp_crt_import = _library.gnutls_openpgp_crt_import
787
openpgp_crt_import.argtypes = [openpgp_crt_t,
788
ctypes.POINTER(datum_t),
789
openpgp_crt_fmt_t]
790
openpgp_crt_import.restype = _error_code
791
792
openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self
793
openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,
794
ctypes.POINTER(ctypes.c_uint)]
795
openpgp_crt_verify_self.restype = _error_code
796
797
openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit
798
openpgp_crt_deinit.argtypes = [openpgp_crt_t]
799
openpgp_crt_deinit.restype = None
800
801
openpgp_crt_get_fingerprint = (
802
_library.gnutls_openpgp_crt_get_fingerprint)
803
openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,
804
ctypes.c_void_p,
805
ctypes.POINTER(
806
ctypes.c_size_t)]
807
openpgp_crt_get_fingerprint.restype = _error_code
808
809
if check_version(b"3.6.4"):
810
certificate_type_get2 = _library.gnutls_certificate_type_get2
811
certificate_type_get2.argtypes = [session_t, ctypes.c_int]
812
certificate_type_get2.restype = _error_code
813
693
814
# Remove non-public functions
694
815
del _error_code, _retry_on_error
695
# Create the global "gnutls" object, simulating a module
696
gnutls = GnuTLS()
816
697
817
698
818
def call_pipe(connection, # : multiprocessing.Connection
699
819
func, *args, **kwargs):
700
820
"""This function is meant to be called by multiprocessing.Process
701
821
702
822
This function runs func(*args, **kwargs), and writes the resulting
703
823
return value on the provided multiprocessing.Connection.
704
824
"""
705
825
connection.send(func(*args, **kwargs))
706
826
connection.close()
707
827
708
class Client(object):
828
829
class Client:
709
830
"""A representation of a client host served by this server.
710
831
711
832
Attributes:
712
833
approved: bool(); 'None' if not yet approved/disapproved
713
834
approval_delay: datetime.timedelta(); Time to wait for approval
714
835
approval_duration: datetime.timedelta(); Duration of one approval
715
checker: subprocess.Popen(); a running checker process used
716
to see if the client lives.
717
'None' if no process is running.
718
checker_callback_tag: a gobject event source tag, or None
836
checker: multiprocessing.Process(); a running checker process used
837
to see if the client lives. 'None' if no process is
838
running.
839
checker_callback_tag: a GLib event source tag, or None
719
840
checker_command: string; External command which is run to check
720
841
if client lives. %() expansions are done at
721
842
runtime with vars(self) as dict, so that for
722
843
instance %(name)s can be used in the command.
723
checker_initiator_tag: a gobject event source tag, or None
844
checker_initiator_tag: a GLib event source tag, or None
724
845
created: datetime.datetime(); (UTC) object creation
725
846
client_structure: Object describing what attributes a client has
726
847
and is used for storing the client at exit
727
848
current_checker_command: string; current running checker_command
728
disable_initiator_tag: a gobject event source tag, or None
849
disable_initiator_tag: a GLib event source tag, or None
729
850
enabled: bool()
730
851
fingerprint: string (40 or 32 hexadecimal digits); used to
731
uniquely identify the client
852
uniquely identify an OpenPGP client
853
key_id: string (64 hexadecimal digits); used to uniquely identify
854
a client using raw public keys
732
855
host: string; available for use by the checker command
733
856
interval: datetime.timedelta(); How often to start a new checker
734
857
last_approval_request: datetime.datetime(); (UTC) or None
750
873
disabled, or None
751
874
server_settings: The server_settings dict from main()
752
875
"""
753
876
754
877
runtime_expansions = ("approval_delay", "approval_duration",
755
"created", "enabled", "expires",
878
"created", "enabled", "expires", "key_id",
756
879
"fingerprint", "host", "interval",
757
880
"last_approval_request", "last_checked_ok",
758
881
"last_enabled", "name", "timeout")
767
890
"approved_by_default": "True",
768
891
"enabled": "True",
769
892
}
770
893
771
894
@staticmethod
772
895
def config_parser(config):
773
896
"""Construct a new dict of client settings of this form:
780
903
for client_name in config.sections():
781
904
section = dict(config.items(client_name))
782
905
client = settings[client_name] = {}
783
906
784
907
client["host"] = section["host"]
785
908
# Reformat values from string types to Python types
786
909
client["approved_by_default"] = config.getboolean(
787
910
client_name, "approved_by_default")
788
911
client["enabled"] = config.getboolean(client_name,
789
912
"enabled")
790
791
# Uppercase and remove spaces from fingerprint for later
792
# comparison purposes with return value from the
793
# fingerprint() function
913
914
# Uppercase and remove spaces from key_id and fingerprint
915
# for later comparison purposes with return value from the
916
# key_id() and fingerprint() functions
917
client["key_id"] = (section.get("key_id", "").upper()
918
.replace(" ", ""))
794
919
client["fingerprint"] = (section["fingerprint"].upper()
795
920
.replace(" ", ""))
796
921
if "secret" in section:
797
client["secret"] = section["secret"].decode("base64")
922
client["secret"] = codecs.decode(section["secret"]
923
.encode("utf-8"),
924
"base64")
798
925
elif "secfile" in section:
799
926
with open(os.path.expanduser(os.path.expandvars
800
927
(section["secfile"])),
815
942
client["last_approval_request"] = None
816
943
client["last_checked_ok"] = None
817
944
client["last_checker_status"] = -2
818
945
819
946
return settings
820
821
def __init__(self, settings, name = None, server_settings=None):
947
948
def __init__(self, settings, name=None, server_settings=None):
822
949
self.name = name
823
950
if server_settings is None:
824
951
server_settings = {}
826
953
# adding all client settings
827
954
for setting, value in settings.items():
828
955
setattr(self, setting, value)
829
956
830
957
if self.enabled:
831
958
if not hasattr(self, "last_enabled"):
832
959
self.last_enabled = datetime.datetime.utcnow()
836
963
else:
837
964
self.last_enabled = None
838
965
self.expires = None
839
966
840
967
logger.debug("Creating client %r", self.name)
968
logger.debug(" Key ID: %s", self.key_id)
841
969
logger.debug(" Fingerprint: %s", self.fingerprint)
842
970
self.created = settings.get("created",
843
971
datetime.datetime.utcnow())
844
972
845
973
# attributes specific for this server instance
846
974
self.checker = None
847
975
self.checker_initiator_tag = None
853
981
self.changedstate = multiprocessing_manager.Condition(
854
982
multiprocessing_manager.Lock())
855
983
self.client_structure = [attr
856
for attr in self.__dict__.iterkeys()
984
for attr in self.__dict__.keys()
857
985
if not attr.startswith("_")]
858
986
self.client_structure.append("client_structure")
859
987
860
988
for name, t in inspect.getmembers(
861
989
type(self), lambda obj: isinstance(obj, property)):
862
990
if not name.startswith("_"):
863
991
self.client_structure.append(name)
864
992
865
993
# Send notice to process children that client state has changed
866
994
def send_changedstate(self):
867
995
with self.changedstate:
868
996
self.changedstate.notify_all()
869
997
870
998
def enable(self):
871
999
"""Start this client's checker and timeout hooks"""
872
1000
if getattr(self, "enabled", False):
877
1005
self.last_enabled = datetime.datetime.utcnow()
878
1006
self.init_checker()
879
1007
self.send_changedstate()
880
1008
881
1009
def disable(self, quiet=True):
882
1010
"""Disable this client."""
883
1011
if not getattr(self, "enabled", False):
885
1013
if not quiet:
886
1014
logger.info("Disabling client %s", self.name)
887
1015
if getattr(self, "disable_initiator_tag", None) is not None:
888
gobject.source_remove(self.disable_initiator_tag)
1016
GLib.source_remove(self.disable_initiator_tag)
889
1017
self.disable_initiator_tag = None
890
1018
self.expires = None
891
1019
if getattr(self, "checker_initiator_tag", None) is not None:
892
gobject.source_remove(self.checker_initiator_tag)
1020
GLib.source_remove(self.checker_initiator_tag)
893
1021
self.checker_initiator_tag = None
894
1022
self.stop_checker()
895
1023
self.enabled = False
896
1024
if not quiet:
897
1025
self.send_changedstate()
898
# Do not run this again if called by a gobject.timeout_add
1026
# Do not run this again if called by a GLib.timeout_add
899
1027
return False
900
1028
901
1029
def __del__(self):
902
1030
self.disable()
903
1031
904
1032
def init_checker(self):
905
1033
# Schedule a new checker to be started an 'interval' from now,
906
1034
# and every interval from then on.
907
1035
if self.checker_initiator_tag is not None:
908
gobject.source_remove(self.checker_initiator_tag)
909
self.checker_initiator_tag = gobject.timeout_add(
1036
GLib.source_remove(self.checker_initiator_tag)
1037
self.checker_initiator_tag = GLib.timeout_add(
910
1038
int(self.interval.total_seconds() * 1000),
911
1039
self.start_checker)
912
1040
# Schedule a disable() when 'timeout' has passed
913
1041
if self.disable_initiator_tag is not None:
914
gobject.source_remove(self.disable_initiator_tag)
915
self.disable_initiator_tag = gobject.timeout_add(
1042
GLib.source_remove(self.disable_initiator_tag)
1043
self.disable_initiator_tag = GLib.timeout_add(
916
1044
int(self.timeout.total_seconds() * 1000), self.disable)
917
1045
# Also start a new checker *right now*.
918
1046
self.start_checker()
919
1047
920
1048
def checker_callback(self, source, condition, connection,
921
1049
command):
922
1050
"""The checker has completed, so take appropriate actions."""
923
self.checker_callback_tag = None
924
self.checker = None
925
1051
# Read return code from connection (see call_pipe)
926
1052
returncode = connection.recv()
927
1053
connection.close()
928
1054
if self.checker is not None:
1055
self.checker.join()
1056
self.checker_callback_tag = None
1057
self.checker = None
1058
929
1059
if returncode >= 0:
930
1060
self.last_checker_status = returncode
931
1061
self.last_checker_signal = None
941
1071
logger.warning("Checker for %(name)s crashed?",
942
1072
vars(self))
943
1073
return False
944
1074
945
1075
def checked_ok(self):
946
1076
"""Assert that the client has been seen, alive and well."""
947
1077
self.last_checked_ok = datetime.datetime.utcnow()
948
1078
self.last_checker_status = 0
949
1079
self.last_checker_signal = None
950
1080
self.bump_timeout()
951
1081
952
1082
def bump_timeout(self, timeout=None):
953
1083
"""Bump up the timeout for this client."""
954
1084
if timeout is None:
955
1085
timeout = self.timeout
956
1086
if self.disable_initiator_tag is not None:
957
gobject.source_remove(self.disable_initiator_tag)
1087
GLib.source_remove(self.disable_initiator_tag)
958
1088
self.disable_initiator_tag = None
959
1089
if getattr(self, "enabled", False):
960
self.disable_initiator_tag = gobject.timeout_add(
1090
self.disable_initiator_tag = GLib.timeout_add(
961
1091
int(timeout.total_seconds() * 1000), self.disable)
962
1092
self.expires = datetime.datetime.utcnow() + timeout
963
1093
964
1094
def need_approval(self):
965
1095
self.last_approval_request = datetime.datetime.utcnow()
966
1096
967
1097
def start_checker(self):
968
1098
"""Start a new checker subprocess if one is not running.
969
1099
970
1100
If a checker already exists, leave it running and do
971
1101
nothing."""
972
1102
# The reason for not killing a running checker is that if we
977
1107
# checkers alone, the checker would have to take more time
978
1108
# than 'timeout' for the client to be disabled, which is as it
979
1109
# should be.
980
1110
981
1111
if self.checker is not None and not self.checker.is_alive():
982
1112
logger.warning("Checker was not alive; joining")
983
1113
self.checker.join()
987
1117
# Escape attributes for the shell
988
1118
escaped_attrs = {
989
1119
attr: re.escape(str(getattr(self, attr)))
990
for attr in self.runtime_expansions }
1120
for attr in self.runtime_expansions}
991
1121
try:
992
1122
command = self.checker_command % escaped_attrs
993
1123
except TypeError as error:
1005
1135
# The exception is when not debugging but nevertheless
1006
1136
# running in the foreground; use the previously
1007
1137
# created wnull.
1008
popen_args = { "close_fds": True,
1009
"shell": True,
1010
"cwd": "/" }
1138
popen_args = {"close_fds": True,
1139
"shell": True,
1140
"cwd": "/"}
1011
1141
if (not self.server_settings["debug"]
1012
1142
and self.server_settings["foreground"]):
1013
1143
popen_args.update({"stdout": wnull,
1014
"stderr": wnull })
1015
pipe = multiprocessing.Pipe(duplex = False)
1144
"stderr": wnull})
1145
pipe = multiprocessing.Pipe(duplex=False)
1016
1146
self.checker = multiprocessing.Process(
1017
target = call_pipe,
1018
args = (pipe[1], subprocess.call, command),
1019
kwargs = popen_args)
1147
target=call_pipe,
1148
args=(pipe[1], subprocess.call, command),
1149
kwargs=popen_args)
1020
1150
self.checker.start()
1021
self.checker_callback_tag = gobject.io_add_watch(
1022
pipe[0].fileno(), gobject.IO_IN,
1151
self.checker_callback_tag = GLib.io_add_watch(
1152
GLib.IOChannel.unix_new(pipe[0].fileno()),
1153
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1023
1154
self.checker_callback, pipe[0], command)
1024
# Re-run this periodically if run by gobject.timeout_add
1155
# Re-run this periodically if run by GLib.timeout_add
1025
1156
return True
1026
1157
1027
1158
def stop_checker(self):
1028
1159
"""Force the checker process, if any, to stop."""
1029
1160
if self.checker_callback_tag:
1030
gobject.source_remove(self.checker_callback_tag)
1161
GLib.source_remove(self.checker_callback_tag)
1031
1162
self.checker_callback_tag = None
1032
1163
if getattr(self, "checker", None) is None:
1033
1164
return
1042
1173
byte_arrays=False):
1043
1174
"""Decorators for marking methods of a DBusObjectWithProperties to
1044
1175
become properties on the D-Bus.
1045
1176
1046
1177
The decorated method will be called with no arguments by "Get"
1047
1178
and with one argument by "Set".
1048
1179
1049
1180
The parameters, where they are supported, are the same as
1050
1181
dbus.service.method, except there is only "signature", since the
1051
1182
type from Get() and the type sent to Set() is the same.
1055
1186
if byte_arrays and signature != "ay":
1056
1187
raise ValueError("Byte arrays not supported for non-'ay'"
1057
1188
" signature {!r}".format(signature))
1058
1189
1059
1190
def decorator(func):
1060
1191
func._dbus_is_property = True
1061
1192
func._dbus_interface = dbus_interface
1064
1195
func._dbus_name = func.__name__
1065
1196
if func._dbus_name.endswith("_dbus_property"):
1066
1197
func._dbus_name = func._dbus_name[:-14]
1067
func._dbus_get_args_options = {'byte_arrays': byte_arrays }
1198
func._dbus_get_args_options = {'byte_arrays': byte_arrays}
1068
1199
return func
1069
1200
1070
1201
return decorator
1071
1202
1072
1203
1073
1204
def dbus_interface_annotations(dbus_interface):
1074
1205
"""Decorator for marking functions returning interface annotations
1075
1206
1076
1207
Usage:
1077
1208
1078
1209
@dbus_interface_annotations("org.example.Interface")
1079
1210
def _foo(self): # Function name does not matter
1080
1211
return {"org.freedesktop.DBus.Deprecated": "true",
1081
1212
"org.freedesktop.DBus.Property.EmitsChangedSignal":
1082
1213
"false"}
1083
1214
"""
1084
1215
1085
1216
def decorator(func):
1086
1217
func._dbus_is_interface = True
1087
1218
func._dbus_interface = dbus_interface
1088
1219
func._dbus_name = dbus_interface
1089
1220
return func
1090
1221
1091
1222
return decorator
1092
1223
1093
1224
1094
1225
def dbus_annotations(annotations):
1095
1226
"""Decorator to annotate D-Bus methods, signals or properties
1096
1227
Usage:
1097
1228
1098
1229
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",
1099
1230
"org.freedesktop.DBus.Property."
1100
1231
"EmitsChangedSignal": "false"})
1102
1233
access="r")
1103
1234
def Property_dbus_property(self):
1104
1235
return dbus.Boolean(False)
1105
1236
1106
1237
See also the DBusObjectWithAnnotations class.
1107
1238
"""
1108
1239
1109
1240
def decorator(func):
1110
1241
func._dbus_annotations = annotations
1111
1242
return func
1112
1243
1113
1244
return decorator
1114
1245
1115
1246
1133
1264
1134
1265
class DBusObjectWithAnnotations(dbus.service.Object):
1135
1266
"""A D-Bus object with annotations.
1136
1267
1137
1268
Classes inheriting from this can use the dbus_annotations
1138
1269
decorator to add annotations to methods or signals.
1139
1270
"""
1140
1271
1141
1272
@staticmethod
1142
1273
def _is_dbus_thing(thing):
1143
1274
"""Returns a function testing if an attribute is a D-Bus thing
1144
1275
1145
1276
If called like _is_dbus_thing("method") it returns a function
1146
1277
suitable for use as predicate to inspect.getmembers().
1147
1278
"""
1148
1279
return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),
1149
1280
False)
1150
1281
1151
1282
def _get_all_dbus_things(self, thing):
1152
1283
"""Returns a generator of (name, attribute) pairs
1153
1284
"""
1156
1287
for cls in self.__class__.__mro__
1157
1288
for name, athing in
1158
1289
inspect.getmembers(cls, self._is_dbus_thing(thing)))
1159
1290
1160
1291
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1161
out_signature = "s",
1162
path_keyword = 'object_path',
1163
connection_keyword = 'connection')
1292
out_signature="s",
1293
path_keyword='object_path',
1294
connection_keyword='connection')
1164
1295
def Introspect(self, object_path, connection):
1165
1296
"""Overloading of standard D-Bus method.
1166
1297
1167
1298
Inserts annotation tags on methods and signals.
1168
1299
"""
1169
1300
xmlstring = dbus.service.Object.Introspect(self, object_path,
1170
1301
connection)
1171
1302
try:
1172
1303
document = xml.dom.minidom.parseString(xmlstring)
1173
1304
1174
1305
for if_tag in document.getElementsByTagName("interface"):
1175
1306
# Add annotation tags
1176
1307
for typ in ("method", "signal"):
1203
1334
if_tag.appendChild(ann_tag)
1204
1335
# Fix argument name for the Introspect method itself
1205
1336
if (if_tag.getAttribute("name")
1206
== dbus.INTROSPECTABLE_IFACE):
1337
== dbus.INTROSPECTABLE_IFACE):
1207
1338
for cn in if_tag.getElementsByTagName("method"):
1208
1339
if cn.getAttribute("name") == "Introspect":
1209
1340
for arg in cn.getElementsByTagName("arg"):
1222
1353
1223
1354
class DBusObjectWithProperties(DBusObjectWithAnnotations):
1224
1355
"""A D-Bus object with properties.
1225
1356
1226
1357
Classes inheriting from this can use the dbus_service_property
1227
1358
decorator to expose methods as D-Bus properties. It exposes the
1228
1359
standard Get(), Set(), and GetAll() methods on the D-Bus.
1229
1360
"""
1230
1361
1231
1362
def _get_dbus_property(self, interface_name, property_name):
1232
1363
"""Returns a bound method if one exists which is a D-Bus
1233
1364
property with the specified name and interface.
1238
1369
if (value._dbus_name == property_name
1239
1370
and value._dbus_interface == interface_name):
1240
1371
return value.__get__(self)
1241
1372
1242
1373
# No such property
1243
1374
raise DBusPropertyNotFound("{}:{}.{}".format(
1244
1375
self.dbus_object_path, interface_name, property_name))
1245
1376
1246
1377
@classmethod
1247
1378
def _get_all_interface_names(cls):
1248
1379
"""Get a sequence of all interfaces supported by an object"""
1251
1382
for x in (inspect.getmro(cls))
1252
1383
for attr in dir(x))
1253
1384
if name is not None)
1254
1385
1255
1386
@dbus.service.method(dbus.PROPERTIES_IFACE,
1256
1387
in_signature="ss",
1257
1388
out_signature="v")
1265
1396
if not hasattr(value, "variant_level"):
1266
1397
return value
1267
1398
return type(value)(value, variant_level=value.variant_level+1)
1268
1399
1269
1400
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
1270
1401
def Set(self, interface_name, property_name, value):
1271
1402
"""Standard D-Bus property Set() method, see D-Bus standard.
1280
1411
raise ValueError("Byte arrays not supported for non-"
1281
1412
"'ay' signature {!r}"
1282
1413
.format(prop._dbus_signature))
1283
value = dbus.ByteArray(b''.join(chr(byte)
1284
for byte in value))
1414
value = dbus.ByteArray(bytes(value))
1285
1415
prop(value)
1286
1416
1287
1417
@dbus.service.method(dbus.PROPERTIES_IFACE,
1288
1418
in_signature="s",
1289
1419
out_signature="a{sv}")
1290
1420
def GetAll(self, interface_name):
1291
1421
"""Standard D-Bus property GetAll() method, see D-Bus
1292
1422
standard.
1293
1423
1294
1424
Note: Will not include properties with access="write".
1295
1425
"""
1296
1426
properties = {}
1307
1437
properties[name] = value
1308
1438
continue
1309
1439
properties[name] = type(value)(
1310
value, variant_level = value.variant_level + 1)
1440
value, variant_level=value.variant_level + 1)
1311
1441
return dbus.Dictionary(properties, signature="sv")
1312
1442
1313
1443
@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
1314
1444
def PropertiesChanged(self, interface_name, changed_properties,
1315
1445
invalidated_properties):
1317
1447
standard.
1318
1448
"""
1319
1449
pass
1320
1450
1321
1451
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1322
1452
out_signature="s",
1323
1453
path_keyword='object_path',
1324
1454
connection_keyword='connection')
1325
1455
def Introspect(self, object_path, connection):
1326
1456
"""Overloading of standard D-Bus method.
1327
1457
1328
1458
Inserts property tags and interface annotation tags.
1329
1459
"""
1330
1460
xmlstring = DBusObjectWithAnnotations.Introspect(self,
1332
1462
connection)
1333
1463
try:
1334
1464
document = xml.dom.minidom.parseString(xmlstring)
1335
1465
1336
1466
def make_tag(document, name, prop):
1337
1467
e = document.createElement("property")
1338
1468
e.setAttribute("name", name)
1339
1469
e.setAttribute("type", prop._dbus_signature)
1340
1470
e.setAttribute("access", prop._dbus_access)
1341
1471
return e
1342
1472
1343
1473
for if_tag in document.getElementsByTagName("interface"):
1344
1474
# Add property tags
1345
1475
for tag in (make_tag(document, name, prop)
1387
1517
exc_info=error)
1388
1518
return xmlstring
1389
1519
1520
1390
1521
try:
1391
1522
dbus.OBJECT_MANAGER_IFACE
1392
1523
except AttributeError:
1393
1524
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
1394
1525
1526
1395
1527
class DBusObjectWithObjectManager(DBusObjectWithAnnotations):
1396
1528
"""A D-Bus object with an ObjectManager.
1397
1529
1398
1530
Classes inheriting from this exposes the standard
1399
1531
GetManagedObjects call and the InterfacesAdded and
1400
1532
InterfacesRemoved signals on the standard
1401
1533
"org.freedesktop.DBus.ObjectManager" interface.
1402
1534
1403
1535
Note: No signals are sent automatically; they must be sent
1404
1536
manually.
1405
1537
"""
1406
1538
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
1407
out_signature = "a{oa{sa{sv}}}")
1539
out_signature="a{oa{sa{sv}}}")
1408
1540
def GetManagedObjects(self):
1409
1541
"""This function must be overridden"""
1410
1542
raise NotImplementedError()
1411
1543
1412
1544
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,
1413
signature = "oa{sa{sv}}")
1545
signature="oa{sa{sv}}")
1414
1546
def InterfacesAdded(self, object_path, interfaces_and_properties):
1415
1547
pass
1416
1417
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature = "oas")
1548
1549
@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")
1418
1550
def InterfacesRemoved(self, object_path, interfaces):
1419
1551
pass
1420
1552
1421
1553
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
1422
out_signature = "s",
1423
path_keyword = 'object_path',
1424
connection_keyword = 'connection')
1554
out_signature="s",
1555
path_keyword='object_path',
1556
connection_keyword='connection')
1425
1557
def Introspect(self, object_path, connection):
1426
1558
"""Overloading of standard D-Bus method.
1427
1559
1428
1560
Override return argument name of GetManagedObjects to be
1429
1561
"objpath_interfaces_and_properties"
1430
1562
"""
1433
1565
connection)
1434
1566
try:
1435
1567
document = xml.dom.minidom.parseString(xmlstring)
1436
1568
1437
1569
for if_tag in document.getElementsByTagName("interface"):
1438
1570
# Fix argument name for the GetManagedObjects method
1439
1571
if (if_tag.getAttribute("name")
1440
== dbus.OBJECT_MANAGER_IFACE):
1572
== dbus.OBJECT_MANAGER_IFACE):
1441
1573
for cn in if_tag.getElementsByTagName("method"):
1442
1574
if (cn.getAttribute("name")
1443
1575
== "GetManagedObjects"):
1453
1585
except (AttributeError, xml.dom.DOMException,
1454
1586
xml.parsers.expat.ExpatError) as error:
1455
1587
logger.error("Failed to override Introspection method",
1456
exc_info = error)
1588
exc_info=error)
1457
1589
return xmlstring
1458
1590
1591
1459
1592
def datetime_to_dbus(dt, variant_level=0):
1460
1593
"""Convert a UTC datetime.datetime() to a D-Bus type."""
1461
1594
if dt is None:
1462
return dbus.String("", variant_level = variant_level)
1595
return dbus.String("", variant_level=variant_level)
1463
1596
return dbus.String(dt.isoformat(), variant_level=variant_level)
1464
1597
1465
1598
1468
1601
dbus.service.Object, it will add alternate D-Bus attributes with
1469
1602
interface names according to the "alt_interface_names" mapping.
1470
1603
Usage:
1471
1604
1472
1605
@alternate_dbus_interfaces({"org.example.Interface":
1473
1606
"net.example.AlternateInterface"})
1474
1607
class SampleDBusObject(dbus.service.Object):
1475
1608
@dbus.service.method("org.example.Interface")
1476
1609
def SampleDBusMethod():
1477
1610
pass
1478
1611
1479
1612
The above "SampleDBusMethod" on "SampleDBusObject" will be
1480
1613
reachable via two interfaces: "org.example.Interface" and
1481
1614
"net.example.AlternateInterface", the latter of which will have
1482
1615
its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to
1483
1616
"true", unless "deprecate" is passed with a False value.
1484
1617
1485
1618
This works for methods and signals, and also for D-Bus properties
1486
1619
(from DBusObjectWithProperties) and interfaces (from the
1487
1620
dbus_interface_annotations decorator).
1488
1621
"""
1489
1622
1490
1623
def wrapper(cls):
1491
1624
for orig_interface_name, alt_interface_name in (
1492
1625
alt_interface_names.items()):
1507
1640
interface_names.add(alt_interface)
1508
1641
# Is this a D-Bus signal?
1509
1642
if getattr(attribute, "_dbus_is_signal", False):
1643
# Extract the original non-method undecorated
1644
# function by black magic
1510
1645
if sys.version_info.major == 2:
1511
# Extract the original non-method undecorated
1512
# function by black magic
1513
1646
nonmethod_func = (dict(
1514
1647
zip(attribute.func_code.co_freevars,
1515
1648
attribute.__closure__))
1516
1649
["func"].cell_contents)
1517
1650
else:
1518
nonmethod_func = attribute
1651
nonmethod_func = (dict(
1652
zip(attribute.__code__.co_freevars,
1653
attribute.__closure__))
1654
["func"].cell_contents)
1519
1655
# Create a new, but exactly alike, function
1520
1656
# object, and decorate it to be a new D-Bus signal
1521
1657
# with the alternate D-Bus interface name
1522
if sys.version_info.major == 2:
1523
new_function = types.FunctionType(
1524
nonmethod_func.func_code,
1525
nonmethod_func.func_globals,
1526
nonmethod_func.func_name,
1527
nonmethod_func.func_defaults,
1528
nonmethod_func.func_closure)
1529
else:
1530
new_function = types.FunctionType(
1531
nonmethod_func.__code__,
1532
nonmethod_func.__globals__,
1533
nonmethod_func.__name__,
1534
nonmethod_func.__defaults__,
1535
nonmethod_func.__closure__)
1658
new_function = copy_function(nonmethod_func)
1536
1659
new_function = (dbus.service.signal(
1537
1660
alt_interface,
1538
1661
attribute._dbus_signature)(new_function))
1542
1665
attribute._dbus_annotations)
1543
1666
except AttributeError:
1544
1667
pass
1668
1545
1669
# Define a creator of a function to call both the
1546
1670
# original and alternate functions, so both the
1547
1671
# original and alternate signals gets sent when
1550
1674
"""This function is a scope container to pass
1551
1675
func1 and func2 to the "call_both" function
1552
1676
outside of its arguments"""
1553
1677
1554
1678
@functools.wraps(func2)
1555
1679
def call_both(*args, **kwargs):
1556
1680
"""This function will emit two D-Bus
1557
1681
signals by calling func1 and func2"""
1558
1682
func1(*args, **kwargs)
1559
1683
func2(*args, **kwargs)
1560
# Make wrapper function look like a D-Bus signal
1684
# Make wrapper function look like a D-Bus
1685
# signal
1561
1686
for name, attr in inspect.getmembers(func2):
1562
1687
if name.startswith("_dbus_"):
1563
1688
setattr(call_both, name, attr)
1564
1689
1565
1690
return call_both
1566
1691
# Create the "call_both" function and add it to
1567
1692
# the class
1577
1702
alt_interface,
1578
1703
attribute._dbus_in_signature,
1579
1704
attribute._dbus_out_signature)
1580
(types.FunctionType(attribute.func_code,
1581
attribute.func_globals,
1582
attribute.func_name,
1583
attribute.func_defaults,
1584
attribute.func_closure)))
1705
(copy_function(attribute)))
1585
1706
# Copy annotations, if any
1586
1707
try:
1587
1708
attr[attrname]._dbus_annotations = dict(
1599
1720
attribute._dbus_access,
1600
1721
attribute._dbus_get_args_options
1601
1722
["byte_arrays"])
1602
(types.FunctionType(
1603
attribute.func_code,
1604
attribute.func_globals,
1605
attribute.func_name,
1606
attribute.func_defaults,
1607
attribute.func_closure)))
1723
(copy_function(attribute)))
1608
1724
# Copy annotations, if any
1609
1725
try:
1610
1726
attr[attrname]._dbus_annotations = dict(
1619
1735
# to the class.
1620
1736
attr[attrname] = (
1621
1737
dbus_interface_annotations(alt_interface)
1622
(types.FunctionType(attribute.func_code,
1623
attribute.func_globals,
1624
attribute.func_name,
1625
attribute.func_defaults,
1626
attribute.func_closure)))
1738
(copy_function(attribute)))
1627
1739
if deprecate:
1628
1740
# Deprecate all alternate interfaces
1629
iname="_AlternateDBusNames_interface_annotation{}"
1741
iname = "_AlternateDBusNames_interface_annotation{}"
1630
1742
for interface_name in interface_names:
1631
1743
1632
1744
@dbus_interface_annotations(interface_name)
1633
1745
def func(self):
1634
return { "org.freedesktop.DBus.Deprecated":
1635
"true" }
1746
return {"org.freedesktop.DBus.Deprecated":
1747
"true"}
1636
1748
# Find an unused name
1637
1749
for aname in (iname.format(i)
1638
1750
for i in itertools.count()):
1642
1754
if interface_names:
1643
1755
# Replace the class with a new subclass of it with
1644
1756
# methods, signals, etc. as created above.
1645
cls = type(b"{}Alternate".format(cls.__name__),
1646
(cls, ), attr)
1757
if sys.version_info.major == 2:
1758
cls = type(b"{}Alternate".format(cls.__name__),
1759
(cls, ), attr)
1760
else:
1761
cls = type("{}Alternate".format(cls.__name__),
1762
(cls, ), attr)
1647
1763
return cls
1648
1764
1649
1765
return wrapper
1650
1766
1651
1767
1653
1769
"se.bsnet.fukt.Mandos"})
1654
1770
class ClientDBus(Client, DBusObjectWithProperties):
1655
1771
"""A Client class using D-Bus
1656
1772
1657
1773
Attributes:
1658
1774
dbus_object_path: dbus.ObjectPath
1659
1775
bus: dbus.SystemBus()
1660
1776
"""
1661
1777
1662
1778
runtime_expansions = (Client.runtime_expansions
1663
1779
+ ("dbus_object_path", ))
1664
1780
1665
1781
_interface = "se.recompile.Mandos.Client"
1666
1782
1667
1783
# dbus.service.Object doesn't use super(), so we can't either.
1668
1669
def __init__(self, bus = None, *args, **kwargs):
1784
1785
def __init__(self, bus=None, *args, **kwargs):
1670
1786
self.bus = bus
1671
1787
Client.__init__(self, *args, **kwargs)
1672
1788
# Only now, when this client is initialized, can it show up on
1678
1794
"/clients/" + client_object_name)
1679
1795
DBusObjectWithProperties.__init__(self, self.bus,
1680
1796
self.dbus_object_path)
1681
1797
1682
1798
def notifychangeproperty(transform_func, dbus_name,
1683
1799
type_func=lambda x: x,
1684
1800
variant_level=1,
1686
1802
_interface=_interface):
1687
1803
""" Modify a variable so that it's a property which announces
1688
1804
its changes to DBus.
1689
1805
1690
1806
transform_fun: Function that takes a value and a variant_level
1691
1807
and transforms it to a D-Bus type.
1692
1808
dbus_name: D-Bus name of the variable
1695
1811
variant_level: D-Bus variant level. Default: 1
1696
1812
"""
1697
1813
attrname = "_{}".format(dbus_name)
1698
1814
1699
1815
def setter(self, value):
1700
1816
if hasattr(self, "dbus_object_path"):
1701
1817
if (not hasattr(self, attrname) or
1708
1824
else:
1709
1825
dbus_value = transform_func(
1710
1826
type_func(value),
1711
variant_level = variant_level)
1827
variant_level=variant_level)
1712
1828
self.PropertyChanged(dbus.String(dbus_name),
1713
1829
dbus_value)
1714
1830
self.PropertiesChanged(
1715
1831
_interface,
1716
dbus.Dictionary({ dbus.String(dbus_name):
1717
dbus_value }),
1832
dbus.Dictionary({dbus.String(dbus_name):
1833
dbus_value}),
1718
1834
dbus.Array())
1719
1835
setattr(self, attrname, value)
1720
1836
1721
1837
return property(lambda self: getattr(self, attrname), setter)
1722
1838
1723
1839
expires = notifychangeproperty(datetime_to_dbus, "Expires")
1724
1840
approvals_pending = notifychangeproperty(dbus.Boolean,
1725
1841
"ApprovalPending",
1726
type_func = bool)
1842
type_func=bool)
1727
1843
enabled = notifychangeproperty(dbus.Boolean, "Enabled")
1728
1844
last_enabled = notifychangeproperty(datetime_to_dbus,
1729
1845
"LastEnabled")
1730
1846
checker = notifychangeproperty(
1731
1847
dbus.Boolean, "CheckerRunning",
1732
type_func = lambda checker: checker is not None)
1848
type_func=lambda checker: checker is not None)
1733
1849
last_checked_ok = notifychangeproperty(datetime_to_dbus,
1734
1850
"LastCheckedOK")
1735
1851
last_checker_status = notifychangeproperty(dbus.Int16,
1740
1856
"ApprovedByDefault")
1741
1857
approval_delay = notifychangeproperty(
1742
1858
dbus.UInt64, "ApprovalDelay",
1743
type_func = lambda td: td.total_seconds() * 1000)
1859
type_func=lambda td: td.total_seconds() * 1000)
1744
1860
approval_duration = notifychangeproperty(
1745
1861
dbus.UInt64, "ApprovalDuration",
1746
type_func = lambda td: td.total_seconds() * 1000)
1862
type_func=lambda td: td.total_seconds() * 1000)
1747
1863
host = notifychangeproperty(dbus.String, "Host")
1748
1864
timeout = notifychangeproperty(
1749
1865
dbus.UInt64, "Timeout",
1750
type_func = lambda td: td.total_seconds() * 1000)
1866
type_func=lambda td: td.total_seconds() * 1000)
1751
1867
extended_timeout = notifychangeproperty(
1752
1868
dbus.UInt64, "ExtendedTimeout",
1753
type_func = lambda td: td.total_seconds() * 1000)
1869
type_func=lambda td: td.total_seconds() * 1000)
1754
1870
interval = notifychangeproperty(
1755
1871
dbus.UInt64, "Interval",
1756
type_func = lambda td: td.total_seconds() * 1000)
1872
type_func=lambda td: td.total_seconds() * 1000)
1757
1873
checker_command = notifychangeproperty(dbus.String, "Checker")
1758
1874
secret = notifychangeproperty(dbus.ByteArray, "Secret",
1759
1875
invalidate_only=True)
1760
1876
1761
1877
del notifychangeproperty
1762
1878
1763
1879
def __del__(self, *args, **kwargs):
1764
1880
try:
1765
1881
self.remove_from_connection()
1768
1884
if hasattr(DBusObjectWithProperties, "__del__"):
1769
1885
DBusObjectWithProperties.__del__(self, *args, **kwargs)
1770
1886
Client.__del__(self, *args, **kwargs)
1771
1887
1772
1888
def checker_callback(self, source, condition,
1773
1889
connection, command, *args, **kwargs):
1774
1890
ret = Client.checker_callback(self, source, condition,
1790
1906
| self.last_checker_signal),
1791
1907
dbus.String(command))
1792
1908
return ret
1793
1909
1794
1910
def start_checker(self, *args, **kwargs):
1795
1911
old_checker_pid = getattr(self.checker, "pid", None)
1796
1912
r = Client.start_checker(self, *args, **kwargs)
1800
1916
# Emit D-Bus signal
1801
1917
self.CheckerStarted(self.current_checker_command)
1802
1918
return r
1803
1919
1804
1920
def _reset_approved(self):
1805
1921
self.approved = None
1806
1922
return False
1807
1923
1808
1924
def approve(self, value=True):
1809
1925
self.approved = value
1810
gobject.timeout_add(int(self.approval_duration.total_seconds()
1811
* 1000), self._reset_approved)
1926
GLib.timeout_add(int(self.approval_duration.total_seconds()
1927
* 1000), self._reset_approved)
1812
1928
self.send_changedstate()
1813
1814
## D-Bus methods, signals & properties
1815
1816
## Interfaces
1817
1818
## Signals
1819
1929
1930
# D-Bus methods, signals & properties
1931
1932
# Interfaces
1933
1934
# Signals
1935
1820
1936
# CheckerCompleted - signal
1821
1937
@dbus.service.signal(_interface, signature="nxs")
1822
1938
def CheckerCompleted(self, exitcode, waitstatus, command):
1823
1939
"D-Bus signal"
1824
1940
pass
1825
1941
1826
1942
# CheckerStarted - signal
1827
1943
@dbus.service.signal(_interface, signature="s")
1828
1944
def CheckerStarted(self, command):
1829
1945
"D-Bus signal"
1830
1946
pass
1831
1947
1832
1948
# PropertyChanged - signal
1833
1949
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1834
1950
@dbus.service.signal(_interface, signature="sv")
1835
1951
def PropertyChanged(self, property, value):
1836
1952
"D-Bus signal"
1837
1953
pass
1838
1954
1839
1955
# GotSecret - signal
1840
1956
@dbus.service.signal(_interface)
1841
1957
def GotSecret(self):
1844
1960
server to mandos-client
1845
1961
"""
1846
1962
pass
1847
1963
1848
1964
# Rejected - signal
1849
1965
@dbus.service.signal(_interface, signature="s")
1850
1966
def Rejected(self, reason):
1851
1967
"D-Bus signal"
1852
1968
pass
1853
1969
1854
1970
# NeedApproval - signal
1855
1971
@dbus.service.signal(_interface, signature="tb")
1856
1972
def NeedApproval(self, timeout, default):
1857
1973
"D-Bus signal"
1858
1974
return self.need_approval()
1859
1860
## Methods
1861
1975
1976
# Methods
1977
1862
1978
# Approve - method
1863
1979
@dbus.service.method(_interface, in_signature="b")
1864
1980
def Approve(self, value):
1865
1981
self.approve(value)
1866
1982
1867
1983
# CheckedOK - method
1868
1984
@dbus.service.method(_interface)
1869
1985
def CheckedOK(self):
1870
1986
self.checked_ok()
1871
1987
1872
1988
# Enable - method
1873
1989
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1874
1990
@dbus.service.method(_interface)
1875
1991
def Enable(self):
1876
1992
"D-Bus method"
1877
1993
self.enable()
1878
1994
1879
1995
# StartChecker - method
1880
1996
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1881
1997
@dbus.service.method(_interface)
1882
1998
def StartChecker(self):
1883
1999
"D-Bus method"
1884
2000
self.start_checker()
1885
2001
1886
2002
# Disable - method
1887
2003
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1888
2004
@dbus.service.method(_interface)
1889
2005
def Disable(self):
1890
2006
"D-Bus method"
1891
2007
self.disable()
1892
2008
1893
2009
# StopChecker - method
1894
2010
@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})
1895
2011
@dbus.service.method(_interface)
1896
2012
def StopChecker(self):
1897
2013
self.stop_checker()
1898
1899
## Properties
1900
2014
2015
# Properties
2016
1901
2017
# ApprovalPending - property
1902
2018
@dbus_service_property(_interface, signature="b", access="read")
1903
2019
def ApprovalPending_dbus_property(self):
1904
2020
return dbus.Boolean(bool(self.approvals_pending))
1905
2021
1906
2022
# ApprovedByDefault - property
1907
2023
@dbus_service_property(_interface,
1908
2024
signature="b",
1911
2027
if value is None: # get
1912
2028
return dbus.Boolean(self.approved_by_default)
1913
2029
self.approved_by_default = bool(value)
1914
2030
1915
2031
# ApprovalDelay - property
1916
2032
@dbus_service_property(_interface,
1917
2033
signature="t",
1921
2037
return dbus.UInt64(self.approval_delay.total_seconds()
1922
2038
* 1000)
1923
2039
self.approval_delay = datetime.timedelta(0, 0, 0, value)
1924
2040
1925
2041
# ApprovalDuration - property
1926
2042
@dbus_service_property(_interface,
1927
2043
signature="t",
1931
2047
return dbus.UInt64(self.approval_duration.total_seconds()
1932
2048
* 1000)
1933
2049
self.approval_duration = datetime.timedelta(0, 0, 0, value)
1934
2050
1935
2051
# Name - property
1936
2052
@dbus_annotations(
1937
2053
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1938
2054
@dbus_service_property(_interface, signature="s", access="read")
1939
2055
def Name_dbus_property(self):
1940
2056
return dbus.String(self.name)
1941
2057
2058
# KeyID - property
2059
@dbus_annotations(
2060
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
2061
@dbus_service_property(_interface, signature="s", access="read")
2062
def KeyID_dbus_property(self):
2063
return dbus.String(self.key_id)
2064
1942
2065
# Fingerprint - property
1943
2066
@dbus_annotations(
1944
2067
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1945
2068
@dbus_service_property(_interface, signature="s", access="read")
1946
2069
def Fingerprint_dbus_property(self):
1947
2070
return dbus.String(self.fingerprint)
1948
2071
1949
2072
# Host - property
1950
2073
@dbus_service_property(_interface,
1951
2074
signature="s",
1954
2077
if value is None: # get
1955
2078
return dbus.String(self.host)
1956
2079
self.host = str(value)
1957
2080
1958
2081
# Created - property
1959
2082
@dbus_annotations(
1960
2083
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})
1961
2084
@dbus_service_property(_interface, signature="s", access="read")
1962
2085
def Created_dbus_property(self):
1963
2086
return datetime_to_dbus(self.created)
1964
2087
1965
2088
# LastEnabled - property
1966
2089
@dbus_service_property(_interface, signature="s", access="read")
1967
2090
def LastEnabled_dbus_property(self):
1968
2091
return datetime_to_dbus(self.last_enabled)
1969
2092
1970
2093
# Enabled - property
1971
2094
@dbus_service_property(_interface,
1972
2095
signature="b",
1978
2101
self.enable()
1979
2102
else:
1980
2103
self.disable()
1981
2104
1982
2105
# LastCheckedOK - property
1983
2106
@dbus_service_property(_interface,
1984
2107
signature="s",
1988
2111
self.checked_ok()
1989
2112
return
1990
2113
return datetime_to_dbus(self.last_checked_ok)
1991
2114
1992
2115
# LastCheckerStatus - property
1993
2116
@dbus_service_property(_interface, signature="n", access="read")
1994
2117
def LastCheckerStatus_dbus_property(self):
1995
2118
return dbus.Int16(self.last_checker_status)
1996
2119
1997
2120
# Expires - property
1998
2121
@dbus_service_property(_interface, signature="s", access="read")
1999
2122
def Expires_dbus_property(self):
2000
2123
return datetime_to_dbus(self.expires)
2001
2124
2002
2125
# LastApprovalRequest - property
2003
2126
@dbus_service_property(_interface, signature="s", access="read")
2004
2127
def LastApprovalRequest_dbus_property(self):
2005
2128
return datetime_to_dbus(self.last_approval_request)
2006
2129
2007
2130
# Timeout - property
2008
2131
@dbus_service_property(_interface,
2009
2132
signature="t",
2024
2147
if (getattr(self, "disable_initiator_tag", None)
2025
2148
is None):
2026
2149
return
2027
gobject.source_remove(self.disable_initiator_tag)
2028
self.disable_initiator_tag = gobject.timeout_add(
2150
GLib.source_remove(self.disable_initiator_tag)
2151
self.disable_initiator_tag = GLib.timeout_add(
2029
2152
int((self.expires - now).total_seconds() * 1000),
2030
2153
self.disable)
2031
2154
2032
2155
# ExtendedTimeout - property
2033
2156
@dbus_service_property(_interface,
2034
2157
signature="t",
2038
2161
return dbus.UInt64(self.extended_timeout.total_seconds()
2039
2162
* 1000)
2040
2163
self.extended_timeout = datetime.timedelta(0, 0, 0, value)
2041
2164
2042
2165
# Interval - property
2043
2166
@dbus_service_property(_interface,
2044
2167
signature="t",
2051
2174
return
2052
2175
if self.enabled:
2053
2176
# Reschedule checker run
2054
gobject.source_remove(self.checker_initiator_tag)
2055
self.checker_initiator_tag = gobject.timeout_add(
2177
GLib.source_remove(self.checker_initiator_tag)
2178
self.checker_initiator_tag = GLib.timeout_add(
2056
2179
value, self.start_checker)
2057
self.start_checker() # Start one now, too
2058
2180
self.start_checker() # Start one now, too
2181
2059
2182
# Checker - property
2060
2183
@dbus_service_property(_interface,
2061
2184
signature="s",
2064
2187
if value is None: # get
2065
2188
return dbus.String(self.checker_command)
2066
2189
self.checker_command = str(value)
2067
2190
2068
2191
# CheckerRunning - property
2069
2192
@dbus_service_property(_interface,
2070
2193
signature="b",
2076
2199
self.start_checker()
2077
2200
else:
2078
2201
self.stop_checker()
2079
2202
2080
2203
# ObjectPath - property
2081
2204
@dbus_annotations(
2082
2205
{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",
2083
2206
"org.freedesktop.DBus.Deprecated": "true"})
2084
2207
@dbus_service_property(_interface, signature="o", access="read")
2085
2208
def ObjectPath_dbus_property(self):
2086
return self.dbus_object_path # is already a dbus.ObjectPath
2087
2209
return self.dbus_object_path # is already a dbus.ObjectPath
2210
2088
2211
# Secret = property
2089
2212
@dbus_annotations(
2090
2213
{"org.freedesktop.DBus.Property.EmitsChangedSignal":
2095
2218
byte_arrays=True)
2096
2219
def Secret_dbus_property(self, value):
2097
2220
self.secret = bytes(value)
2098
2221
2099
2222
del _interface
2100
2223
2101
2224
2102
class ProxyClient(object):
2103
def __init__(self, child_pipe, fpr, address):
2225
class ProxyClient:
2226
def __init__(self, child_pipe, key_id, fpr, address):
2104
2227
self._pipe = child_pipe
2105
self._pipe.send(('init', fpr, address))
2228
self._pipe.send(('init', key_id, fpr, address))
2106
2229
if not self._pipe.recv():
2107
raise KeyError(fpr)
2108
2230
raise KeyError(key_id or fpr)
2231
2109
2232
def __getattribute__(self, name):
2110
2233
if name == '_pipe':
2111
2234
return super(ProxyClient, self).__getattribute__(name)
2114
2237
if data[0] == 'data':
2115
2238
return data[1]
2116
2239
if data[0] == 'function':
2117
2240
2118
2241
def func(*args, **kwargs):
2119
2242
self._pipe.send(('funcall', name, args, kwargs))
2120
2243
return self._pipe.recv()[1]
2121
2244
2122
2245
return func
2123
2246
2124
2247
def __setattr__(self, name, value):
2125
2248
if name == '_pipe':
2126
2249
return super(ProxyClient, self).__setattr__(name, value)
2129
2252
2130
2253
class ClientHandler(socketserver.BaseRequestHandler, object):
2131
2254
"""A class to handle client connections.
2132
2255
2133
2256
Instantiated once for each connection to handle it.
2134
2257
Note: This will run in its own forked process."""
2135
2258
2136
2259
def handle(self):
2137
2260
with contextlib.closing(self.server.child_pipe) as child_pipe:
2138
2261
logger.info("TCP connection from: %s",
2139
2262
str(self.client_address))
2140
2263
logger.debug("Pipe FD: %d",
2141
2264
self.server.child_pipe.fileno())
2142
2265
2143
2266
session = gnutls.ClientSession(self.request)
2144
2145
#priority = ':'.join(("NONE", "+VERS-TLS1.1",
2146
# "+AES-256-CBC", "+SHA1",
2147
# "+COMP-NULL", "+CTYPE-OPENPGP",
2148
# "+DHE-DSS"))
2267
2268
# priority = ':'.join(("NONE", "+VERS-TLS1.1",
2269
# "+AES-256-CBC", "+SHA1",
2270
# "+COMP-NULL", "+CTYPE-OPENPGP",
2271
# "+DHE-DSS"))
2149
2272
# Use a fallback default, since this MUST be set.
2150
2273
priority = self.server.gnutls_priority
2151
2274
if priority is None:
2152
2275
priority = "NORMAL"
2153
gnutls.priority_set_direct(session._c_object, priority,
2276
gnutls.priority_set_direct(session._c_object,
2277
priority.encode("utf-8"),
2154
2278
None)
2155
2279
2156
2280
# Start communication using the Mandos protocol
2157
2281
# Get protocol number
2158
2282
line = self.request.makefile().readline()
2163
2287
except (ValueError, IndexError, RuntimeError) as error:
2164
2288
logger.error("Unknown protocol version: %s", error)
2165
2289
return
2166
2290
2167
2291
# Start GnuTLS connection
2168
2292
try:
2169
2293
session.handshake()
2173
2297
# established. Just abandon the request.
2174
2298
return
2175
2299
logger.debug("Handshake succeeded")
2176
2300
2177
2301
approval_required = False
2178
2302
try:
2179
try:
2180
fpr = self.fingerprint(
2181
self.peer_certificate(session))
2182
except (TypeError, gnutls.Error) as error:
2183
logger.warning("Bad certificate: %s", error)
2184
return
2185
logger.debug("Fingerprint: %s", fpr)
2186
2187
try:
2188
client = ProxyClient(child_pipe, fpr,
2303
if gnutls.has_rawpk:
2304
fpr = b""
2305
try:
2306
key_id = self.key_id(
2307
self.peer_certificate(session))
2308
except (TypeError, gnutls.Error) as error:
2309
logger.warning("Bad certificate: %s", error)
2310
return
2311
logger.debug("Key ID: %s", key_id)
2312
2313
else:
2314
key_id = b""
2315
try:
2316
fpr = self.fingerprint(
2317
self.peer_certificate(session))
2318
except (TypeError, gnutls.Error) as error:
2319
logger.warning("Bad certificate: %s", error)
2320
return
2321
logger.debug("Fingerprint: %s", fpr)
2322
2323
try:
2324
client = ProxyClient(child_pipe, key_id, fpr,
2189
2325
self.client_address)
2190
2326
except KeyError:
2191
2327
return
2192
2328
2193
2329
if client.approval_delay:
2194
2330
delay = client.approval_delay
2195
2331
client.approvals_pending += 1
2196
2332
approval_required = True
2197
2333
2198
2334
while True:
2199
2335
if not client.enabled:
2200
2336
logger.info("Client %s is disabled",
2203
2339
# Emit D-Bus signal
2204
2340
client.Rejected("Disabled")
2205
2341
return
2206
2342
2207
2343
if client.approved or not client.approval_delay:
2208
#We are approved or approval is disabled
2344
# We are approved or approval is disabled
2209
2345
break
2210
2346
elif client.approved is None:
2211
2347
logger.info("Client %s needs approval",
2222
2358
# Emit D-Bus signal
2223
2359
client.Rejected("Denied")
2224
2360
return
2225
2226
#wait until timeout or approved
2361
2362
# wait until timeout or approved
2227
2363
time = datetime.datetime.now()
2228
2364
client.changedstate.acquire()
2229
2365
client.changedstate.wait(delay.total_seconds())
2242
2378
break
2243
2379
else:
2244
2380
delay -= time2 - time
2245
2381
2246
2382
try:
2247
2383
session.send(client.secret)
2248
2384
except gnutls.Error as error:
2249
2385
logger.warning("gnutls send failed",
2250
exc_info = error)
2386
exc_info=error)
2251
2387
return
2252
2388
2253
2389
logger.info("Sending secret to %s", client.name)
2254
2390
# bump the timeout using extended_timeout
2255
2391
client.bump_timeout(client.extended_timeout)
2256
2392
if self.server.use_dbus:
2257
2393
# Emit D-Bus signal
2258
2394
client.GotSecret()
2259
2395
2260
2396
finally:
2261
2397
if approval_required:
2262
2398
client.approvals_pending -= 1
2265
2401
except gnutls.Error as error:
2266
2402
logger.warning("GnuTLS bye failed",
2267
2403
exc_info=error)
2268
2404
2269
2405
@staticmethod
2270
2406
def peer_certificate(session):
2271
"Return the peer's OpenPGP certificate as a bytestring"
2272
# If not an OpenPGP certificate...
2273
if (gnutls.certificate_type_get(session._c_object)
2274
!= gnutls.CRT_OPENPGP):
2407
"Return the peer's certificate as a bytestring"
2408
try:
2409
cert_type = gnutls.certificate_type_get2(session._c_object,
2410
gnutls.CTYPE_PEERS)
2411
except AttributeError:
2412
cert_type = gnutls.certificate_type_get(session._c_object)
2413
if gnutls.has_rawpk:
2414
valid_cert_types = frozenset((gnutls.CRT_RAWPK,))
2415
else:
2416
valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))
2417
# If not a valid certificate type...
2418
if cert_type not in valid_cert_types:
2419
logger.info("Cert type %r not in %r", cert_type,
2420
valid_cert_types)
2275
2421
# ...return invalid data
2276
2422
return b""
2277
2423
list_size = ctypes.c_uint(1)
2283
2429
return None
2284
2430
cert = cert_list[0]
2285
2431
return ctypes.string_at(cert.data, cert.size)
2286
2432
2433
@staticmethod
2434
def key_id(certificate):
2435
"Convert a certificate bytestring to a hexdigit key ID"
2436
# New GnuTLS "datum" with the public key
2437
datum = gnutls.datum_t(
2438
ctypes.cast(ctypes.c_char_p(certificate),
2439
ctypes.POINTER(ctypes.c_ubyte)),
2440
ctypes.c_uint(len(certificate)))
2441
# XXX all these need to be created in the gnutls "module"
2442
# New empty GnuTLS certificate
2443
pubkey = gnutls.pubkey_t()
2444
gnutls.pubkey_init(ctypes.byref(pubkey))
2445
# Import the raw public key into the certificate
2446
gnutls.pubkey_import(pubkey,
2447
ctypes.byref(datum),
2448
gnutls.X509_FMT_DER)
2449
# New buffer for the key ID
2450
buf = ctypes.create_string_buffer(32)
2451
buf_len = ctypes.c_size_t(len(buf))
2452
# Get the key ID from the raw public key into the buffer
2453
gnutls.pubkey_get_key_id(pubkey,
2454
gnutls.KEYID_USE_SHA256,
2455
ctypes.cast(ctypes.byref(buf),
2456
ctypes.POINTER(ctypes.c_ubyte)),
2457
ctypes.byref(buf_len))
2458
# Deinit the certificate
2459
gnutls.pubkey_deinit(pubkey)
2460
2461
# Convert the buffer to a Python bytestring
2462
key_id = ctypes.string_at(buf, buf_len.value)
2463
# Convert the bytestring to hexadecimal notation
2464
hex_key_id = binascii.hexlify(key_id).upper()
2465
return hex_key_id
2466
2287
2467
@staticmethod
2288
2468
def fingerprint(openpgp):
2289
2469
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
2304
2484
ctypes.byref(crtverify))
2305
2485
if crtverify.value != 0:
2306
2486
gnutls.openpgp_crt_deinit(crt)
2307
raise gnutls.CertificateSecurityError("Verify failed")
2487
raise gnutls.CertificateSecurityError(code
2488
=crtverify.value)
2308
2489
# New buffer for the fingerprint
2309
2490
buf = ctypes.create_string_buffer(20)
2310
2491
buf_len = ctypes.c_size_t()
2320
2501
return hex_fpr
2321
2502
2322
2503
2323
class MultiprocessingMixIn(object):
2504
class MultiprocessingMixIn:
2324
2505
"""Like socketserver.ThreadingMixIn, but with multiprocessing"""
2325
2506
2326
2507
def sub_process_main(self, request, address):
2327
2508
try:
2328
2509
self.finish_request(request, address)
2329
2510
except Exception:
2330
2511
self.handle_error(request, address)
2331
2512
self.close_request(request)
2332
2513
2333
2514
def process_request(self, request, address):
2334
2515
"""Start a new process to process the request."""
2335
proc = multiprocessing.Process(target = self.sub_process_main,
2336
args = (request, address))
2516
proc = multiprocessing.Process(target=self.sub_process_main,
2517
args=(request, address))
2337
2518
proc.start()
2338
2519
return proc
2339
2520
2340
2521
2341
class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):
2522
class MultiprocessingMixInWithPipe(MultiprocessingMixIn):
2342
2523
""" adds a pipe to the MixIn """
2343
2524
2344
2525
def process_request(self, request, client_address):
2345
2526
"""Overrides and wraps the original process_request().
2346
2527
2347
2528
This function creates a new pipe in self.pipe
2348
2529
"""
2349
2530
parent_pipe, self.child_pipe = multiprocessing.Pipe()
2350
2531
2351
2532
proc = MultiprocessingMixIn.process_request(self, request,
2352
2533
client_address)
2353
2534
self.child_pipe.close()
2354
2535
self.add_pipe(parent_pipe, proc)
2355
2536
2356
2537
def add_pipe(self, parent_pipe, proc):
2357
2538
"""Dummy function; override as necessary"""
2358
2539
raise NotImplementedError()
2359
2540
2360
2541
2361
2542
class IPv6_TCPServer(MultiprocessingMixInWithPipe,
2362
socketserver.TCPServer, object):
2543
socketserver.TCPServer):
2363
2544
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
2364
2545
2365
2546
Attributes:
2366
2547
enabled: Boolean; whether this server is activated yet
2367
2548
interface: None or a network interface name (string)
2368
2549
use_ipv6: Boolean; to use IPv6 or not
2369
2550
"""
2370
2551
2371
2552
def __init__(self, server_address, RequestHandlerClass,
2372
2553
interface=None,
2373
2554
use_ipv6=True,
2383
2564
self.socketfd = socketfd
2384
2565
# Save the original socket.socket() function
2385
2566
self.socket_socket = socket.socket
2567
2386
2568
# To implement --socket, we monkey patch socket.socket.
2387
#
2569
#
2388
2570
# (When socketserver.TCPServer is a new-style class, we
2389
2571
# could make self.socket into a property instead of monkey
2390
2572
# patching socket.socket.)
2391
#
2573
#
2392
2574
# Create a one-time-only replacement for socket.socket()
2393
2575
@functools.wraps(socket.socket)
2394
2576
def socket_wrapper(*args, **kwargs):
2406
2588
# socket_wrapper(), if socketfd was set.
2407
2589
socketserver.TCPServer.__init__(self, server_address,
2408
2590
RequestHandlerClass)
2409
2591
2410
2592
def server_bind(self):
2411
2593
"""This overrides the normal server_bind() function
2412
2594
to bind to an interface if one was specified, and also NOT to
2413
2595
bind to an address or port if they were not specified."""
2596
global SO_BINDTODEVICE
2414
2597
if self.interface is not None:
2415
2598
if SO_BINDTODEVICE is None:
2416
logger.error("SO_BINDTODEVICE does not exist;"
2417
" cannot bind to interface %s",
2418
self.interface)
2419
else:
2420
try:
2421
self.socket.setsockopt(
2422
socket.SOL_SOCKET, SO_BINDTODEVICE,
2423
(self.interface + "\0").encode("utf-8"))
2424
except socket.error as error:
2425
if error.errno == errno.EPERM:
2426
logger.error("No permission to bind to"
2427
" interface %s", self.interface)
2428
elif error.errno == errno.ENOPROTOOPT:
2429
logger.error("SO_BINDTODEVICE not available;"
2430
" cannot bind to interface %s",
2431
self.interface)
2432
elif error.errno == errno.ENODEV:
2433
logger.error("Interface %s does not exist,"
2434
" cannot bind", self.interface)
2435
else:
2436
raise
2599
# Fall back to a hard-coded value which seems to be
2600
# common enough.
2601
logger.warning("SO_BINDTODEVICE not found, trying 25")
2602
SO_BINDTODEVICE = 25
2603
try:
2604
self.socket.setsockopt(
2605
socket.SOL_SOCKET, SO_BINDTODEVICE,
2606
(self.interface + "\0").encode("utf-8"))
2607
except socket.error as error:
2608
if error.errno == errno.EPERM:
2609
logger.error("No permission to bind to"
2610
" interface %s", self.interface)
2611
elif error.errno == errno.ENOPROTOOPT:
2612
logger.error("SO_BINDTODEVICE not available;"
2613
" cannot bind to interface %s",
2614
self.interface)
2615
elif error.errno == errno.ENODEV:
2616
logger.error("Interface %s does not exist,"
2617
" cannot bind", self.interface)
2618
else:
2619
raise
2437
2620
# Only bind(2) the socket if we really need to.
2438
2621
if self.server_address[0] or self.server_address[1]:
2622
if self.server_address[1]:
2623
self.allow_reuse_address = True
2439
2624
if not self.server_address[0]:
2440
2625
if self.address_family == socket.AF_INET6:
2441
any_address = "::" # in6addr_any
2626
any_address = "::" # in6addr_any
2442
2627
else:
2443
any_address = "0.0.0.0" # INADDR_ANY
2628
any_address = "0.0.0.0" # INADDR_ANY
2444
2629
self.server_address = (any_address,
2445
2630
self.server_address[1])
2446
2631
elif not self.server_address[1]:
2456
2641
2457
2642
class MandosServer(IPv6_TCPServer):
2458
2643
"""Mandos server.
2459
2644
2460
2645
Attributes:
2461
2646
clients: set of Client objects
2462
2647
gnutls_priority GnuTLS priority string
2463
2648
use_dbus: Boolean; to emit D-Bus signals or not
2464
2465
Assumes a gobject.MainLoop event loop.
2649
2650
Assumes a GLib.MainLoop event loop.
2466
2651
"""
2467
2652
2468
2653
def __init__(self, server_address, RequestHandlerClass,
2469
2654
interface=None,
2470
2655
use_ipv6=True,
2480
2665
self.gnutls_priority = gnutls_priority
2481
2666
IPv6_TCPServer.__init__(self, server_address,
2482
2667
RequestHandlerClass,
2483
interface = interface,
2484
use_ipv6 = use_ipv6,
2485
socketfd = socketfd)
2486
2668
interface=interface,
2669
use_ipv6=use_ipv6,
2670
socketfd=socketfd)
2671
2487
2672
def server_activate(self):
2488
2673
if self.enabled:
2489
2674
return socketserver.TCPServer.server_activate(self)
2490
2675
2491
2676
def enable(self):
2492
2677
self.enabled = True
2493
2678
2494
2679
def add_pipe(self, parent_pipe, proc):
2495
2680
# Call "handle_ipc" for both data and EOF events
2496
gobject.io_add_watch(
2497
parent_pipe.fileno(),
2498
gobject.IO_IN | gobject.IO_HUP,
2681
GLib.io_add_watch(
2682
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2683
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2499
2684
functools.partial(self.handle_ipc,
2500
parent_pipe = parent_pipe,
2501
proc = proc))
2502
2685
parent_pipe=parent_pipe,
2686
proc=proc))
2687
2503
2688
def handle_ipc(self, source, condition,
2504
2689
parent_pipe=None,
2505
proc = None,
2690
proc=None,
2506
2691
client_object=None):
2507
2692
# error, or the other end of multiprocessing.Pipe has closed
2508
if condition & (gobject.IO_ERR | gobject.IO_HUP):
2693
if condition & (GLib.IO_ERR | GLib.IO_HUP):
2509
2694
# Wait for other process to exit
2510
2695
proc.join()
2511
2696
return False
2512
2697
2513
2698
# Read a request from the child
2514
2699
request = parent_pipe.recv()
2515
2700
command = request[0]
2516
2701
2517
2702
if command == 'init':
2518
fpr = request[1]
2519
address = request[2]
2520
2521
for c in self.clients.itervalues():
2522
if c.fingerprint == fpr:
2703
key_id = request[1].decode("ascii")
2704
fpr = request[2].decode("ascii")
2705
address = request[3]
2706
2707
for c in self.clients.values():
2708
if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":
2709
continue
2710
if key_id and c.key_id == key_id:
2711
client = c
2712
break
2713
if fpr and c.fingerprint == fpr:
2523
2714
client = c
2524
2715
break
2525
2716
else:
2526
logger.info("Client not found for fingerprint: %s, ad"
2527
"dress: %s", fpr, address)
2717
logger.info("Client not found for key ID: %s, address"
2718
": %s", key_id or fpr, address)
2528
2719
if self.use_dbus:
2529
2720
# Emit D-Bus signal
2530
mandos_dbus_service.ClientNotFound(fpr,
2721
mandos_dbus_service.ClientNotFound(key_id or fpr,
2531
2722
address[0])
2532
2723
parent_pipe.send(False)
2533
2724
return False
2534
2535
gobject.io_add_watch(
2536
parent_pipe.fileno(),
2537
gobject.IO_IN | gobject.IO_HUP,
2725
2726
GLib.io_add_watch(
2727
GLib.IOChannel.unix_new(parent_pipe.fileno()),
2728
GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2538
2729
functools.partial(self.handle_ipc,
2539
parent_pipe = parent_pipe,
2540
proc = proc,
2541
client_object = client))
2730
parent_pipe=parent_pipe,
2731
proc=proc,
2732
client_object=client))
2542
2733
parent_pipe.send(True)
2543
2734
# remove the old hook in favor of the new above hook on
2544
2735
# same fileno
2547
2738
funcname = request[1]
2548
2739
args = request[2]
2549
2740
kwargs = request[3]
2550
2741
2551
2742
parent_pipe.send(('data', getattr(client_object,
2552
2743
funcname)(*args,
2553
2744
**kwargs)))
2554
2745
2555
2746
if command == 'getattr':
2556
2747
attrname = request[1]
2557
2748
if isinstance(client_object.__getattribute__(attrname),
2560
2751
else:
2561
2752
parent_pipe.send((
2562
2753
'data', client_object.__getattribute__(attrname)))
2563
2754
2564
2755
if command == 'setattr':
2565
2756
attrname = request[1]
2566
2757
value = request[2]
2567
2758
setattr(client_object, attrname, value)
2568
2759
2569
2760
return True
2570
2761
2571
2762
2572
2763
def rfc3339_duration_to_delta(duration):
2573
2764
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
2574
2575
>>> rfc3339_duration_to_delta("P7D")
2576
datetime.timedelta(7)
2577
>>> rfc3339_duration_to_delta("PT60S")
2578
datetime.timedelta(0, 60)
2579
>>> rfc3339_duration_to_delta("PT60M")
2580
datetime.timedelta(0, 3600)
2581
>>> rfc3339_duration_to_delta("PT24H")
2582
datetime.timedelta(1)
2583
>>> rfc3339_duration_to_delta("P1W")
2584
datetime.timedelta(7)
2585
>>> rfc3339_duration_to_delta("PT5M30S")
2586
datetime.timedelta(0, 330)
2587
>>> rfc3339_duration_to_delta("P1DT3M20S")
2588
datetime.timedelta(1, 200)
2765
2766
>>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
2767
True
2768
>>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
2769
True
2770
>>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
2771
True
2772
>>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
2773
True
2774
>>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
2775
True
2776
>>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
2777
True
2778
>>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
2779
True
2589
2780
"""
2590
2781
2591
2782
# Parsing an RFC 3339 duration with regular expressions is not
2592
2783
# possible - there would have to be multiple places for the same
2593
2784
# values, like seconds. The current code, while more esoteric, is
2594
2785
# cleaner without depending on a parsing library. If Python had a
2595
2786
# built-in library for parsing we would use it, but we'd like to
2596
2787
# avoid excessive use of external libraries.
2597
2788
2598
2789
# New type for defining tokens, syntax, and semantics all-in-one
2599
2790
Token = collections.namedtuple("Token", (
2600
2791
"regexp", # To match token; if "value" is not None, must have
2633
2824
frozenset((token_year, token_month,
2634
2825
token_day, token_time,
2635
2826
token_week)))
2636
# Define starting values
2637
value = datetime.timedelta() # Value so far
2827
# Define starting values:
2828
# Value so far
2829
value = datetime.timedelta()
2638
2830
found_token = None
2639
followers = frozenset((token_duration, )) # Following valid tokens
2640
s = duration # String left to parse
2831
# Following valid tokens
2832
followers = frozenset((token_duration, ))
2833
# String left to parse
2834
s = duration
2641
2835
# Loop until end token is found
2642
2836
while found_token is not token_end:
2643
2837
# Search for any currently valid tokens
2667
2861
2668
2862
def string_to_delta(interval):
2669
2863
"""Parse a string and return a datetime.timedelta
2670
2671
>>> string_to_delta('7d')
2672
datetime.timedelta(7)
2673
>>> string_to_delta('60s')
2674
datetime.timedelta(0, 60)
2675
>>> string_to_delta('60m')
2676
datetime.timedelta(0, 3600)
2677
>>> string_to_delta('24h')
2678
datetime.timedelta(1)
2679
>>> string_to_delta('1w')
2680
datetime.timedelta(7)
2681
>>> string_to_delta('5m 30s')
2682
datetime.timedelta(0, 330)
2864
2865
>>> string_to_delta('7d') == datetime.timedelta(7)
2866
True
2867
>>> string_to_delta('60s') == datetime.timedelta(0, 60)
2868
True
2869
>>> string_to_delta('60m') == datetime.timedelta(0, 3600)
2870
True
2871
>>> string_to_delta('24h') == datetime.timedelta(1)
2872
True
2873
>>> string_to_delta('1w') == datetime.timedelta(7)
2874
True
2875
>>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
2876
True
2683
2877
"""
2684
2878
2685
2879
try:
2686
2880
return rfc3339_duration_to_delta(interval)
2687
2881
except ValueError:
2688
2882
pass
2689
2883
2690
2884
timevalue = datetime.timedelta(0)
2691
2885
for s in interval.split():
2692
2886
try:
2710
2904
return timevalue
2711
2905
2712
2906
2713
def daemon(nochdir = False, noclose = False):
2907
def daemon(nochdir=False, noclose=False):
2714
2908
"""See daemon(3). Standard BSD Unix function.
2715
2909
2716
2910
This should really exist as os.daemon, but it doesn't (yet)."""
2717
2911
if os.fork():
2718
2912
sys.exit()
2736
2930
2737
2931
2738
2932
def main():
2739
2933
2740
2934
##################################################################
2741
2935
# Parsing of options, both command line and config file
2742
2936
2743
2937
parser = argparse.ArgumentParser()
2744
2938
parser.add_argument("-v", "--version", action="version",
2745
version = "%(prog)s {}".format(version),
2939
version="%(prog)s {}".format(version),
2746
2940
help="show version number and exit")
2747
2941
parser.add_argument("-i", "--interface", metavar="IF",
2748
2942
help="Bind to interface IF")
2784
2978
parser.add_argument("--no-zeroconf", action="store_false",
2785
2979
dest="zeroconf", help="Do not use Zeroconf",
2786
2980
default=None)
2787
2981
2788
2982
options = parser.parse_args()
2789
2790
if options.check:
2791
import doctest
2792
fail_count, test_count = doctest.testmod()
2793
sys.exit(os.EX_OK if fail_count == 0 else 1)
2794
2983
2795
2984
# Default values for config file for server-global settings
2796
server_defaults = { "interface": "",
2797
"address": "",
2798
"port": "",
2799
"debug": "False",
2800
"priority":
2801
"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2802
":+SIGN-DSA-SHA256",
2803
"servicename": "Mandos",
2804
"use_dbus": "True",
2805
"use_ipv6": "True",
2806
"debuglevel": "",
2807
"restore": "True",
2808
"socket": "",
2809
"statedir": "/var/lib/mandos",
2810
"foreground": "False",
2811
"zeroconf": "True",
2812
}
2813
2985
if gnutls.has_rawpk:
2986
priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"
2987
":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")
2988
else:
2989
priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"
2990
":+SIGN-DSA-SHA256")
2991
server_defaults = {"interface": "",
2992
"address": "",
2993
"port": "",
2994
"debug": "False",
2995
"priority": priority,
2996
"servicename": "Mandos",
2997
"use_dbus": "True",
2998
"use_ipv6": "True",
2999
"debuglevel": "",
3000
"restore": "True",
3001
"socket": "",
3002
"statedir": "/var/lib/mandos",
3003
"foreground": "False",
3004
"zeroconf": "True",
3005
}
3006
del priority
3007
2814
3008
# Parse config file for server-global settings
2815
server_config = configparser.SafeConfigParser(server_defaults)
3009
server_config = configparser.ConfigParser(server_defaults)
2816
3010
del server_defaults
2817
3011
server_config.read(os.path.join(options.configdir, "mandos.conf"))
2818
# Convert the SafeConfigParser object to a dict
3012
# Convert the ConfigParser object to a dict
2819
3013
server_settings = server_config.defaults()
2820
3014
# Use the appropriate methods on the non-string config options
2821
for option in ("debug", "use_dbus", "use_ipv6", "foreground"):
3015
for option in ("debug", "use_dbus", "use_ipv6", "restore",
3016
"foreground", "zeroconf"):
2822
3017
server_settings[option] = server_config.getboolean("DEFAULT",
2823
3018
option)
2824
3019
if server_settings["port"]:
2834
3029
server_settings["socket"] = os.dup(server_settings
2835
3030
["socket"])
2836
3031
del server_config
2837
3032
2838
3033
# Override the settings from the config file with command line
2839
3034
# options, if set.
2840
3035
for option in ("interface", "address", "port", "debug",
2858
3053
if server_settings["debug"]:
2859
3054
server_settings["foreground"] = True
2860
3055
# Now we have our good server settings in "server_settings"
2861
3056
2862
3057
##################################################################
2863
3058
2864
3059
if (not server_settings["zeroconf"]
2865
3060
and not (server_settings["port"]
2866
3061
or server_settings["socket"] != "")):
2867
3062
parser.error("Needs port or socket to work without Zeroconf")
2868
3063
2869
3064
# For convenience
2870
3065
debug = server_settings["debug"]
2871
3066
debuglevel = server_settings["debuglevel"]
2875
3070
stored_state_file)
2876
3071
foreground = server_settings["foreground"]
2877
3072
zeroconf = server_settings["zeroconf"]
2878
3073
2879
3074
if debug:
2880
3075
initlogger(debug, logging.DEBUG)
2881
3076
else:
2884
3079
else:
2885
3080
level = getattr(logging, debuglevel.upper())
2886
3081
initlogger(debug, level)
2887
3082
2888
3083
if server_settings["servicename"] != "Mandos":
2889
3084
syslogger.setFormatter(
2890
3085
logging.Formatter('Mandos ({}) [%(process)d]:'
2891
3086
' %(levelname)s: %(message)s'.format(
2892
3087
server_settings["servicename"])))
2893
3088
2894
3089
# Parse config file with clients
2895
client_config = configparser.SafeConfigParser(Client
2896
.client_defaults)
3090
client_config = configparser.ConfigParser(Client.client_defaults)
2897
3091
client_config.read(os.path.join(server_settings["configdir"],
2898
3092
"clients.conf"))
2899
3093
2900
3094
global mandos_dbus_service
2901
3095
mandos_dbus_service = None
2902
3096
2903
3097
socketfd = None
2904
3098
if server_settings["socket"] != "":
2905
3099
socketfd = server_settings["socket"]
2921
3115
except IOError as e:
2922
3116
logger.error("Could not open file %r", pidfilename,
2923
3117
exc_info=e)
2924
2925
for name in ("_mandos", "mandos", "nobody"):
3118
3119
for name, group in (("_mandos", "_mandos"),
3120
("mandos", "mandos"),
3121
("nobody", "nogroup")):
2926
3122
try:
2927
3123
uid = pwd.getpwnam(name).pw_uid
2928
gid = pwd.getpwnam(name).pw_gid
3124
gid = pwd.getpwnam(group).pw_gid
2929
3125
break
2930
3126
except KeyError:
2931
3127
continue
2935
3131
try:
2936
3132
os.setgid(gid)
2937
3133
os.setuid(uid)
3134
if debug:
3135
logger.debug("Did setuid/setgid to {}:{}".format(uid,
3136
gid))
2938
3137
except OSError as error:
3138
logger.warning("Failed to setuid/setgid to {}:{}: {}"
3139
.format(uid, gid, os.strerror(error.errno)))
2939
3140
if error.errno != errno.EPERM:
2940
3141
raise
2941
3142
2942
3143
if debug:
2943
3144
# Enable all possible GnuTLS debugging
2944
3145
2945
3146
# "Use a log level over 10 to enable all debugging options."
2946
3147
# - GnuTLS manual
2947
3148
gnutls.global_set_log_level(11)
2948
3149
2949
3150
@gnutls.log_func
2950
3151
def debug_gnutls(level, string):
2951
3152
logger.debug("GnuTLS: %s", string[:-1])
2952
3153
2953
3154
gnutls.global_set_log_function(debug_gnutls)
2954
3155
2955
3156
# Redirect stdin so all checkers get /dev/null
2956
3157
null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)
2957
3158
os.dup2(null, sys.stdin.fileno())
2958
3159
if null > 2:
2959
3160
os.close(null)
2960
3161
2961
3162
# Need to fork before connecting to D-Bus
2962
3163
if not foreground:
2963
3164
# Close all input and output, do double fork, etc.
2964
3165
daemon()
2965
2966
# multiprocessing will use threads, so before we use gobject we
2967
# need to inform gobject that threads will be used.
2968
gobject.threads_init()
2969
3166
3167
if gi.version_info < (3, 10, 2):
3168
# multiprocessing will use threads, so before we use GLib we
3169
# need to inform GLib that threads will be used.
3170
GLib.threads_init()
3171
2970
3172
global main_loop
2971
3173
# From the Avahi example code
2972
3174
DBusGMainLoop(set_as_default=True)
2973
main_loop = gobject.MainLoop()
3175
main_loop = GLib.MainLoop()
2974
3176
bus = dbus.SystemBus()
2975
3177
# End of Avahi example code
2976
3178
if use_dbus:
2989
3191
if zeroconf:
2990
3192
protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET
2991
3193
service = AvahiServiceToSyslog(
2992
name = server_settings["servicename"],
2993
servicetype = "_mandos._tcp",
2994
protocol = protocol,
2995
bus = bus)
3194
name=server_settings["servicename"],
3195
servicetype="_mandos._tcp",
3196
protocol=protocol,
3197
bus=bus)
2996
3198
if server_settings["interface"]:
2997
3199
service.interface = if_nametoindex(
2998
3200
server_settings["interface"].encode("utf-8"))
2999
3201
3000
3202
global multiprocessing_manager
3001
3203
multiprocessing_manager = multiprocessing.Manager()
3002
3204
3003
3205
client_class = Client
3004
3206
if use_dbus:
3005
client_class = functools.partial(ClientDBus, bus = bus)
3006
3207
client_class = functools.partial(ClientDBus, bus=bus)
3208
3007
3209
client_settings = Client.config_parser(client_config)
3008
3210
old_client_settings = {}
3009
3211
clients_data = {}
3010
3212
3011
3213
# This is used to redirect stdout and stderr for checker processes
3012
3214
global wnull
3013
wnull = open(os.devnull, "w") # A writable /dev/null
3215
wnull = open(os.devnull, "w") # A writable /dev/null
3014
3216
# Only used if server is running in foreground but not in debug
3015
3217
# mode
3016
3218
if debug or not foreground:
3017
3219
wnull.close()
3018
3220
3019
3221
# Get client data and settings from last running state.
3020
3222
if server_settings["restore"]:
3021
3223
try:
3022
3224
with open(stored_state_path, "rb") as stored_state:
3023
clients_data, old_client_settings = pickle.load(
3024
stored_state)
3225
if sys.version_info.major == 2:
3226
clients_data, old_client_settings = pickle.load(
3227
stored_state)
3228
else:
3229
bytes_clients_data, bytes_old_client_settings = (
3230
pickle.load(stored_state, encoding="bytes"))
3231
# Fix bytes to strings
3232
# clients_data
3233
# .keys()
3234
clients_data = {(key.decode("utf-8")
3235
if isinstance(key, bytes)
3236
else key): value
3237
for key, value in
3238
bytes_clients_data.items()}
3239
del bytes_clients_data
3240
for key in clients_data:
3241
value = {(k.decode("utf-8")
3242
if isinstance(k, bytes) else k): v
3243
for k, v in
3244
clients_data[key].items()}
3245
clients_data[key] = value
3246
# .client_structure
3247
value["client_structure"] = [
3248
(s.decode("utf-8")
3249
if isinstance(s, bytes)
3250
else s) for s in
3251
value["client_structure"]]
3252
# .name, .host, and .checker_command
3253
for k in ("name", "host", "checker_command"):
3254
if isinstance(value[k], bytes):
3255
value[k] = value[k].decode("utf-8")
3256
if "key_id" not in value:
3257
value["key_id"] = ""
3258
elif "fingerprint" not in value:
3259
value["fingerprint"] = ""
3260
# old_client_settings
3261
# .keys()
3262
old_client_settings = {
3263
(key.decode("utf-8")
3264
if isinstance(key, bytes)
3265
else key): value
3266
for key, value in
3267
bytes_old_client_settings.items()}
3268
del bytes_old_client_settings
3269
# .host and .checker_command
3270
for value in old_client_settings.values():
3271
for attribute in ("host", "checker_command"):
3272
if isinstance(value[attribute], bytes):
3273
value[attribute] = (value[attribute]
3274
.decode("utf-8"))
3025
3275
os.remove(stored_state_path)
3026
3276
except IOError as e:
3027
3277
if e.errno == errno.ENOENT:
3035
3285
logger.warning("Could not load persistent state: "
3036
3286
"EOFError:",
3037
3287
exc_info=e)
3038
3288
3039
3289
with PGPEngine() as pgp:
3040
3290
for client_name, client in clients_data.items():
3041
3291
# Skip removed clients
3042
3292
if client_name not in client_settings:
3043
3293
continue
3044
3294
3045
3295
# Decide which value to use after restoring saved state.
3046
3296
# We have three different values: Old config file,
3047
3297
# new config file, and saved state.
3058
3308
client[name] = value
3059
3309
except KeyError:
3060
3310
pass
3061
3311
3062
3312
# Clients who has passed its expire date can still be
3063
3313
# enabled if its last checker was successful. A Client
3064
3314
# whose checker succeeded before we stored its state is
3097
3347
client_name))
3098
3348
client["secret"] = (client_settings[client_name]
3099
3349
["secret"])
3100
3350
3101
3351
# Add/remove clients based on new changes made to config
3102
3352
for client_name in (set(old_client_settings)
3103
3353
- set(client_settings)):
3105
3355
for client_name in (set(client_settings)
3106
3356
- set(old_client_settings)):
3107
3357
clients_data[client_name] = client_settings[client_name]
3108
3358
3109
3359
# Create all client objects
3110
3360
for client_name, client in clients_data.items():
3111
3361
tcp_server.clients[client_name] = client_class(
3112
name = client_name,
3113
settings = client,
3114
server_settings = server_settings)
3115
3362
name=client_name,
3363
settings=client,
3364
server_settings=server_settings)
3365
3116
3366
if not tcp_server.clients:
3117
3367
logger.warning("No clients defined")
3118
3368
3119
3369
if not foreground:
3120
3370
if pidfile is not None:
3121
3371
pid = os.getpid()
3127
3377
pidfilename, pid)
3128
3378
del pidfile
3129
3379
del pidfilename
3130
3131
signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())
3132
signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())
3133
3380
3381
for termsig in (signal.SIGHUP, signal.SIGTERM):
3382
GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,
3383
lambda: main_loop.quit() and False)
3384
3134
3385
if use_dbus:
3135
3386
3136
3387
@alternate_dbus_interfaces(
3137
{ "se.recompile.Mandos": "se.bsnet.fukt.Mandos" })
3388
{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})
3138
3389
class MandosDBusService(DBusObjectWithObjectManager):
3139
3390
"""A D-Bus proxy object"""
3140
3391
3141
3392
def __init__(self):
3142
3393
dbus.service.Object.__init__(self, bus, "/")
3143
3394
3144
3395
_interface = "se.recompile.Mandos"
3145
3396
3146
3397
@dbus.service.signal(_interface, signature="o")
3147
3398
def ClientAdded(self, objpath):
3148
3399
"D-Bus signal"
3149
3400
pass
3150
3401
3151
3402
@dbus.service.signal(_interface, signature="ss")
3152
def ClientNotFound(self, fingerprint, address):
3403
def ClientNotFound(self, key_id, address):
3153
3404
"D-Bus signal"
3154
3405
pass
3155
3406
3156
3407
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3157
3408
"true"})
3158
3409
@dbus.service.signal(_interface, signature="os")
3159
3410
def ClientRemoved(self, objpath, name):
3160
3411
"D-Bus signal"
3161
3412
pass
3162
3413
3163
3414
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3164
3415
"true"})
3165
3416
@dbus.service.method(_interface, out_signature="ao")
3166
3417
def GetAllClients(self):
3167
3418
"D-Bus method"
3168
3419
return dbus.Array(c.dbus_object_path for c in
3169
tcp_server.clients.itervalues())
3170
3420
tcp_server.clients.values())
3421
3171
3422
@dbus_annotations({"org.freedesktop.DBus.Deprecated":
3172
3423
"true"})
3173
3424
@dbus.service.method(_interface,
3175
3426
def GetAllClientsWithProperties(self):
3176
3427
"D-Bus method"
3177
3428
return dbus.Dictionary(
3178
{ c.dbus_object_path: c.GetAll(
3429
{c.dbus_object_path: c.GetAll(
3179
3430
"se.recompile.Mandos.Client")
3180
for c in tcp_server.clients.itervalues() },
3431
for c in tcp_server.clients.values()},
3181
3432
signature="oa{sv}")
3182
3433
3183
3434
@dbus.service.method(_interface, in_signature="o")
3184
3435
def RemoveClient(self, object_path):
3185
3436
"D-Bus method"
3186
for c in tcp_server.clients.itervalues():
3437
for c in tcp_server.clients.values():
3187
3438
if c.dbus_object_path == object_path:
3188
3439
del tcp_server.clients[c.name]
3189
3440
c.remove_from_connection()
3193
3444
self.client_removed_signal(c)
3194
3445
return
3195
3446
raise KeyError(object_path)
3196
3447
3197
3448
del _interface
3198
3449
3199
3450
@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,
3200
out_signature = "a{oa{sa{sv}}}")
3451
out_signature="a{oa{sa{sv}}}")
3201
3452
def GetManagedObjects(self):
3202
3453
"""D-Bus method"""
3203
3454
return dbus.Dictionary(
3204
{ client.dbus_object_path:
3205
dbus.Dictionary(
3206
{ interface: client.GetAll(interface)
3207
for interface in
3208
client._get_all_interface_names()})
3209
for client in tcp_server.clients.values()})
3210
3455
{client.dbus_object_path:
3456
dbus.Dictionary(
3457
{interface: client.GetAll(interface)
3458
for interface in
3459
client._get_all_interface_names()})
3460
for client in tcp_server.clients.values()})
3461
3211
3462
def client_added_signal(self, client):
3212
3463
"""Send the new standard signal and the old signal"""
3213
3464
if use_dbus:
3215
3466
self.InterfacesAdded(
3216
3467
client.dbus_object_path,
3217
3468
dbus.Dictionary(
3218
{ interface: client.GetAll(interface)
3219
for interface in
3220
client._get_all_interface_names()}))
3469
{interface: client.GetAll(interface)
3470
for interface in
3471
client._get_all_interface_names()}))
3221
3472
# Old signal
3222
3473
self.ClientAdded(client.dbus_object_path)
3223
3474
3224
3475
def client_removed_signal(self, client):
3225
3476
"""Send the new standard signal and the old signal"""
3226
3477
if use_dbus:
3231
3482
# Old signal
3232
3483
self.ClientRemoved(client.dbus_object_path,
3233
3484
client.name)
3234
3485
3235
3486
mandos_dbus_service = MandosDBusService()
3236
3487
3488
# Save modules to variables to exempt the modules from being
3489
# unloaded before the function registered with atexit() is run.
3490
mp = multiprocessing
3491
wn = wnull
3492
3237
3493
def cleanup():
3238
3494
"Cleanup function; run on exit"
3239
3495
if zeroconf:
3240
3496
service.cleanup()
3241
3242
multiprocessing.active_children()
3243
wnull.close()
3497
3498
mp.active_children()
3499
wn.close()
3244
3500
if not (tcp_server.clients or client_settings):
3245
3501
return
3246
3502
3247
3503
# Store client before exiting. Secrets are encrypted with key
3248
3504
# based on what config file has. If config file is
3249
3505
# removed/edited, old secret will thus be unrecovable.
3250
3506
clients = {}
3251
3507
with PGPEngine() as pgp:
3252
for client in tcp_server.clients.itervalues():
3508
for client in tcp_server.clients.values():
3253
3509
key = client_settings[client.name]["secret"]
3254
3510
client.encrypted_secret = pgp.encrypt(client.secret,
3255
3511
key)
3256
3512
client_dict = {}
3257
3513
3258
3514
# A list of attributes that can not be pickled
3259
3515
# + secret.
3260
exclude = { "bus", "changedstate", "secret",
3261
"checker", "server_settings" }
3516
exclude = {"bus", "changedstate", "secret",
3517
"checker", "server_settings"}
3262
3518
for name, typ in inspect.getmembers(dbus.service
3263
3519
.Object):
3264
3520
exclude.add(name)
3265
3521
3266
3522
client_dict["encrypted_secret"] = (client
3267
3523
.encrypted_secret)
3268
3524
for attr in client.client_structure:
3269
3525
if attr not in exclude:
3270
3526
client_dict[attr] = getattr(client, attr)
3271
3527
3272
3528
clients[client.name] = client_dict
3273
3529
del client_settings[client.name]["secret"]
3274
3530
3275
3531
try:
3276
3532
with tempfile.NamedTemporaryFile(
3277
3533
mode='wb',
3279
3535
prefix='clients-',
3280
3536
dir=os.path.dirname(stored_state_path),
3281
3537
delete=False) as stored_state:
3282
pickle.dump((clients, client_settings), stored_state)
3538
pickle.dump((clients, client_settings), stored_state,
3539
protocol=2)
3283
3540
tempname = stored_state.name
3284
3541
os.rename(tempname, stored_state_path)
3285
3542
except (IOError, OSError) as e:
3295
3552
logger.warning("Could not save persistent state:",
3296
3553
exc_info=e)
3297
3554
raise
3298
3555
3299
3556
# Delete all clients, and settings from config
3300
3557
while tcp_server.clients:
3301
3558
name, client = tcp_server.clients.popitem()
3307
3564
if use_dbus:
3308
3565
mandos_dbus_service.client_removed_signal(client)
3309
3566
client_settings.clear()
3310
3567
3311
3568
atexit.register(cleanup)
3312
3313
for client in tcp_server.clients.itervalues():
3569
3570
for client in tcp_server.clients.values():
3314
3571
if use_dbus:
3315
3572
# Emit D-Bus signal for adding
3316
3573
mandos_dbus_service.client_added_signal(client)
3317
3574
# Need to initiate checking of clients
3318
3575
if client.enabled:
3319
3576
client.init_checker()
3320
3577
3321
3578
tcp_server.enable()
3322
3579
tcp_server.server_activate()
3323
3580
3324
3581
# Find out what port we got
3325
3582
if zeroconf:
3326
3583
service.port = tcp_server.socket.getsockname()[1]
3331
3588
else: # IPv4
3332
3589
logger.info("Now listening on address %r, port %d",
3333
3590
*tcp_server.socket.getsockname())
3334
3335
#service.interface = tcp_server.socket.getsockname()[3]
3336
3591
3592
# service.interface = tcp_server.socket.getsockname()[3]
3593
3337
3594
try:
3338
3595
if zeroconf:
3339
3596
# From the Avahi example code
3344
3601
cleanup()
3345
3602
sys.exit(1)
3346
3603
# End of Avahi example code
3347
3348
gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,
3349
lambda *args, **kwargs:
3350
(tcp_server.handle_request
3351
(*args[2:], **kwargs) or True))
3352
3604
3605
GLib.io_add_watch(
3606
GLib.IOChannel.unix_new(tcp_server.fileno()),
3607
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
3608
lambda *args, **kwargs: (tcp_server.handle_request
3609
(*args[2:], **kwargs) or True))
3610
3353
3611
logger.debug("Starting main loop")
3354
3612
main_loop.run()
3355
3613
except AvahiError as error:
3364
3622
# Must run before the D-Bus bus name gets deregistered
3365
3623
cleanup()
3366
3624
3625
3626
def should_only_run_tests():
3627
parser = argparse.ArgumentParser(add_help=False)
3628
parser.add_argument("--check", action='store_true')
3629
args, unknown_args = parser.parse_known_args()
3630
run_tests = args.check
3631
if run_tests:
3632
# Remove --check argument from sys.argv
3633
sys.argv[1:] = unknown_args
3634
return run_tests
3635
3636
# Add all tests from doctest strings
3637
def load_tests(loader, tests, none):
3638
import doctest
3639
tests.addTests(doctest.DocTestSuite())
3640
return tests
3367
3641
3368
3642
if __name__ == '__main__':
3369
main()
3643
try:
3644
if should_only_run_tests():
3645
# Call using ./mandos --check [--verbose]
3646
unittest.main()
3647
else:
3648
main()
3649
finally:
3650
logging.shutdown()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0