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