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.600
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.600
- Committer: Teddy Hogeborn
- Date: 2019-03-12 17:33:44 UTC
- mto: This revision was merged to the branch mainline in revision 382.
- Revision ID: teddy@recompile.se-20190312173344-13d0hhhkmwu3up78
mandos-ctl: Refactor
* mandos-ctl (domain): Rename to "dbus_busname_domain". Delete after
use.
(busname): Rename to "dbus_busname". All users changed.
(server_path): Rename to "server_dbus_path". All users changed.
(server_interface): Rename to "server_dbus_interface". All users
changed.
(client_interface): Rename to "client_dbus_interface". All users
changed.
* mandos-ctl (domain): Rename to "dbus_busname_domain". Delete after
use.
(busname): Rename to "dbus_busname". All users changed.
(server_path): Rename to "server_dbus_path". All users changed.
(server_interface): Rename to "server_dbus_interface". All users
changed.
(client_interface): Rename to "client_dbus_interface". All users
changed.
- files added:
- bugs.xml
- files removed:
- initramfs-tools-hook-conf
- files modified:
- DBUS-API
added
removed
mandos-ctl
1
1
#!/usr/bin/python
2
# -*- mode: python; coding: utf-8 -*-
3
#
2
# -*- mode: python; coding: utf-8; after-save-hook: (lambda () (let ((command (if (and (boundp 'tramp-file-name-structure) (string-match (car tramp-file-name-structure) (buffer-file-name))) (tramp-file-name-localname (tramp-dissect-file-name (buffer-file-name))) (buffer-file-name)))) (if (= (shell-command (format "%s --check" (shell-quote-argument command)) "*Test*") 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w)) (kill-buffer "*Test*")) (display-buffer "*Test*")))); -*-
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
#
6
# Copyright © 2008-2015 Teddy Hogeborn
7
# Copyright © 2008-2015 Björn Påhlsson
8
#
9
# This program is free software: you can redistribute it and/or modify
10
# it under the terms of the GNU General Public License as published by
5
#
6
# Copyright © 2008-2019 Teddy Hogeborn
7
# Copyright © 2008-2019 Björn Påhlsson
8
#
9
# This file is part of Mandos.
10
#
11
# Mandos is free software: you can redistribute it and/or modify it
12
# under the terms of the GNU General Public License as published by
11
13
# the Free Software Foundation, either version 3 of the License, or
12
14
# (at your option) any later version.
13
15
#
14
# This program is distributed in the hope that it will be useful,
15
# but WITHOUT ANY WARRANTY; without even the implied warranty of
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
16
18
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
19
# GNU General Public License for more details.
18
#
20
#
19
21
# You should have received a copy of the GNU General Public License
20
# along with this program. If not, see
21
# <http://www.gnu.org/licenses/>.
22
#
22
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
23
#
23
24
# Contact the authors at <mandos@recompile.se>.
24
#
25
#
25
26
26
27
from __future__ import (division, absolute_import, print_function,
27
28
unicode_literals)
38
39
import re
39
40
import os
40
41
import collections
41
import doctest
42
import json
43
import unittest
44
import logging
45
import io
46
import tempfile
47
import contextlib
42
48
43
49
import dbus
44
50
51
# Show warnings by default
52
if not sys.warnoptions:
53
import warnings
54
warnings.simplefilter("default")
55
56
log = logging.getLogger(sys.argv[0])
57
logging.basicConfig(level="INFO", # Show info level messages
58
format="%(message)s") # Show basic log messages
59
60
logging.captureWarnings(True) # Show warnings via the logging system
61
45
62
if sys.version_info.major == 2:
46
63
str = unicode
47
64
48
65
locale.setlocale(locale.LC_ALL, "")
49
66
50
tablewords = {
51
"Name": "Name",
52
"Enabled": "Enabled",
53
"Timeout": "Timeout",
54
"LastCheckedOK": "Last Successful Check",
55
"LastApprovalRequest": "Last Approval Request",
56
"Created": "Created",
57
"Interval": "Interval",
58
"Host": "Host",
59
"Fingerprint": "Fingerprint",
60
"CheckerRunning": "Check Is Running",
61
"LastEnabled": "Last Enabled",
62
"ApprovalPending": "Approval Is Pending",
63
"ApprovedByDefault": "Approved By Default",
64
"ApprovalDelay": "Approval Delay",
65
"ApprovalDuration": "Approval Duration",
66
"Checker": "Checker",
67
"ExtendedTimeout": "Extended Timeout"
68
}
69
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
70
domain = "se.recompile"
71
busname = domain + ".Mandos"
72
server_path = "/"
73
server_interface = domain + ".Mandos"
74
client_interface = domain + ".Mandos.Client"
75
version = "1.6.9"
67
dbus_busname_domain = "se.recompile"
68
dbus_busname = dbus_busname_domain + ".Mandos"
69
server_dbus_path = "/"
70
server_dbus_interface = dbus_busname_domain + ".Mandos"
71
client_dbus_interface = dbus_busname_domain + ".Mandos.Client"
72
del dbus_busname_domain
73
version = "1.8.3"
74
75
76
try:
77
dbus.OBJECT_MANAGER_IFACE
78
except AttributeError:
79
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
76
80
77
81
78
82
def milliseconds_to_string(ms):
79
83
td = datetime.timedelta(0, 0, 0, ms)
80
return ("{days}{hours:02}:{minutes:02}:{seconds:02}".format(
81
days = "{}T".format(td.days) if td.days else "",
82
hours = td.seconds // 3600,
83
minutes = (td.seconds % 3600) // 60,
84
seconds = td.seconds % 60))
84
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
85
.format(days="{}T".format(td.days) if td.days else "",
86
hours=td.seconds // 3600,
87
minutes=(td.seconds % 3600) // 60,
88
seconds=td.seconds % 60))
85
89
86
90
87
91
def rfc3339_duration_to_delta(duration):
88
92
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
89
93
90
94
>>> rfc3339_duration_to_delta("P7D")
91
95
datetime.timedelta(7)
92
96
>>> rfc3339_duration_to_delta("PT60S")
93
97
datetime.timedelta(0, 60)
94
98
>>> rfc3339_duration_to_delta("PT60M")
95
99
datetime.timedelta(0, 3600)
100
>>> rfc3339_duration_to_delta("P60M")
101
datetime.timedelta(1680)
96
102
>>> rfc3339_duration_to_delta("PT24H")
97
103
datetime.timedelta(1)
98
104
>>> rfc3339_duration_to_delta("P1W")
101
107
datetime.timedelta(0, 330)
102
108
>>> rfc3339_duration_to_delta("P1DT3M20S")
103
109
datetime.timedelta(1, 200)
110
>>> # Can not be empty:
111
>>> rfc3339_duration_to_delta("")
112
Traceback (most recent call last):
113
...
114
ValueError: Invalid RFC 3339 duration: u''
115
>>> # Must start with "P":
116
>>> rfc3339_duration_to_delta("1D")
117
Traceback (most recent call last):
118
...
119
ValueError: Invalid RFC 3339 duration: u'1D'
120
>>> # Must use correct order
121
>>> rfc3339_duration_to_delta("PT1S2M")
122
Traceback (most recent call last):
123
...
124
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
125
>>> # Time needs time marker
126
>>> rfc3339_duration_to_delta("P1H2S")
127
Traceback (most recent call last):
128
...
129
ValueError: Invalid RFC 3339 duration: u'P1H2S'
130
>>> # Weeks can not be combined with anything else
131
>>> rfc3339_duration_to_delta("P1D2W")
132
Traceback (most recent call last):
133
...
134
ValueError: Invalid RFC 3339 duration: u'P1D2W'
135
>>> rfc3339_duration_to_delta("P2W2H")
136
Traceback (most recent call last):
137
...
138
ValueError: Invalid RFC 3339 duration: u'P2W2H'
104
139
"""
105
140
106
141
# Parsing an RFC 3339 duration with regular expressions is not
107
142
# possible - there would have to be multiple places for the same
108
143
# values, like seconds. The current code, while more esoteric, is
109
144
# cleaner without depending on a parsing library. If Python had a
110
145
# built-in library for parsing we would use it, but we'd like to
111
146
# avoid excessive use of external libraries.
112
147
113
148
# New type for defining tokens, syntax, and semantics all-in-one
114
149
Token = collections.namedtuple("Token", (
115
150
"regexp", # To match token; if "value" is not None, must have
148
183
frozenset((token_year, token_month,
149
184
token_day, token_time,
150
185
token_week)))
151
# Define starting values
152
value = datetime.timedelta() # Value so far
186
# Define starting values:
187
# Value so far
188
value = datetime.timedelta()
153
189
found_token = None
154
followers = frozenset((token_duration, )) # Following valid tokens
155
s = duration # String left to parse
190
# Following valid tokens
191
followers = frozenset((token_duration, ))
192
# String left to parse
193
s = duration
156
194
# Loop until end token is found
157
195
while found_token is not token_end:
158
196
# Search for any currently valid tokens
181
219
182
220
183
221
def string_to_delta(interval):
184
"""Parse a string and return a datetime.timedelta
185
186
>>> string_to_delta('7d')
187
datetime.timedelta(7)
188
>>> string_to_delta('60s')
189
datetime.timedelta(0, 60)
190
>>> string_to_delta('60m')
191
datetime.timedelta(0, 3600)
192
>>> string_to_delta('24h')
193
datetime.timedelta(1)
194
>>> string_to_delta('1w')
195
datetime.timedelta(7)
196
>>> string_to_delta('5m 30s')
197
datetime.timedelta(0, 330)
198
"""
199
222
"""Parse a string and return a datetime.timedelta"""
223
200
224
try:
201
225
return rfc3339_duration_to_delta(interval)
202
except ValueError:
203
pass
204
226
except ValueError as e:
227
log.warning("%s - Parsing as pre-1.6.1 interval instead",
228
' '.join(e.args))
229
return parse_pre_1_6_1_interval(interval)
230
231
232
def parse_pre_1_6_1_interval(interval):
233
"""Parse an interval string as documented by Mandos before 1.6.1,
234
and return a datetime.timedelta
235
236
>>> parse_pre_1_6_1_interval('7d')
237
datetime.timedelta(7)
238
>>> parse_pre_1_6_1_interval('60s')
239
datetime.timedelta(0, 60)
240
>>> parse_pre_1_6_1_interval('60m')
241
datetime.timedelta(0, 3600)
242
>>> parse_pre_1_6_1_interval('24h')
243
datetime.timedelta(1)
244
>>> parse_pre_1_6_1_interval('1w')
245
datetime.timedelta(7)
246
>>> parse_pre_1_6_1_interval('5m 30s')
247
datetime.timedelta(0, 330)
248
>>> parse_pre_1_6_1_interval('')
249
datetime.timedelta(0)
250
>>> # Ignore unknown characters, allow any order and repetitions
251
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')
252
datetime.timedelta(2, 480, 18000)
253
254
"""
255
205
256
value = datetime.timedelta(0)
206
257
regexp = re.compile(r"(\d+)([dsmhw]?)")
207
258
208
259
for num, suffix in regexp.findall(interval):
209
260
if suffix == "d":
210
261
value += datetime.timedelta(int(num))
221
272
return value
222
273
223
274
224
def print_clients(clients, keywords):
225
def valuetostring(value, keyword):
226
if type(value) is dbus.Boolean:
227
return "Yes" if value else "No"
228
if keyword in ("Timeout", "Interval", "ApprovalDelay",
229
"ApprovalDuration", "ExtendedTimeout"):
230
return milliseconds_to_string(value)
231
return str(value)
232
233
# Create format string to print table rows
234
format_string = " ".join("{{{key}:{width}}}".format(
235
width = max(len(tablewords[key]),
236
max(len(valuetostring(client[key], key))
237
for client in clients)),
238
key = key)
239
for key in keywords)
240
# Print header line
241
print(format_string.format(**tablewords))
242
for client in clients:
243
print(format_string.format(**{
244
key: valuetostring(client[key], key)
245
for key in keywords }))
246
247
248
def has_actions(options):
249
return any((options.enable,
250
options.disable,
251
options.bump_timeout,
252
options.start_checker,
253
options.stop_checker,
254
options.is_enabled,
255
options.remove,
256
options.checker is not None,
257
options.timeout is not None,
258
options.extended_timeout is not None,
259
options.interval is not None,
260
options.approved_by_default is not None,
261
options.approval_delay is not None,
262
options.approval_duration is not None,
263
options.host is not None,
264
options.secret is not None,
265
options.approve,
266
options.deny))
267
268
269
def main():
270
parser = argparse.ArgumentParser()
275
## Classes for commands.
276
277
# Abstract classes first
278
class Command(object):
279
"""Abstract class for commands"""
280
def run(self, clients, bus=None, mandos=None):
281
"""Normal commands should implement run_on_one_client(), but
282
commands which want to operate on all clients at the same time
283
can override this run() method instead."""
284
self.mandos = mandos
285
for clientpath, properties in clients.items():
286
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
287
dbus_busname, str(clientpath))
288
client = bus.get_object(dbus_busname, clientpath)
289
self.run_on_one_client(client, properties)
290
291
class PrintCmd(Command):
292
"""Abstract class for commands printing client details"""
293
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
294
"Created", "Interval", "Host", "KeyID",
295
"Fingerprint", "CheckerRunning", "LastEnabled",
296
"ApprovalPending", "ApprovedByDefault",
297
"LastApprovalRequest", "ApprovalDelay",
298
"ApprovalDuration", "Checker", "ExtendedTimeout",
299
"Expires", "LastCheckerStatus")
300
def run(self, clients, bus=None, mandos=None):
301
print(self.output(clients.values()))
302
def output(self, clients):
303
raise NotImplementedError()
304
305
class PropertyCmd(Command):
306
"""Abstract class for Actions for setting one client property"""
307
def run_on_one_client(self, client, properties):
308
"""Set the Client's D-Bus property"""
309
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,
310
client.__dbus_object_path__,
311
dbus.PROPERTIES_IFACE, client_dbus_interface,
312
self.propname, self.value_to_set
313
if not isinstance(self.value_to_set, dbus.Boolean)
314
else bool(self.value_to_set))
315
client.Set(client_dbus_interface, self.propname,
316
self.value_to_set,
317
dbus_interface=dbus.PROPERTIES_IFACE)
318
@property
319
def propname(self):
320
raise NotImplementedError()
321
322
class PropertyValueCmd(PropertyCmd):
323
"""Abstract class for PropertyCmd recieving a value as argument"""
324
def __init__(self, value):
325
self.value_to_set = value
326
327
class MillisecondsPropertyValueArgumentCmd(PropertyValueCmd):
328
"""Abstract class for PropertyValueCmd taking a value argument as
329
a datetime.timedelta() but should store it as milliseconds."""
330
@property
331
def value_to_set(self):
332
return self._vts
333
@value_to_set.setter
334
def value_to_set(self, value):
335
"""When setting, convert value from a datetime.timedelta"""
336
self._vts = int(round(value.total_seconds() * 1000))
337
338
# Actual (non-abstract) command classes
339
340
class PrintTableCmd(PrintCmd):
341
def __init__(self, verbose=False):
342
self.verbose = verbose
343
344
def output(self, clients):
345
default_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
346
keywords = default_keywords
347
if self.verbose:
348
keywords = self.all_keywords
349
return str(self.TableOfClients(clients, keywords))
350
351
class TableOfClients(object):
352
tableheaders = {
353
"Name": "Name",
354
"Enabled": "Enabled",
355
"Timeout": "Timeout",
356
"LastCheckedOK": "Last Successful Check",
357
"LastApprovalRequest": "Last Approval Request",
358
"Created": "Created",
359
"Interval": "Interval",
360
"Host": "Host",
361
"Fingerprint": "Fingerprint",
362
"KeyID": "Key ID",
363
"CheckerRunning": "Check Is Running",
364
"LastEnabled": "Last Enabled",
365
"ApprovalPending": "Approval Is Pending",
366
"ApprovedByDefault": "Approved By Default",
367
"ApprovalDelay": "Approval Delay",
368
"ApprovalDuration": "Approval Duration",
369
"Checker": "Checker",
370
"ExtendedTimeout": "Extended Timeout",
371
"Expires": "Expires",
372
"LastCheckerStatus": "Last Checker Status",
373
}
374
375
def __init__(self, clients, keywords, tableheaders=None):
376
self.clients = clients
377
self.keywords = keywords
378
if tableheaders is not None:
379
self.tableheaders = tableheaders
380
381
def __str__(self):
382
return "\n".join(self.rows())
383
384
if sys.version_info.major == 2:
385
__unicode__ = __str__
386
def __str__(self):
387
return str(self).encode(locale.getpreferredencoding())
388
389
def rows(self):
390
format_string = self.row_formatting_string()
391
rows = [self.header_line(format_string)]
392
rows.extend(self.client_line(client, format_string)
393
for client in self.clients)
394
return rows
395
396
def row_formatting_string(self):
397
"Format string used to format table rows"
398
return " ".join("{{{key}:{width}}}".format(
399
width=max(len(self.tableheaders[key]),
400
*(len(self.string_from_client(client, key))
401
for client in self.clients)),
402
key=key)
403
for key in self.keywords)
404
405
def string_from_client(self, client, key):
406
return self.valuetostring(client[key], key)
407
408
@staticmethod
409
def valuetostring(value, keyword):
410
if isinstance(value, dbus.Boolean):
411
return "Yes" if value else "No"
412
if keyword in ("Timeout", "Interval", "ApprovalDelay",
413
"ApprovalDuration", "ExtendedTimeout"):
414
return milliseconds_to_string(value)
415
return str(value)
416
417
def header_line(self, format_string):
418
return format_string.format(**self.tableheaders)
419
420
def client_line(self, client, format_string):
421
return format_string.format(
422
**{key: self.string_from_client(client, key)
423
for key in self.keywords})
424
425
426
427
class DumpJSONCmd(PrintCmd):
428
def output(self, clients):
429
data = {client["Name"]:
430
{key: self.dbus_boolean_to_bool(client[key])
431
for key in self.all_keywords}
432
for client in clients.values()}
433
return json.dumps(data, indent=4, separators=(',', ': '))
434
@staticmethod
435
def dbus_boolean_to_bool(value):
436
if isinstance(value, dbus.Boolean):
437
value = bool(value)
438
return value
439
440
class IsEnabledCmd(Command):
441
def run(self, clients, bus=None, mandos=None):
442
client, properties = next(iter(clients.items()))
443
if self.is_enabled(client, properties):
444
sys.exit(0)
445
sys.exit(1)
446
def is_enabled(self, client, properties):
447
return properties["Enabled"]
448
449
class RemoveCmd(Command):
450
def run_on_one_client(self, client, properties):
451
log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)", dbus_busname,
452
server_dbus_path, server_dbus_interface,
453
str(client.__dbus_object_path__))
454
self.mandos.RemoveClient(client.__dbus_object_path__)
455
456
class ApproveCmd(Command):
457
def run_on_one_client(self, client, properties):
458
log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,
459
client.__dbus_object_path__, client_dbus_interface)
460
client.Approve(dbus.Boolean(True),
461
dbus_interface=client_dbus_interface)
462
463
class DenyCmd(Command):
464
def run_on_one_client(self, client, properties):
465
log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,
466
client.__dbus_object_path__, client_dbus_interface)
467
client.Approve(dbus.Boolean(False),
468
dbus_interface=client_dbus_interface)
469
470
class EnableCmd(PropertyCmd):
471
propname = "Enabled"
472
value_to_set = dbus.Boolean(True)
473
474
class DisableCmd(PropertyCmd):
475
propname = "Enabled"
476
value_to_set = dbus.Boolean(False)
477
478
class BumpTimeoutCmd(PropertyCmd):
479
propname = "LastCheckedOK"
480
value_to_set = ""
481
482
class StartCheckerCmd(PropertyCmd):
483
propname = "CheckerRunning"
484
value_to_set = dbus.Boolean(True)
485
486
class StopCheckerCmd(PropertyCmd):
487
propname = "CheckerRunning"
488
value_to_set = dbus.Boolean(False)
489
490
class ApproveByDefaultCmd(PropertyCmd):
491
propname = "ApprovedByDefault"
492
value_to_set = dbus.Boolean(True)
493
494
class DenyByDefaultCmd(PropertyCmd):
495
propname = "ApprovedByDefault"
496
value_to_set = dbus.Boolean(False)
497
498
class SetCheckerCmd(PropertyValueCmd):
499
propname = "Checker"
500
501
class SetHostCmd(PropertyValueCmd):
502
propname = "Host"
503
504
class SetSecretCmd(PropertyValueCmd):
505
propname = "Secret"
506
@property
507
def value_to_set(self):
508
return self._vts
509
@value_to_set.setter
510
def value_to_set(self, value):
511
"""When setting, read data from supplied file object"""
512
self._vts = value.read()
513
value.close()
514
515
class SetTimeoutCmd(MillisecondsPropertyValueArgumentCmd):
516
propname = "Timeout"
517
518
class SetExtendedTimeoutCmd(MillisecondsPropertyValueArgumentCmd):
519
propname = "ExtendedTimeout"
520
521
class SetIntervalCmd(MillisecondsPropertyValueArgumentCmd):
522
propname = "Interval"
523
524
class SetApprovalDelayCmd(MillisecondsPropertyValueArgumentCmd):
525
propname = "ApprovalDelay"
526
527
class SetApprovalDurationCmd(MillisecondsPropertyValueArgumentCmd):
528
propname = "ApprovalDuration"
529
530
def add_command_line_options(parser):
271
531
parser.add_argument("--version", action="version",
272
version = "%(prog)s {}".format(version),
532
version="%(prog)s {}".format(version),
273
533
help="show version number and exit")
274
534
parser.add_argument("-a", "--all", action="store_true",
275
535
help="Select all clients")
276
536
parser.add_argument("-v", "--verbose", action="store_true",
277
537
help="Print all fields")
278
parser.add_argument("-e", "--enable", action="store_true",
279
help="Enable client")
280
parser.add_argument("-d", "--disable", action="store_true",
281
help="disable client")
538
parser.add_argument("-j", "--dump-json", action="store_true",
539
help="Dump client data in JSON format")
540
enable_disable = parser.add_mutually_exclusive_group()
541
enable_disable.add_argument("-e", "--enable", action="store_true",
542
help="Enable client")
543
enable_disable.add_argument("-d", "--disable",
544
action="store_true",
545
help="disable client")
282
546
parser.add_argument("-b", "--bump-timeout", action="store_true",
283
547
help="Bump timeout for client")
284
parser.add_argument("--start-checker", action="store_true",
285
help="Start checker for client")
286
parser.add_argument("--stop-checker", action="store_true",
287
help="Stop checker for client")
548
start_stop_checker = parser.add_mutually_exclusive_group()
549
start_stop_checker.add_argument("--start-checker",
550
action="store_true",
551
help="Start checker for client")
552
start_stop_checker.add_argument("--stop-checker",
553
action="store_true",
554
help="Stop checker for client")
288
555
parser.add_argument("-V", "--is-enabled", action="store_true",
289
556
help="Check if client is enabled")
290
557
parser.add_argument("-r", "--remove", action="store_true",
291
558
help="Remove client")
292
559
parser.add_argument("-c", "--checker",
293
560
help="Set checker command for client")
294
parser.add_argument("-t", "--timeout",
561
parser.add_argument("-t", "--timeout", type=string_to_delta,
295
562
help="Set timeout for client")
296
parser.add_argument("--extended-timeout",
563
parser.add_argument("--extended-timeout", type=string_to_delta,
297
564
help="Set extended timeout for client")
298
parser.add_argument("-i", "--interval",
565
parser.add_argument("-i", "--interval", type=string_to_delta,
299
566
help="Set checker interval for client")
300
parser.add_argument("--approve-by-default", action="store_true",
301
default=None, dest="approved_by_default",
302
help="Set client to be approved by default")
303
parser.add_argument("--deny-by-default", action="store_false",
304
dest="approved_by_default",
305
help="Set client to be denied by default")
306
parser.add_argument("--approval-delay",
567
approve_deny_default = parser.add_mutually_exclusive_group()
568
approve_deny_default.add_argument(
569
"--approve-by-default", action="store_true",
570
default=None, dest="approved_by_default",
571
help="Set client to be approved by default")
572
approve_deny_default.add_argument(
573
"--deny-by-default", action="store_false",
574
dest="approved_by_default",
575
help="Set client to be denied by default")
576
parser.add_argument("--approval-delay", type=string_to_delta,
307
577
help="Set delay before client approve/deny")
308
parser.add_argument("--approval-duration",
578
parser.add_argument("--approval-duration", type=string_to_delta,
309
579
help="Set duration of one client approval")
310
580
parser.add_argument("-H", "--host", help="Set host for client")
311
581
parser.add_argument("-s", "--secret",
312
582
type=argparse.FileType(mode="rb"),
313
583
help="Set password blob (file) for client")
314
parser.add_argument("-A", "--approve", action="store_true",
315
help="Approve any current client request")
316
parser.add_argument("-D", "--deny", action="store_true",
317
help="Deny any current client request")
584
approve_deny = parser.add_mutually_exclusive_group()
585
approve_deny.add_argument(
586
"-A", "--approve", action="store_true",
587
help="Approve any current client request")
588
approve_deny.add_argument("-D", "--deny", action="store_true",
589
help="Deny any current client request")
590
parser.add_argument("--debug", action="store_true",
591
help="Debug mode (show D-Bus commands)")
318
592
parser.add_argument("--check", action="store_true",
319
593
help="Run self-test")
320
594
parser.add_argument("client", nargs="*", help="Client name")
321
options = parser.parse_args()
322
595
596
597
def commands_from_options(options):
598
599
commands = []
600
601
if options.dump_json:
602
commands.append(DumpJSONCmd())
603
604
if options.enable:
605
commands.append(EnableCmd())
606
607
if options.disable:
608
commands.append(DisableCmd())
609
610
if options.bump_timeout:
611
commands.append(BumpTimeoutCmd())
612
613
if options.start_checker:
614
commands.append(StartCheckerCmd())
615
616
if options.stop_checker:
617
commands.append(StopCheckerCmd())
618
619
if options.is_enabled:
620
commands.append(IsEnabledCmd())
621
622
if options.checker is not None:
623
commands.append(SetCheckerCmd(options.checker))
624
625
if options.timeout is not None:
626
commands.append(SetTimeoutCmd(options.timeout))
627
628
if options.extended_timeout:
629
commands.append(
630
SetExtendedTimeoutCmd(options.extended_timeout))
631
632
if options.interval is not None:
633
commands.append(SetIntervalCmd(options.interval))
634
635
if options.approved_by_default is not None:
636
if options.approved_by_default:
637
commands.append(ApproveByDefaultCmd())
638
else:
639
commands.append(DenyByDefaultCmd())
640
641
if options.approval_delay is not None:
642
commands.append(SetApprovalDelayCmd(options.approval_delay))
643
644
if options.approval_duration is not None:
645
commands.append(
646
SetApprovalDurationCmd(options.approval_duration))
647
648
if options.host is not None:
649
commands.append(SetHostCmd(options.host))
650
651
if options.secret is not None:
652
commands.append(SetSecretCmd(options.secret))
653
654
if options.approve:
655
commands.append(ApproveCmd())
656
657
if options.deny:
658
commands.append(DenyCmd())
659
660
if options.remove:
661
commands.append(RemoveCmd())
662
663
# If no command option has been given, show table of clients,
664
# optionally verbosely
665
if not commands:
666
commands.append(PrintTableCmd(verbose=options.verbose))
667
668
return commands
669
670
671
def check_option_syntax(parser, options):
672
"""Apply additional restrictions on options, not expressible in
673
argparse"""
674
675
def has_actions(options):
676
return any((options.enable,
677
options.disable,
678
options.bump_timeout,
679
options.start_checker,
680
options.stop_checker,
681
options.is_enabled,
682
options.remove,
683
options.checker is not None,
684
options.timeout is not None,
685
options.extended_timeout is not None,
686
options.interval is not None,
687
options.approved_by_default is not None,
688
options.approval_delay is not None,
689
options.approval_duration is not None,
690
options.host is not None,
691
options.secret is not None,
692
options.approve,
693
options.deny))
694
323
695
if has_actions(options) and not (options.client or options.all):
324
696
parser.error("Options require clients names or --all.")
325
697
if options.verbose and has_actions(options):
326
parser.error("--verbose can only be used alone or with"
327
" --all.")
698
parser.error("--verbose can only be used alone.")
699
if options.dump_json and (options.verbose
700
or has_actions(options)):
701
parser.error("--dump-json can only be used alone.")
328
702
if options.all and not has_actions(options):
329
703
parser.error("--all requires an action.")
330
331
if options.check:
332
fail_count, test_count = doctest.testmod()
333
sys.exit(os.EX_OK if fail_count == 0 else 1)
334
704
if options.is_enabled and len(options.client) > 1:
705
parser.error("--is-enabled requires exactly one client")
706
if options.remove:
707
options.remove = False
708
if has_actions(options) and not options.deny:
709
parser.error("--remove can only be combined with --deny")
710
options.remove = True
711
712
713
def main():
714
parser = argparse.ArgumentParser()
715
716
add_command_line_options(parser)
717
718
options = parser.parse_args()
719
720
check_option_syntax(parser, options)
721
722
clientnames = options.client
723
724
if options.debug:
725
log.setLevel(logging.DEBUG)
726
335
727
try:
336
728
bus = dbus.SystemBus()
337
mandos_dbus_objc = bus.get_object(busname, server_path)
729
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
730
dbus_busname, server_dbus_path)
731
mandos_dbus_objc = bus.get_object(dbus_busname,
732
server_dbus_path)
338
733
except dbus.exceptions.DBusException:
339
print("Could not connect to Mandos server", file=sys.stderr)
734
log.critical("Could not connect to Mandos server")
340
735
sys.exit(1)
341
736
342
737
mandos_serv = dbus.Interface(mandos_dbus_objc,
343
dbus_interface = server_interface)
344
345
#block stderr since dbus library prints to stderr
346
null = os.open(os.path.devnull, os.O_RDWR)
347
stderrcopy = os.dup(sys.stderr.fileno())
348
os.dup2(null, sys.stderr.fileno())
349
os.close(null)
738
dbus_interface=server_dbus_interface)
739
mandos_serv_object_manager = dbus.Interface(
740
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
741
742
# Filter out log message from dbus module
743
dbus_logger = logging.getLogger("dbus.proxies")
744
class NullFilter(logging.Filter):
745
def filter(self, record):
746
return False
747
dbus_filter = NullFilter()
350
748
try:
749
dbus_logger.addFilter(dbus_filter)
750
log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", dbus_busname,
751
server_dbus_path, dbus.OBJECT_MANAGER_IFACE)
752
mandos_clients = {path: ifs_and_props[client_dbus_interface]
753
for path, ifs_and_props in
754
mandos_serv_object_manager
755
.GetManagedObjects().items()
756
if client_dbus_interface in ifs_and_props}
757
except dbus.exceptions.DBusException as e:
758
log.critical("Failed to access Mandos server through D-Bus:"
759
"\n%s", e)
760
sys.exit(1)
761
finally:
762
# restore dbus logger
763
dbus_logger.removeFilter(dbus_filter)
764
765
# Compile dict of (clients: properties) to process
766
clients = {}
767
768
if not clientnames:
769
clients = {objpath: properties
770
for objpath, properties in mandos_clients.items()}
771
else:
772
for name in clientnames:
773
for objpath, properties in mandos_clients.items():
774
if properties["Name"] == name:
775
clients[objpath] = properties
776
break
777
else:
778
log.critical("Client not found on server: %r", name)
779
sys.exit(1)
780
781
# Run all commands on clients
782
commands = commands_from_options(options)
783
for command in commands:
784
command.run(clients, bus, mandos_serv)
785
786
787
class Test_milliseconds_to_string(unittest.TestCase):
788
def test_all(self):
789
self.assertEqual(milliseconds_to_string(93785000),
790
"1T02:03:05")
791
def test_no_days(self):
792
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
793
def test_all_zero(self):
794
self.assertEqual(milliseconds_to_string(0), "00:00:00")
795
def test_no_fractional_seconds(self):
796
self.assertEqual(milliseconds_to_string(400), "00:00:00")
797
self.assertEqual(milliseconds_to_string(900), "00:00:00")
798
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
799
800
class Test_string_to_delta(unittest.TestCase):
801
def test_handles_basic_rfc3339(self):
802
self.assertEqual(string_to_delta("PT0S"),
803
datetime.timedelta())
804
self.assertEqual(string_to_delta("P0D"),
805
datetime.timedelta())
806
self.assertEqual(string_to_delta("PT1S"),
807
datetime.timedelta(0, 1))
808
self.assertEqual(string_to_delta("PT2H"),
809
datetime.timedelta(0, 7200))
810
def test_falls_back_to_pre_1_6_1_with_warning(self):
811
# assertLogs only exists in Python 3.4
812
if hasattr(self, "assertLogs"):
813
with self.assertLogs(log, logging.WARNING):
814
value = string_to_delta("2h")
815
else:
816
class WarningFilter(logging.Filter):
817
"""Don't show, but record the presence of, warnings"""
818
def filter(self, record):
819
is_warning = record.levelno >= logging.WARNING
820
self.found = is_warning or getattr(self, "found",
821
False)
822
return not is_warning
823
warning_filter = WarningFilter()
824
log.addFilter(warning_filter)
825
try:
826
value = string_to_delta("2h")
827
finally:
828
log.removeFilter(warning_filter)
829
self.assertTrue(getattr(warning_filter, "found", False))
830
self.assertEqual(value, datetime.timedelta(0, 7200))
831
832
833
class TestCmd(unittest.TestCase):
834
"""Abstract class for tests of command classes"""
835
def setUp(self):
836
testcase = self
837
class MockClient(object):
838
def __init__(self, name, **attributes):
839
self.__dbus_object_path__ = "/clients/{}".format(name)
840
self.attributes = attributes
841
self.attributes["Name"] = name
842
self.calls = []
843
def Set(self, interface, propname, value, dbus_interface):
844
testcase.assertEqual(interface, client_dbus_interface)
845
testcase.assertEqual(dbus_interface,
846
dbus.PROPERTIES_IFACE)
847
self.attributes[propname] = value
848
def Get(self, interface, propname, dbus_interface):
849
testcase.assertEqual(interface, client_dbus_interface)
850
testcase.assertEqual(dbus_interface,
851
dbus.PROPERTIES_IFACE)
852
return self.attributes[propname]
853
def Approve(self, approve, dbus_interface):
854
testcase.assertEqual(dbus_interface,
855
client_dbus_interface)
856
self.calls.append(("Approve", (approve,
857
dbus_interface)))
858
self.client = MockClient(
859
"foo",
860
KeyID=("92ed150794387c03ce684574b1139a65"
861
"94a34f895daaaf09fd8ea90a27cddb12"),
862
Secret=b"secret",
863
Host="foo.example.org",
864
Enabled=dbus.Boolean(True),
865
Timeout=300000,
866
LastCheckedOK="2019-02-03T00:00:00",
867
Created="2019-01-02T00:00:00",
868
Interval=120000,
869
Fingerprint=("778827225BA7DE539C5A"
870
"7CFA59CFF7CDBD9A5920"),
871
CheckerRunning=dbus.Boolean(False),
872
LastEnabled="2019-01-03T00:00:00",
873
ApprovalPending=dbus.Boolean(False),
874
ApprovedByDefault=dbus.Boolean(True),
875
LastApprovalRequest="",
876
ApprovalDelay=0,
877
ApprovalDuration=1000,
878
Checker="fping -q -- %(host)s",
879
ExtendedTimeout=900000,
880
Expires="2019-02-04T00:00:00",
881
LastCheckerStatus=0)
882
self.other_client = MockClient(
883
"barbar",
884
KeyID=("0558568eedd67d622f5c83b35a115f79"
885
"6ab612cff5ad227247e46c2b020f441c"),
886
Secret=b"secretbar",
887
Host="192.0.2.3",
888
Enabled=dbus.Boolean(True),
889
Timeout=300000,
890
LastCheckedOK="2019-02-04T00:00:00",
891
Created="2019-01-03T00:00:00",
892
Interval=120000,
893
Fingerprint=("3E393AEAEFB84C7E89E2"
894
"F547B3A107558FCA3A27"),
895
CheckerRunning=dbus.Boolean(True),
896
LastEnabled="2019-01-04T00:00:00",
897
ApprovalPending=dbus.Boolean(False),
898
ApprovedByDefault=dbus.Boolean(False),
899
LastApprovalRequest="2019-01-03T00:00:00",
900
ApprovalDelay=30000,
901
ApprovalDuration=1000,
902
Checker=":",
903
ExtendedTimeout=900000,
904
Expires="2019-02-05T00:00:00",
905
LastCheckerStatus=-2)
906
self.clients = collections.OrderedDict(
907
[
908
("/clients/foo", self.client.attributes),
909
("/clients/barbar", self.other_client.attributes),
910
])
911
self.one_client = {"/clients/foo": self.client.attributes}
912
@property
913
def bus(self):
914
class Bus(object):
915
@staticmethod
916
def get_object(client_bus_name, path):
917
self.assertEqual(client_bus_name, dbus_busname)
918
return {
919
"/clients/foo": self.client,
920
"/clients/barbar": self.other_client,
921
}[path]
922
return Bus()
923
924
class TestPrintTableCmd(TestCmd):
925
def test_normal(self):
926
output = PrintTableCmd().output(self.clients.values())
927
expected_output = """
928
Name Enabled Timeout Last Successful Check
929
foo Yes 00:05:00 2019-02-03T00:00:00
930
barbar Yes 00:05:00 2019-02-04T00:00:00
931
"""[1:-1]
932
self.assertEqual(output, expected_output)
933
def test_verbose(self):
934
output = PrintTableCmd(verbose=True).output(
935
self.clients.values())
936
expected_output = """
937
Name Enabled Timeout Last Successful Check Created Interval Host Key ID Fingerprint Check Is Running Last Enabled Approval Is Pending Approved By Default Last Approval Request Approval Delay Approval Duration Checker Extended Timeout Expires Last Checker Status
938
foo Yes 00:05:00 2019-02-03T00:00:00 2019-01-02T00:00:00 00:02:00 foo.example.org 92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8ea90a27cddb12 778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 No 2019-01-03T00:00:00 No Yes 00:00:00 00:00:01 fping -q -- %(host)s 00:15:00 2019-02-04T00:00:00 0
939
barbar Yes 00:05:00 2019-02-04T00:00:00 2019-01-03T00:00:00 00:02:00 192.0.2.3 0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e46c2b020f441c 3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 Yes 2019-01-04T00:00:00 No No 2019-01-03T00:00:00 00:00:30 00:00:01 : 00:15:00 2019-02-05T00:00:00 -2
940
"""[1:-1]
941
self.assertEqual(output, expected_output)
942
def test_one_client(self):
943
output = PrintTableCmd().output(self.one_client.values())
944
expected_output = """
945
Name Enabled Timeout Last Successful Check
946
foo Yes 00:05:00 2019-02-03T00:00:00
947
"""[1:-1]
948
self.assertEqual(output, expected_output)
949
950
class TestDumpJSONCmd(TestCmd):
951
def setUp(self):
952
self.expected_json = {
953
"foo": {
954
"Name": "foo",
955
"KeyID": ("92ed150794387c03ce684574b1139a65"
956
"94a34f895daaaf09fd8ea90a27cddb12"),
957
"Host": "foo.example.org",
958
"Enabled": True,
959
"Timeout": 300000,
960
"LastCheckedOK": "2019-02-03T00:00:00",
961
"Created": "2019-01-02T00:00:00",
962
"Interval": 120000,
963
"Fingerprint": ("778827225BA7DE539C5A"
964
"7CFA59CFF7CDBD9A5920"),
965
"CheckerRunning": False,
966
"LastEnabled": "2019-01-03T00:00:00",
967
"ApprovalPending": False,
968
"ApprovedByDefault": True,
969
"LastApprovalRequest": "",
970
"ApprovalDelay": 0,
971
"ApprovalDuration": 1000,
972
"Checker": "fping -q -- %(host)s",
973
"ExtendedTimeout": 900000,
974
"Expires": "2019-02-04T00:00:00",
975
"LastCheckerStatus": 0,
976
},
977
"barbar": {
978
"Name": "barbar",
979
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
980
"6ab612cff5ad227247e46c2b020f441c"),
981
"Host": "192.0.2.3",
982
"Enabled": True,
983
"Timeout": 300000,
984
"LastCheckedOK": "2019-02-04T00:00:00",
985
"Created": "2019-01-03T00:00:00",
986
"Interval": 120000,
987
"Fingerprint": ("3E393AEAEFB84C7E89E2"
988
"F547B3A107558FCA3A27"),
989
"CheckerRunning": True,
990
"LastEnabled": "2019-01-04T00:00:00",
991
"ApprovalPending": False,
992
"ApprovedByDefault": False,
993
"LastApprovalRequest": "2019-01-03T00:00:00",
994
"ApprovalDelay": 30000,
995
"ApprovalDuration": 1000,
996
"Checker": ":",
997
"ExtendedTimeout": 900000,
998
"Expires": "2019-02-05T00:00:00",
999
"LastCheckerStatus": -2,
1000
},
1001
}
1002
return super(TestDumpJSONCmd, self).setUp()
1003
def test_normal(self):
1004
json_data = json.loads(DumpJSONCmd().output(self.clients))
1005
self.assertDictEqual(json_data, self.expected_json)
1006
def test_one_client(self):
1007
clients = self.one_client
1008
json_data = json.loads(DumpJSONCmd().output(clients))
1009
expected_json = {"foo": self.expected_json["foo"]}
1010
self.assertDictEqual(json_data, expected_json)
1011
1012
class TestIsEnabledCmd(TestCmd):
1013
def test_is_enabled(self):
1014
self.assertTrue(all(IsEnabledCmd().is_enabled(client, properties)
1015
for client, properties in self.clients.items()))
1016
def test_is_enabled_run_exits_successfully(self):
1017
with self.assertRaises(SystemExit) as e:
1018
IsEnabledCmd().run(self.one_client)
1019
if e.exception.code is not None:
1020
self.assertEqual(e.exception.code, 0)
1021
else:
1022
self.assertIsNone(e.exception.code)
1023
def test_is_enabled_run_exits_with_failure(self):
1024
self.client.attributes["Enabled"] = dbus.Boolean(False)
1025
with self.assertRaises(SystemExit) as e:
1026
IsEnabledCmd().run(self.one_client)
1027
if isinstance(e.exception.code, int):
1028
self.assertNotEqual(e.exception.code, 0)
1029
else:
1030
self.assertIsNotNone(e.exception.code)
1031
1032
class TestRemoveCmd(TestCmd):
1033
def test_remove(self):
1034
class MockMandos(object):
1035
def __init__(self):
1036
self.calls = []
1037
def RemoveClient(self, dbus_path):
1038
self.calls.append(("RemoveClient", (dbus_path,)))
1039
mandos = MockMandos()
1040
super(TestRemoveCmd, self).setUp()
1041
RemoveCmd().run(self.clients, self.bus, mandos)
1042
self.assertEqual(len(mandos.calls), 2)
1043
for clientpath in self.clients:
1044
self.assertIn(("RemoveClient", (clientpath,)),
1045
mandos.calls)
1046
1047
class TestApproveCmd(TestCmd):
1048
def test_approve(self):
1049
ApproveCmd().run(self.clients, self.bus)
1050
for clientpath in self.clients:
1051
client = self.bus.get_object(dbus_busname, clientpath)
1052
self.assertIn(("Approve", (True, client_dbus_interface)),
1053
client.calls)
1054
1055
class TestDenyCmd(TestCmd):
1056
def test_deny(self):
1057
DenyCmd().run(self.clients, self.bus)
1058
for clientpath in self.clients:
1059
client = self.bus.get_object(dbus_busname, clientpath)
1060
self.assertIn(("Approve", (False, client_dbus_interface)),
1061
client.calls)
1062
1063
class TestEnableCmd(TestCmd):
1064
def test_enable(self):
1065
for clientpath in self.clients:
1066
client = self.bus.get_object(dbus_busname, clientpath)
1067
client.attributes["Enabled"] = False
1068
1069
EnableCmd().run(self.clients, self.bus)
1070
1071
for clientpath in self.clients:
1072
client = self.bus.get_object(dbus_busname, clientpath)
1073
self.assertTrue(client.attributes["Enabled"])
1074
1075
class TestDisableCmd(TestCmd):
1076
def test_disable(self):
1077
DisableCmd().run(self.clients, self.bus)
1078
for clientpath in self.clients:
1079
client = self.bus.get_object(dbus_busname, clientpath)
1080
self.assertFalse(client.attributes["Enabled"])
1081
1082
class Unique(object):
1083
"""Class for objects which exist only to be unique objects, since
1084
unittest.mock.sentinel only exists in Python 3.3"""
1085
1086
class TestPropertyCmd(TestCmd):
1087
"""Abstract class for tests of PropertyCmd classes"""
1088
def runTest(self):
1089
if not hasattr(self, "command"):
1090
return
1091
values_to_get = getattr(self, "values_to_get",
1092
self.values_to_set)
1093
for value_to_set, value_to_get in zip(self.values_to_set,
1094
values_to_get):
1095
for clientpath in self.clients:
1096
client = self.bus.get_object(dbus_busname, clientpath)
1097
old_value = client.attributes[self.propname]
1098
self.assertNotIsInstance(old_value, Unique)
1099
client.attributes[self.propname] = Unique()
1100
self.run_command(value_to_set, self.clients)
1101
for clientpath in self.clients:
1102
client = self.bus.get_object(dbus_busname, clientpath)
1103
value = client.attributes[self.propname]
1104
self.assertNotIsInstance(value, Unique)
1105
self.assertEqual(value, value_to_get)
1106
def run_command(self, value, clients):
1107
self.command().run(clients, self.bus)
1108
1109
class TestBumpTimeoutCmd(TestPropertyCmd):
1110
command = BumpTimeoutCmd
1111
propname = "LastCheckedOK"
1112
values_to_set = [""]
1113
1114
class TestStartCheckerCmd(TestPropertyCmd):
1115
command = StartCheckerCmd
1116
propname = "CheckerRunning"
1117
values_to_set = [dbus.Boolean(True)]
1118
1119
class TestStopCheckerCmd(TestPropertyCmd):
1120
command = StopCheckerCmd
1121
propname = "CheckerRunning"
1122
values_to_set = [dbus.Boolean(False)]
1123
1124
class TestApproveByDefaultCmd(TestPropertyCmd):
1125
command = ApproveByDefaultCmd
1126
propname = "ApprovedByDefault"
1127
values_to_set = [dbus.Boolean(True)]
1128
1129
class TestDenyByDefaultCmd(TestPropertyCmd):
1130
command = DenyByDefaultCmd
1131
propname = "ApprovedByDefault"
1132
values_to_set = [dbus.Boolean(False)]
1133
1134
class TestPropertyValueCmd(TestPropertyCmd):
1135
"""Abstract class for tests of PropertyValueCmd classes"""
1136
def runTest(self):
1137
if type(self) is TestPropertyValueCmd:
1138
return
1139
return super(TestPropertyValueCmd, self).runTest()
1140
def run_command(self, value, clients):
1141
self.command(value).run(clients, self.bus)
1142
1143
class TestSetCheckerCmd(TestPropertyValueCmd):
1144
command = SetCheckerCmd
1145
propname = "Checker"
1146
values_to_set = ["", ":", "fping -q -- %s"]
1147
1148
class TestSetHostCmd(TestPropertyValueCmd):
1149
command = SetHostCmd
1150
propname = "Host"
1151
values_to_set = ["192.0.2.3", "foo.example.org"]
1152
1153
class TestSetSecretCmd(TestPropertyValueCmd):
1154
command = SetSecretCmd
1155
propname = "Secret"
1156
values_to_set = [io.BytesIO(b""),
1157
io.BytesIO(b"secret\0xyzzy\nbar")]
1158
values_to_get = [b"", b"secret\0xyzzy\nbar"]
1159
1160
class TestSetTimeoutCmd(TestPropertyValueCmd):
1161
command = SetTimeoutCmd
1162
propname = "Timeout"
1163
values_to_set = [datetime.timedelta(),
1164
datetime.timedelta(minutes=5),
1165
datetime.timedelta(seconds=1),
1166
datetime.timedelta(weeks=1),
1167
datetime.timedelta(weeks=52)]
1168
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1169
1170
class TestSetExtendedTimeoutCmd(TestPropertyValueCmd):
1171
command = SetExtendedTimeoutCmd
1172
propname = "ExtendedTimeout"
1173
values_to_set = [datetime.timedelta(),
1174
datetime.timedelta(minutes=5),
1175
datetime.timedelta(seconds=1),
1176
datetime.timedelta(weeks=1),
1177
datetime.timedelta(weeks=52)]
1178
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1179
1180
class TestSetIntervalCmd(TestPropertyValueCmd):
1181
command = SetIntervalCmd
1182
propname = "Interval"
1183
values_to_set = [datetime.timedelta(),
1184
datetime.timedelta(minutes=5),
1185
datetime.timedelta(seconds=1),
1186
datetime.timedelta(weeks=1),
1187
datetime.timedelta(weeks=52)]
1188
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1189
1190
class TestSetApprovalDelayCmd(TestPropertyValueCmd):
1191
command = SetApprovalDelayCmd
1192
propname = "ApprovalDelay"
1193
values_to_set = [datetime.timedelta(),
1194
datetime.timedelta(minutes=5),
1195
datetime.timedelta(seconds=1),
1196
datetime.timedelta(weeks=1),
1197
datetime.timedelta(weeks=52)]
1198
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1199
1200
class TestSetApprovalDurationCmd(TestPropertyValueCmd):
1201
command = SetApprovalDurationCmd
1202
propname = "ApprovalDuration"
1203
values_to_set = [datetime.timedelta(),
1204
datetime.timedelta(minutes=5),
1205
datetime.timedelta(seconds=1),
1206
datetime.timedelta(weeks=1),
1207
datetime.timedelta(weeks=52)]
1208
values_to_get = [0, 300000, 1000, 604800000, 31449600000]
1209
1210
class Test_command_from_options(unittest.TestCase):
1211
def setUp(self):
1212
self.parser = argparse.ArgumentParser()
1213
add_command_line_options(self.parser)
1214
def assert_command_from_args(self, args, command_cls, **cmd_attrs):
1215
"""Assert that parsing ARGS should result in an instance of
1216
COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""
1217
options = self.parser.parse_args(args)
1218
check_option_syntax(self.parser, options)
1219
commands = commands_from_options(options)
1220
self.assertEqual(len(commands), 1)
1221
command = commands[0]
1222
self.assertIsInstance(command, command_cls)
1223
for key, value in cmd_attrs.items():
1224
self.assertEqual(getattr(command, key), value)
1225
def test_print_table(self):
1226
self.assert_command_from_args([], PrintTableCmd,
1227
verbose=False)
1228
1229
def test_print_table_verbose(self):
1230
self.assert_command_from_args(["--verbose"], PrintTableCmd,
1231
verbose=True)
1232
1233
def test_print_table_verbose_short(self):
1234
self.assert_command_from_args(["-v"], PrintTableCmd,
1235
verbose=True)
1236
1237
def test_enable(self):
1238
self.assert_command_from_args(["--enable", "foo"], EnableCmd)
1239
1240
def test_enable_short(self):
1241
self.assert_command_from_args(["-e", "foo"], EnableCmd)
1242
1243
def test_disable(self):
1244
self.assert_command_from_args(["--disable", "foo"],
1245
DisableCmd)
1246
1247
def test_disable_short(self):
1248
self.assert_command_from_args(["-d", "foo"], DisableCmd)
1249
1250
def test_bump_timeout(self):
1251
self.assert_command_from_args(["--bump-timeout", "foo"],
1252
BumpTimeoutCmd)
1253
1254
def test_bump_timeout_short(self):
1255
self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)
1256
1257
def test_start_checker(self):
1258
self.assert_command_from_args(["--start-checker", "foo"],
1259
StartCheckerCmd)
1260
1261
def test_stop_checker(self):
1262
self.assert_command_from_args(["--stop-checker", "foo"],
1263
StopCheckerCmd)
1264
1265
def test_remove(self):
1266
self.assert_command_from_args(["--remove", "foo"],
1267
RemoveCmd)
1268
1269
def test_remove_short(self):
1270
self.assert_command_from_args(["-r", "foo"], RemoveCmd)
1271
1272
def test_checker(self):
1273
self.assert_command_from_args(["--checker", ":", "foo"],
1274
SetCheckerCmd, value_to_set=":")
1275
1276
def test_checker_empty(self):
1277
self.assert_command_from_args(["--checker", "", "foo"],
1278
SetCheckerCmd, value_to_set="")
1279
1280
def test_checker_short(self):
1281
self.assert_command_from_args(["-c", ":", "foo"],
1282
SetCheckerCmd, value_to_set=":")
1283
1284
def test_timeout(self):
1285
self.assert_command_from_args(["--timeout", "PT5M", "foo"],
1286
SetTimeoutCmd,
1287
value_to_set=300000)
1288
1289
def test_timeout_short(self):
1290
self.assert_command_from_args(["-t", "PT5M", "foo"],
1291
SetTimeoutCmd,
1292
value_to_set=300000)
1293
1294
def test_extended_timeout(self):
1295
self.assert_command_from_args(["--extended-timeout", "PT15M",
1296
"foo"],
1297
SetExtendedTimeoutCmd,
1298
value_to_set=900000)
1299
1300
def test_interval(self):
1301
self.assert_command_from_args(["--interval", "PT2M", "foo"],
1302
SetIntervalCmd,
1303
value_to_set=120000)
1304
1305
def test_interval_short(self):
1306
self.assert_command_from_args(["-i", "PT2M", "foo"],
1307
SetIntervalCmd,
1308
value_to_set=120000)
1309
1310
def test_approve_by_default(self):
1311
self.assert_command_from_args(["--approve-by-default", "foo"],
1312
ApproveByDefaultCmd)
1313
1314
def test_deny_by_default(self):
1315
self.assert_command_from_args(["--deny-by-default", "foo"],
1316
DenyByDefaultCmd)
1317
1318
def test_approval_delay(self):
1319
self.assert_command_from_args(["--approval-delay", "PT30S",
1320
"foo"], SetApprovalDelayCmd,
1321
value_to_set=30000)
1322
1323
def test_approval_duration(self):
1324
self.assert_command_from_args(["--approval-duration", "PT1S",
1325
"foo"], SetApprovalDurationCmd,
1326
value_to_set=1000)
1327
1328
def test_host(self):
1329
self.assert_command_from_args(["--host", "foo.example.org",
1330
"foo"], SetHostCmd,
1331
value_to_set="foo.example.org")
1332
1333
def test_host_short(self):
1334
self.assert_command_from_args(["-H", "foo.example.org",
1335
"foo"], SetHostCmd,
1336
value_to_set="foo.example.org")
1337
1338
def test_secret_devnull(self):
1339
self.assert_command_from_args(["--secret", os.path.devnull,
1340
"foo"], SetSecretCmd,
1341
value_to_set=b"")
1342
1343
def test_secret_tempfile(self):
1344
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1345
value = b"secret\0xyzzy\nbar"
1346
f.write(value)
1347
f.seek(0)
1348
self.assert_command_from_args(["--secret", f.name,
1349
"foo"], SetSecretCmd,
1350
value_to_set=value)
1351
1352
def test_secret_devnull_short(self):
1353
self.assert_command_from_args(["-s", os.path.devnull, "foo"],
1354
SetSecretCmd, value_to_set=b"")
1355
1356
def test_secret_tempfile_short(self):
1357
with tempfile.NamedTemporaryFile(mode="r+b") as f:
1358
value = b"secret\0xyzzy\nbar"
1359
f.write(value)
1360
f.seek(0)
1361
self.assert_command_from_args(["-s", f.name, "foo"],
1362
SetSecretCmd,
1363
value_to_set=value)
1364
1365
def test_approve(self):
1366
self.assert_command_from_args(["--approve", "foo"],
1367
ApproveCmd)
1368
1369
def test_approve_short(self):
1370
self.assert_command_from_args(["-A", "foo"], ApproveCmd)
1371
1372
def test_deny(self):
1373
self.assert_command_from_args(["--deny", "foo"], DenyCmd)
1374
1375
def test_deny_short(self):
1376
self.assert_command_from_args(["-D", "foo"], DenyCmd)
1377
1378
def test_dump_json(self):
1379
self.assert_command_from_args(["--dump-json"], DumpJSONCmd)
1380
1381
def test_is_enabled(self):
1382
self.assert_command_from_args(["--is-enabled", "foo"],
1383
IsEnabledCmd)
1384
1385
def test_is_enabled_short(self):
1386
self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)
1387
1388
def test_deny_before_remove(self):
1389
options = self.parser.parse_args(["--deny", "--remove", "foo"])
1390
check_option_syntax(self.parser, options)
1391
commands = commands_from_options(options)
1392
self.assertEqual(len(commands), 2)
1393
self.assertIsInstance(commands[0], DenyCmd)
1394
self.assertIsInstance(commands[1], RemoveCmd)
1395
1396
def test_deny_before_remove_reversed(self):
1397
options = self.parser.parse_args(["--remove", "--deny", "--all"])
1398
check_option_syntax(self.parser, options)
1399
commands = commands_from_options(options)
1400
self.assertEqual(len(commands), 2)
1401
self.assertIsInstance(commands[0], DenyCmd)
1402
self.assertIsInstance(commands[1], RemoveCmd)
1403
1404
1405
class Test_check_option_syntax(unittest.TestCase):
1406
# This mostly corresponds to the definition from has_actions() in
1407
# check_option_syntax()
1408
actions = {
1409
# The actual values set here are not that important, but we do
1410
# at least stick to the correct types, even though they are
1411
# never used
1412
"enable": True,
1413
"disable": True,
1414
"bump_timeout": True,
1415
"start_checker": True,
1416
"stop_checker": True,
1417
"is_enabled": True,
1418
"remove": True,
1419
"checker": "x",
1420
"timeout": datetime.timedelta(),
1421
"extended_timeout": datetime.timedelta(),
1422
"interval": datetime.timedelta(),
1423
"approved_by_default": True,
1424
"approval_delay": datetime.timedelta(),
1425
"approval_duration": datetime.timedelta(),
1426
"host": "x",
1427
"secret": io.BytesIO(b"x"),
1428
"approve": True,
1429
"deny": True,
1430
}
1431
1432
def setUp(self):
1433
self.parser = argparse.ArgumentParser()
1434
add_command_line_options(self.parser)
1435
1436
@contextlib.contextmanager
1437
def assertParseError(self):
1438
with self.assertRaises(SystemExit) as e:
1439
with self.temporarily_suppress_stderr():
1440
yield
1441
# Exit code from argparse is guaranteed to be "2". Reference:
1442
# https://docs.python.org/3/library/argparse.html#exiting-methods
1443
self.assertEqual(e.exception.code, 2)
1444
1445
@staticmethod
1446
@contextlib.contextmanager
1447
def temporarily_suppress_stderr():
1448
null = os.open(os.path.devnull, os.O_RDWR)
1449
stderrcopy = os.dup(sys.stderr.fileno())
1450
os.dup2(null, sys.stderr.fileno())
1451
os.close(null)
351
1452
try:
352
mandos_clients = mandos_serv.GetAllClientsWithProperties()
1453
yield
353
1454
finally:
354
#restore stderr
1455
# restore stderr
355
1456
os.dup2(stderrcopy, sys.stderr.fileno())
356
1457
os.close(stderrcopy)
357
except dbus.exceptions.DBusException:
358
print("Access denied: Accessing mandos server through dbus.",
359
file=sys.stderr)
360
sys.exit(1)
361
362
# Compile dict of (clients: properties) to process
363
clients={}
364
365
if options.all or not options.client:
366
clients = { bus.get_object(busname, path): properties
367
for path, properties in mandos_clients.items() }
368
else:
369
for name in options.client:
370
for path, client in mandos_clients.items():
371
if client["Name"] == name:
372
client_objc = bus.get_object(busname, path)
373
clients[client_objc] = client
374
break
375
else:
376
print("Client not found on server: {!r}"
377
.format(name), file=sys.stderr)
378
sys.exit(1)
379
380
if not has_actions(options) and clients:
381
if options.verbose:
382
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
383
"Created", "Interval", "Host", "Fingerprint",
384
"CheckerRunning", "LastEnabled",
385
"ApprovalPending", "ApprovedByDefault",
386
"LastApprovalRequest", "ApprovalDelay",
387
"ApprovalDuration", "Checker",
388
"ExtendedTimeout")
389
else:
390
keywords = defaultkeywords
391
392
print_clients(clients.values(), keywords)
393
else:
394
# Process each client in the list by all selected options
395
for client in clients:
396
397
def set_client_prop(prop, value):
398
"""Set a Client D-Bus property"""
399
client.Set(client_interface, prop, value,
400
dbus_interface=dbus.PROPERTIES_IFACE)
401
402
def set_client_prop_ms(prop, value):
403
"""Set a Client D-Bus property, converted
404
from a string to milliseconds."""
405
set_client_prop(prop,
406
string_to_delta(value).total_seconds()
407
* 1000)
408
409
if options.remove:
410
mandos_serv.RemoveClient(client.__dbus_object_path__)
411
if options.enable:
412
set_client_prop("Enabled", dbus.Boolean(True))
413
if options.disable:
414
set_client_prop("Enabled", dbus.Boolean(False))
415
if options.bump_timeout:
416
set_client_prop("LastCheckedOK", "")
417
if options.start_checker:
418
set_client_prop("CheckerRunning", dbus.Boolean(True))
419
if options.stop_checker:
420
set_client_prop("CheckerRunning", dbus.Boolean(False))
421
if options.is_enabled:
422
sys.exit(0 if client.Get(client_interface,
423
"Enabled",
424
dbus_interface=
425
dbus.PROPERTIES_IFACE)
426
else 1)
427
if options.checker is not None:
428
set_client_prop("Checker", options.checker)
429
if options.host is not None:
430
set_client_prop("Host", options.host)
431
if options.interval is not None:
432
set_client_prop_ms("Interval", options.interval)
433
if options.approval_delay is not None:
434
set_client_prop_ms("ApprovalDelay",
435
options.approval_delay)
436
if options.approval_duration is not None:
437
set_client_prop_ms("ApprovalDuration",
438
options.approval_duration)
439
if options.timeout is not None:
440
set_client_prop_ms("Timeout", options.timeout)
441
if options.extended_timeout is not None:
442
set_client_prop_ms("ExtendedTimeout",
443
options.extended_timeout)
444
if options.secret is not None:
445
set_client_prop("Secret",
446
dbus.ByteArray(options.secret.read()))
447
if options.approved_by_default is not None:
448
set_client_prop("ApprovedByDefault",
449
dbus.Boolean(options
450
.approved_by_default))
451
if options.approve:
452
client.Approve(dbus.Boolean(True),
453
dbus_interface=client_interface)
454
elif options.deny:
455
client.Approve(dbus.Boolean(False),
456
dbus_interface=client_interface)
457
1458
1459
def check_option_syntax(self, options):
1460
check_option_syntax(self.parser, options)
1461
1462
def test_actions_requires_client_or_all(self):
1463
for action, value in self.actions.items():
1464
options = self.parser.parse_args()
1465
setattr(options, action, value)
1466
with self.assertParseError():
1467
self.check_option_syntax(options)
1468
1469
def test_actions_conflicts_with_verbose(self):
1470
for action, value in self.actions.items():
1471
options = self.parser.parse_args()
1472
setattr(options, action, value)
1473
options.verbose = True
1474
with self.assertParseError():
1475
self.check_option_syntax(options)
1476
1477
def test_dump_json_conflicts_with_verbose(self):
1478
options = self.parser.parse_args()
1479
options.dump_json = True
1480
options.verbose = True
1481
with self.assertParseError():
1482
self.check_option_syntax(options)
1483
1484
def test_dump_json_conflicts_with_action(self):
1485
for action, value in self.actions.items():
1486
options = self.parser.parse_args()
1487
setattr(options, action, value)
1488
options.dump_json = True
1489
with self.assertParseError():
1490
self.check_option_syntax(options)
1491
1492
def test_all_can_not_be_alone(self):
1493
options = self.parser.parse_args()
1494
options.all = True
1495
with self.assertParseError():
1496
self.check_option_syntax(options)
1497
1498
def test_all_is_ok_with_any_action(self):
1499
for action, value in self.actions.items():
1500
options = self.parser.parse_args()
1501
setattr(options, action, value)
1502
options.all = True
1503
self.check_option_syntax(options)
1504
1505
def test_is_enabled_fails_without_client(self):
1506
options = self.parser.parse_args()
1507
options.is_enabled = True
1508
with self.assertParseError():
1509
self.check_option_syntax(options)
1510
1511
def test_is_enabled_works_with_one_client(self):
1512
options = self.parser.parse_args()
1513
options.is_enabled = True
1514
options.client = ["foo"]
1515
self.check_option_syntax(options)
1516
1517
def test_is_enabled_fails_with_two_clients(self):
1518
options = self.parser.parse_args()
1519
options.is_enabled = True
1520
options.client = ["foo", "barbar"]
1521
with self.assertParseError():
1522
self.check_option_syntax(options)
1523
1524
def test_remove_can_only_be_combined_with_action_deny(self):
1525
for action, value in self.actions.items():
1526
if action in {"remove", "deny"}:
1527
continue
1528
options = self.parser.parse_args()
1529
setattr(options, action, value)
1530
options.all = True
1531
options.remove = True
1532
with self.assertParseError():
1533
self.check_option_syntax(options)
1534
1535
1536
1537
def should_only_run_tests():
1538
parser = argparse.ArgumentParser(add_help=False)
1539
parser.add_argument("--check", action='store_true')
1540
args, unknown_args = parser.parse_known_args()
1541
run_tests = args.check
1542
if run_tests:
1543
# Remove --check argument from sys.argv
1544
sys.argv[1:] = unknown_args
1545
return run_tests
1546
1547
# Add all tests from doctest strings
1548
def load_tests(loader, tests, none):
1549
import doctest
1550
tests.addTests(doctest.DocTestSuite())
1551
return tests
458
1552
459
1553
if __name__ == "__main__":
460
main()
1554
if should_only_run_tests():
1555
# Call using ./tdd-python-script --check [--verbose]
1556
unittest.main()
1557
else:
1558
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0