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