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