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-ctl
- browse files at revision 237.7.777
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.777
- Committer: teddy at recompile
- Date: 2020-12-03 20:30:45 UTC
- mto: This revision was merged to the branch mainline in revision 404.
- Revision ID: teddy@recompile.se-20201203203045-iqd6nq9y5nwalh1x
Minor fix of a test function
In dracut-module/password-agent, the test function
test_send_password_to_socket_EMSGSIZE() (which tests that the
send_password_to_socket() task function aborts properly when getting
EMSGSIZE when writing to the password socket), part of the test code
is supposed to find a message size which definitely does trigger
EMSGSIZE when send()ing to a socket. Without a "break" in the proper
place, however, the size given is always exactly 1024 bytes too large.
This is very probably not a problem, since a too large message will
still be too large if it is increased by 1024 bytes, and send(2) in
practice checks the size before reading the buffer. The biggest issue
would be if some version of send(2) would try to look at the last 1024
bytes of the message buffer before checking the message size; this
would then lead to a buffer over-read when running this test function.
(But even then there would be no security implications since the tests
are not run in the normal operation of the program.)
* dracut-module/password-agent.c
(test_send_password_to_socket_EMSGSIZE): Break out early when ssret
< 0 and errno == EMSGSIZE; don't allow loop to increase message_size
again.
In dracut-module/password-agent, the test function
test_send_password_to_socket_EMSGSIZE() (which tests that the
send_password_to_socket() task function aborts properly when getting
EMSGSIZE when writing to the password socket), part of the test code
is supposed to find a message size which definitely does trigger
EMSGSIZE when send()ing to a socket. Without a "break" in the proper
place, however, the size given is always exactly 1024 bytes too large.
This is very probably not a problem, since a too large message will
still be too large if it is increased by 1024 bytes, and send(2) in
practice checks the size before reading the buffer. The biggest issue
would be if some version of send(2) would try to look at the last 1024
bytes of the message buffer before checking the message size; this
would then lead to a buffer over-read when running this test function.
(But even then there would be no security implications since the tests
are not run in the normal operation of the program.)
* dracut-module/password-agent.c
(test_send_password_to_socket_EMSGSIZE): Break out early when ssret
< 0 and errno == EMSGSIZE; don't allow loop to increase message_size
again.
- files added:
- debian/po/de.po
- files modified:
- .bzrignore
added
removed
mandos-ctl
1
#!/usr/bin/python
1
#!/usr/bin/python3 -bbI
2
2
# -*- after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-
3
3
#
4
# Mandos Monitor - Control and monitor the Mandos server
4
# Mandos Control - Control or query the Mandos server
5
5
#
6
# Copyright © 2008-2019 Teddy Hogeborn
7
# Copyright © 2008-2019 Björn Påhlsson
6
# Copyright © 2008-2020 Teddy Hogeborn
7
# Copyright © 2008-2020 Björn Påhlsson
8
8
#
9
9
# This file is part of Mandos.
10
10
#
46
46
import tempfile
47
47
import contextlib
48
48
49
if sys.version_info.major == 2:
50
__metaclass__ = type
51
str = unicode
52
53
class gi:
54
"""Dummy gi module, for the tests"""
55
class repository:
56
class GLib:
57
class Error(Exception):
58
pass
59
dbussy = None
60
ravel = None
61
dbus_python = None
62
pydbus = None
63
49
64
try:
50
import pydbus
51
import gi
52
dbus_python = None
65
import dbussy
66
import ravel
53
67
except ImportError:
54
import dbus as dbus_python
55
pydbus = None
56
class gi(object):
57
"""Dummy gi module, for the tests"""
58
class repository(object):
59
class GLib(object):
60
class Error(Exception):
61
pass
68
try:
69
import pydbus
70
import gi
71
except ImportError:
72
import dbus as dbus_python
73
62
74
63
75
# Show warnings by default
64
76
if not sys.warnoptions:
72
84
logging.captureWarnings(True) # Show warnings via the logging system
73
85
74
86
if sys.version_info.major == 2:
75
str = unicode
76
87
import StringIO
77
88
io.StringIO = StringIO.StringIO
78
89
79
90
locale.setlocale(locale.LC_ALL, "")
80
91
81
version = "1.8.5"
92
version = "1.8.13"
82
93
83
94
84
95
def main():
93
104
if options.debug:
94
105
log.setLevel(logging.DEBUG)
95
106
96
if pydbus is not None:
107
if dbussy is not None and ravel is not None:
108
bus = dbussy_adapter.CachingBus(dbussy, ravel)
109
elif pydbus is not None:
97
110
bus = pydbus_adapter.CachingBus(pydbus)
98
111
else:
99
112
bus = dbus_python_adapter.CachingBus(dbus_python)
467
480
parser.error("--remove can only be combined with --deny")
468
481
469
482
470
class dbus(object):
483
class dbus:
471
484
472
class SystemBus(object):
485
class SystemBus:
473
486
474
487
object_manager_iface = "org.freedesktop.DBus.ObjectManager"
475
488
def get_managed_objects(self, busname, objectpath):
484
497
self.properties_iface, interface, key,
485
498
value)
486
499
500
def call_method(self, methodname, busname, objectpath,
501
interface, *args):
502
raise NotImplementedError()
503
487
504
488
505
class MandosBus(SystemBus):
489
506
busname_domain = "se.recompile"
521
538
pass
522
539
523
540
524
class dbus_python_adapter(object):
541
class dbus_python_adapter:
525
542
526
543
class SystemBus(dbus.MandosBus):
527
544
"""Use dbus-python"""
581
598
self.client_interface, key,
582
599
value)
583
600
584
class SilenceLogger(object):
601
class SilenceLogger:
585
602
"Simple context manager to silence a particular logger"
586
603
def __init__(self, loggername):
587
604
self.logger = logging.getLogger(loggername)
616
633
return new_object
617
634
618
635
619
class pydbus_adapter(object):
636
class pydbus_adapter:
620
637
class SystemBus(dbus.MandosBus):
621
638
def __init__(self, module=pydbus):
622
639
self.pydbus = module
679
696
return new_object
680
697
681
698
699
class dbussy_adapter:
700
class SystemBus(dbus.SystemBus):
701
"""Use DBussy"""
702
703
def __init__(self, dbussy, ravel):
704
self.dbussy = dbussy
705
self.ravel = ravel
706
self.bus = ravel.system_bus()
707
708
@contextlib.contextmanager
709
def convert_exception(self, exception_class=dbus.Error):
710
try:
711
yield
712
except self.dbussy.DBusError as e:
713
# This does what "raise from" would do
714
exc = exception_class(*e.args)
715
exc.__cause__ = e
716
raise exc
717
718
def call_method(self, methodname, busname, objectpath,
719
interface, *args):
720
proxy_object = self.get_object(busname, objectpath)
721
log.debug("D-Bus: %s:%s:%s.%s(%s)", busname, objectpath,
722
interface, methodname,
723
", ".join(repr(a) for a in args))
724
iface = proxy_object.get_interface(interface)
725
method = getattr(iface, methodname)
726
with self.convert_exception(dbus.Error):
727
value = method(*args)
728
# DBussy returns values either as an empty list or as a
729
# list of one element with the return value
730
if value:
731
return self.type_filter(value[0])
732
733
def get_object(self, busname, objectpath):
734
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
735
busname, objectpath)
736
with self.convert_exception(dbus.ConnectFailed):
737
return self.bus[busname][objectpath]
738
739
def type_filter(self, value):
740
"""Convert the most bothersome types to Python types"""
741
# A D-Bus Variant value is represented as the Python type
742
# Tuple[dbussy.DBUS.Signature, Any]
743
if isinstance(value, tuple):
744
if (len(value) == 2
745
and isinstance(value[0],
746
self.dbussy.DBUS.Signature)):
747
return self.type_filter(value[1])
748
elif isinstance(value, self.dbussy.DBUS.ObjectPath):
749
return str(value)
750
# Also recurse into dictionaries
751
elif isinstance(value, dict):
752
return {self.type_filter(key):
753
self.type_filter(subval)
754
for key, subval in value.items()}
755
return value
756
757
def set_property(self, busname, objectpath, interface, key,
758
value):
759
proxy_object = self.get_object(busname, objectpath)
760
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", busname,
761
objectpath, self.properties_iface, interface,
762
key, value)
763
if key == "Secret":
764
# DBussy wants a Byte Array to be a sequence of
765
# values, not a byte string
766
value = tuple(value)
767
setattr(proxy_object.get_interface(interface), key, value)
768
769
class MandosBus(SystemBus, dbus.MandosBus):
770
pass
771
772
class CachingBus(MandosBus):
773
"""A caching layer for dbussy_adapter.MandosBus"""
774
def __init__(self, *args, **kwargs):
775
self.object_cache = {}
776
super(dbussy_adapter.CachingBus, self).__init__(*args,
777
**kwargs)
778
def get_object(self, busname, objectpath):
779
try:
780
return self.object_cache[(busname, objectpath)]
781
except KeyError:
782
new_object = super(
783
dbussy_adapter.CachingBus,
784
self).get_object(busname, objectpath)
785
self.object_cache[(busname, objectpath)] = new_object
786
return new_object
787
788
682
789
def commands_from_options(options):
683
790
684
791
commands = list(options.commands)
712
819
return commands
713
820
714
821
715
class command(object):
822
class command:
716
823
"""A namespace for command classes"""
717
824
718
class Base(object):
825
class Base:
719
826
"""Abstract base class for commands"""
720
827
def run(self, clients, bus=None):
721
828
"""Normal commands should implement run_on_one_client(),
784
891
keywords = self.all_keywords
785
892
print(self.TableOfClients(clients.values(), keywords))
786
893
787
class TableOfClients(object):
894
class TableOfClients:
788
895
tableheaders = {
789
896
"Name": "Name",
790
897
"Enabled": "Enabled",
1021
1128
"output"))
1022
1129
1023
1130
1024
class Unique(object):
1131
class Unique:
1025
1132
"""Class for objects which exist only to be unique objects, since
1026
1133
unittest.mock.sentinel only exists in Python 3.3"""
1027
1134
1311
1418
class Test_dbus_python_adapter_SystemBus(TestCaseWithAssertLogs):
1312
1419
1313
1420
def MockDBusPython_func(self, func):
1314
class mock_dbus_python(object):
1421
class mock_dbus_python:
1315
1422
"""mock dbus-python module"""
1316
class exceptions(object):
1423
class exceptions:
1317
1424
"""Pseudo-namespace"""
1318
1425
class DBusException(Exception):
1319
1426
pass
1320
class SystemBus(object):
1427
class SystemBus:
1321
1428
@staticmethod
1322
1429
def get_object(busname, objectpath):
1323
1430
DBusObject = collections.namedtuple(
1337
1444
dbus_interface=dbus_interface)
1338
1445
return DBusObject(methodname=method,
1339
1446
Set=set_property)
1340
class Boolean(object):
1447
class Boolean:
1341
1448
def __init__(self, value):
1342
1449
self.value = bool(value)
1343
1450
def __bool__(self):
1527
1634
finally:
1528
1635
dbus_logger.removeFilter(counting_handler)
1529
1636
1530
self.assertNotIsInstance(e, dbus.ConnectFailed)
1637
self.assertNotIsInstance(e.exception, dbus.ConnectFailed)
1531
1638
1532
1639
# Make sure the dbus logger was suppressed
1533
1640
self.assertEqual(0, counting_handler.count)
1555
1662
self.call_method(bus, "methodname", "busname",
1556
1663
"objectpath", "interface")
1557
1664
1558
class fake_dbus_python_raises_exception_on_connect(object):
1665
class fake_dbus_python_raises_exception_on_connect:
1559
1666
"""fake dbus-python module"""
1560
class exceptions(object):
1667
class exceptions:
1561
1668
"""Pseudo-namespace"""
1562
1669
class DBusException(Exception):
1563
1670
pass
1571
1678
1572
1679
1573
1680
class Test_dbus_python_adapter_CachingBus(unittest.TestCase):
1574
class mock_dbus_python(object):
1681
class mock_dbus_python:
1575
1682
"""mock dbus-python modules"""
1576
class SystemBus(object):
1683
class SystemBus:
1577
1684
@staticmethod
1578
1685
def get_object(busname, objectpath):
1579
1686
return Unique()
1625
1732
class Test_pydbus_adapter_SystemBus(TestCaseWithAssertLogs):
1626
1733
1627
1734
def Stub_pydbus_func(self, func):
1628
class stub_pydbus(object):
1735
class stub_pydbus:
1629
1736
"""stub pydbus module"""
1630
class SystemBus(object):
1737
class SystemBus:
1631
1738
@staticmethod
1632
1739
def get(busname, objectpath):
1633
1740
DBusObject = collections.namedtuple(
1670
1777
self.call_method(bus, "methodname", "busname",
1671
1778
"objectpath", "interface")
1672
1779
1673
self.assertNotIsInstance(e, dbus.ConnectFailed)
1780
self.assertNotIsInstance(e.exception, dbus.ConnectFailed)
1674
1781
1675
1782
def test_get_converts_to_correct_exception(self):
1676
1783
bus = pydbus_adapter.SystemBus(
1679
1786
self.call_method(bus, "methodname", "busname",
1680
1787
"objectpath", "interface")
1681
1788
1682
class fake_pydbus_raises_exception_on_connect(object):
1789
class fake_pydbus_raises_exception_on_connect:
1683
1790
"""fake dbus-python module"""
1684
1791
@classmethod
1685
1792
def SystemBus(cls):
1689
1796
return Bus(get=get)
1690
1797
1691
1798
def test_set_property_uses_setattr(self):
1692
class Object(object):
1799
class Object:
1693
1800
pass
1694
1801
obj = Object()
1695
class pydbus_spy(object):
1696
class SystemBus(object):
1802
class pydbus_spy:
1803
class SystemBus:
1697
1804
@staticmethod
1698
1805
def get(busname, objectpath):
1699
1806
return {"interface": obj}
1706
1813
def test_get_suppresses_xml_deprecation_warning(self):
1707
1814
if sys.version_info.major >= 3:
1708
1815
return
1709
class stub_pydbus_get(object):
1710
class SystemBus(object):
1816
class stub_pydbus_get:
1817
class SystemBus:
1711
1818
@staticmethod
1712
1819
def get(busname, objectpath):
1713
1820
warnings.warn_explicit(
1721
1828
1722
1829
1723
1830
class Test_pydbus_adapter_CachingBus(unittest.TestCase):
1724
class stub_pydbus(object):
1831
class stub_pydbus:
1725
1832
"""stub pydbus module"""
1726
class SystemBus(object):
1833
class SystemBus:
1727
1834
@staticmethod
1728
1835
def get(busname, objectpath):
1729
1836
return Unique()
1771
1878
self.assertIs(obj1, obj1b)
1772
1879
1773
1880
1881
class Test_dbussy_adapter_SystemBus(TestCaseWithAssertLogs):
1882
1883
class dummy_dbussy:
1884
class DBUS:
1885
class ObjectPath(str):
1886
pass
1887
class DBusError(Exception):
1888
pass
1889
1890
def fake_ravel_func(self, func):
1891
class fake_ravel:
1892
@staticmethod
1893
def system_bus():
1894
class DBusInterfaceProxy:
1895
@staticmethod
1896
def methodname(*args):
1897
return [func(*args)]
1898
class DBusObject:
1899
@staticmethod
1900
def get_interface(interface):
1901
if interface == "interface":
1902
return DBusInterfaceProxy()
1903
return {"busname": {"objectpath": DBusObject()}}
1904
return fake_ravel
1905
1906
def call_method(self, bus, methodname, busname, objectpath,
1907
interface, *args):
1908
with self.assertLogs(log, logging.DEBUG):
1909
return bus.call_method(methodname, busname, objectpath,
1910
interface, *args)
1911
1912
def test_call_method_returns(self):
1913
expected_method_return = Unique()
1914
method_args = (Unique(), Unique())
1915
def func(*args):
1916
self.assertEqual(len(method_args), len(args))
1917
for marg, arg in zip(method_args, args):
1918
self.assertIs(marg, arg)
1919
return expected_method_return
1920
fake_ravel = self.fake_ravel_func(func)
1921
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1922
ret = self.call_method(bus, "methodname", "busname",
1923
"objectpath", "interface",
1924
*method_args)
1925
self.assertIs(ret, expected_method_return)
1926
1927
def test_call_method_filters_objectpath(self):
1928
def func():
1929
return method_return
1930
fake_ravel = self.fake_ravel_func(func)
1931
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1932
method_return = (self.dummy_dbussy.DBUS
1933
.ObjectPath("objectpath"))
1934
ret = self.call_method(bus, "methodname", "busname",
1935
"objectpath", "interface")
1936
self.assertEqual("objectpath", ret)
1937
self.assertNotIsInstance(ret,
1938
self.dummy_dbussy.DBUS.ObjectPath)
1939
1940
def test_call_method_filters_objectpaths_in_dict(self):
1941
ObjectPath = self.dummy_dbussy.DBUS.ObjectPath
1942
def func():
1943
return method_return
1944
fake_ravel = self.fake_ravel_func(func)
1945
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1946
method_return = {
1947
ObjectPath("objectpath_key_1"):
1948
ObjectPath("objectpath_value_1"),
1949
ObjectPath("objectpath_key_2"):
1950
ObjectPath("objectpath_value_2"),
1951
}
1952
ret = self.call_method(bus, "methodname", "busname",
1953
"objectpath", "interface")
1954
expected_method_return = {str(key): str(value)
1955
for key, value in
1956
method_return.items()}
1957
for key, value in ret.items():
1958
self.assertNotIsInstance(key, ObjectPath)
1959
self.assertNotIsInstance(value, ObjectPath)
1960
self.assertEqual(expected_method_return, ret)
1961
self.assertIsInstance(ret, dict)
1962
1963
def test_call_method_filters_objectpaths_in_dict_in_dict(self):
1964
ObjectPath = self.dummy_dbussy.DBUS.ObjectPath
1965
def func():
1966
return method_return
1967
fake_ravel = self.fake_ravel_func(func)
1968
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1969
method_return = {
1970
ObjectPath("key1"): {
1971
ObjectPath("key11"): ObjectPath("value11"),
1972
ObjectPath("key12"): ObjectPath("value12"),
1973
},
1974
ObjectPath("key2"): {
1975
ObjectPath("key21"): ObjectPath("value21"),
1976
ObjectPath("key22"): ObjectPath("value22"),
1977
},
1978
}
1979
ret = self.call_method(bus, "methodname", "busname",
1980
"objectpath", "interface")
1981
expected_method_return = {
1982
"key1": {"key11": "value11",
1983
"key12": "value12"},
1984
"key2": {"key21": "value21",
1985
"key22": "value22"},
1986
}
1987
self.assertEqual(expected_method_return, ret)
1988
for key, value in ret.items():
1989
self.assertIsInstance(value, dict)
1990
self.assertEqual(expected_method_return[key], value)
1991
self.assertNotIsInstance(key, ObjectPath)
1992
for inner_key, inner_value in value.items():
1993
self.assertIsInstance(value, dict)
1994
self.assertEqual(
1995
expected_method_return[key][inner_key],
1996
inner_value)
1997
self.assertNotIsInstance(key, ObjectPath)
1998
1999
def test_call_method_filters_objectpaths_in_dict_three_deep(self):
2000
ObjectPath = self.dummy_dbussy.DBUS.ObjectPath
2001
def func():
2002
return method_return
2003
fake_ravel = self.fake_ravel_func(func)
2004
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
2005
method_return = {
2006
ObjectPath("key1"): {
2007
ObjectPath("key2"): {
2008
ObjectPath("key3"): ObjectPath("value"),
2009
},
2010
},
2011
}
2012
ret = self.call_method(bus, "methodname", "busname",
2013
"objectpath", "interface")
2014
expected_method_return = {"key1": {"key2": {"key3": "value"}}}
2015
self.assertEqual(expected_method_return, ret)
2016
self.assertIsInstance(ret, dict)
2017
self.assertNotIsInstance(next(iter(ret.keys())), ObjectPath)
2018
self.assertIsInstance(ret["key1"], dict)
2019
self.assertNotIsInstance(next(iter(ret["key1"].keys())),
2020
ObjectPath)
2021
self.assertIsInstance(ret["key1"]["key2"], dict)
2022
self.assertNotIsInstance(
2023
next(iter(ret["key1"]["key2"].keys())),
2024
ObjectPath)
2025
self.assertEqual("value", ret["key1"]["key2"]["key3"])
2026
self.assertNotIsInstance(ret["key1"]["key2"]["key3"],
2027
self.dummy_dbussy.DBUS.ObjectPath)
2028
2029
def test_call_method_handles_exception(self):
2030
def func():
2031
raise self.dummy_dbussy.DBusError()
2032
2033
fake_ravel = self.fake_ravel_func(func)
2034
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
2035
2036
with self.assertRaises(dbus.Error) as e:
2037
self.call_method(bus, "methodname", "busname",
2038
"objectpath", "interface")
2039
2040
self.assertNotIsInstance(e.exception, dbus.ConnectFailed)
2041
2042
def test_get_object_converts_to_correct_exception(self):
2043
class fake_ravel_raises_exception_on_connect:
2044
@staticmethod
2045
def system_bus():
2046
class Bus:
2047
@staticmethod
2048
def __getitem__(key):
2049
if key == "objectpath":
2050
raise self.dummy_dbussy.DBusError()
2051
raise Exception(key)
2052
return {"busname": Bus()}
2053
def func():
2054
raise self.dummy_dbussy.DBusError()
2055
bus = dbussy_adapter.SystemBus(
2056
self.dummy_dbussy,
2057
fake_ravel_raises_exception_on_connect)
2058
with self.assertRaises(dbus.ConnectFailed):
2059
self.call_method(bus, "methodname", "busname",
2060
"objectpath", "interface")
2061
2062
1774
2063
class Test_commands_from_options(unittest.TestCase):
1775
2064
1776
2065
def setUp(self):
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0