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