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 1019
- compare with another revision
- download diff
- download tarball
- view history from revision 1019
- Committer: Teddy Hogeborn
- Date: 2019-03-04 19:03:10 UTC
- Revision ID: teddy@recompile.se-20190304190310-n6brlijq8s692dok
mandos-ctl: New tests for ApproveCmd and DenyCmd
* mandos-ctl (TestCmd.MockClient.Approve): New method.
(TestApproveCmd, TestDenyCmd): New.
* mandos-ctl (TestCmd.MockClient.Approve): New method.
(TestApproveCmd, TestDenyCmd): New.
- 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
42
45
43
46
import dbus
44
47
48
# Show warnings by default
49
if not sys.warnoptions:
50
import warnings
51
warnings.simplefilter("default")
52
53
log = logging.getLogger(sys.argv[0])
54
logging.basicConfig(level="INFO", # Show info level messages
55
format="%(message)s") # Show basic log messages
56
57
logging.captureWarnings(True) # Show warnings via the logging system
58
45
59
if sys.version_info.major == 2:
46
60
str = unicode
47
61
48
62
locale.setlocale(locale.LC_ALL, "")
49
63
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
64
domain = "se.recompile"
71
65
busname = domain + ".Mandos"
72
66
server_path = "/"
73
67
server_interface = domain + ".Mandos"
74
68
client_interface = domain + ".Mandos.Client"
75
version = "1.6.9"
69
version = "1.8.3"
70
71
72
try:
73
dbus.OBJECT_MANAGER_IFACE
74
except AttributeError:
75
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
76
76
77
77
78
78
def milliseconds_to_string(ms):
79
79
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))
80
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
81
.format(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))
85
85
86
86
87
87
def rfc3339_duration_to_delta(duration):
88
88
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
89
89
90
90
>>> rfc3339_duration_to_delta("P7D")
91
91
datetime.timedelta(7)
92
92
>>> rfc3339_duration_to_delta("PT60S")
93
93
datetime.timedelta(0, 60)
94
94
>>> rfc3339_duration_to_delta("PT60M")
95
95
datetime.timedelta(0, 3600)
96
>>> rfc3339_duration_to_delta("P60M")
97
datetime.timedelta(1680)
96
98
>>> rfc3339_duration_to_delta("PT24H")
97
99
datetime.timedelta(1)
98
100
>>> rfc3339_duration_to_delta("P1W")
101
103
datetime.timedelta(0, 330)
102
104
>>> rfc3339_duration_to_delta("P1DT3M20S")
103
105
datetime.timedelta(1, 200)
106
>>> # Can not be empty:
107
>>> rfc3339_duration_to_delta("")
108
Traceback (most recent call last):
109
...
110
ValueError: Invalid RFC 3339 duration: u''
111
>>> # Must start with "P":
112
>>> rfc3339_duration_to_delta("1D")
113
Traceback (most recent call last):
114
...
115
ValueError: Invalid RFC 3339 duration: u'1D'
116
>>> # Must use correct order
117
>>> rfc3339_duration_to_delta("PT1S2M")
118
Traceback (most recent call last):
119
...
120
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
121
>>> # Time needs time marker
122
>>> rfc3339_duration_to_delta("P1H2S")
123
Traceback (most recent call last):
124
...
125
ValueError: Invalid RFC 3339 duration: u'P1H2S'
126
>>> # Weeks can not be combined with anything else
127
>>> rfc3339_duration_to_delta("P1D2W")
128
Traceback (most recent call last):
129
...
130
ValueError: Invalid RFC 3339 duration: u'P1D2W'
131
>>> rfc3339_duration_to_delta("P2W2H")
132
Traceback (most recent call last):
133
...
134
ValueError: Invalid RFC 3339 duration: u'P2W2H'
104
135
"""
105
136
106
137
# Parsing an RFC 3339 duration with regular expressions is not
107
138
# possible - there would have to be multiple places for the same
108
139
# values, like seconds. The current code, while more esoteric, is
109
140
# cleaner without depending on a parsing library. If Python had a
110
141
# built-in library for parsing we would use it, but we'd like to
111
142
# avoid excessive use of external libraries.
112
143
113
144
# New type for defining tokens, syntax, and semantics all-in-one
114
145
Token = collections.namedtuple("Token", (
115
146
"regexp", # To match token; if "value" is not None, must have
148
179
frozenset((token_year, token_month,
149
180
token_day, token_time,
150
181
token_week)))
151
# Define starting values
152
value = datetime.timedelta() # Value so far
182
# Define starting values:
183
# Value so far
184
value = datetime.timedelta()
153
185
found_token = None
154
followers = frozenset((token_duration, )) # Following valid tokens
155
s = duration # String left to parse
186
# Following valid tokens
187
followers = frozenset((token_duration, ))
188
# String left to parse
189
s = duration
156
190
# Loop until end token is found
157
191
while found_token is not token_end:
158
192
# Search for any currently valid tokens
181
215
182
216
183
217
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
218
"""Parse a string and return a datetime.timedelta"""
219
200
220
try:
201
221
return rfc3339_duration_to_delta(interval)
202
except ValueError:
203
pass
204
222
except ValueError as e:
223
log.warning("%s - Parsing as pre-1.6.1 interval instead",
224
' '.join(e.args))
225
return parse_pre_1_6_1_interval(interval)
226
227
228
def parse_pre_1_6_1_interval(interval):
229
"""Parse an interval string as documented by Mandos before 1.6.1,
230
and return a datetime.timedelta
231
232
>>> parse_pre_1_6_1_interval('7d')
233
datetime.timedelta(7)
234
>>> parse_pre_1_6_1_interval('60s')
235
datetime.timedelta(0, 60)
236
>>> parse_pre_1_6_1_interval('60m')
237
datetime.timedelta(0, 3600)
238
>>> parse_pre_1_6_1_interval('24h')
239
datetime.timedelta(1)
240
>>> parse_pre_1_6_1_interval('1w')
241
datetime.timedelta(7)
242
>>> parse_pre_1_6_1_interval('5m 30s')
243
datetime.timedelta(0, 330)
244
>>> parse_pre_1_6_1_interval('')
245
datetime.timedelta(0)
246
>>> # Ignore unknown characters, allow any order and repetitions
247
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')
248
datetime.timedelta(2, 480, 18000)
249
250
"""
251
205
252
value = datetime.timedelta(0)
206
253
regexp = re.compile(r"(\d+)([dsmhw]?)")
207
254
208
255
for num, suffix in regexp.findall(interval):
209
256
if suffix == "d":
210
257
value += datetime.timedelta(int(num))
221
268
return value
222
269
223
270
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
271
## Classes for commands.
272
273
# Abstract classes first
274
class Command(object):
275
"""Abstract class for commands"""
276
def run(self, mandos, clients):
277
"""Normal commands should implement run_on_one_client(), but
278
commands which want to operate on all clients at the same time
279
can override this run() method instead."""
280
self.mandos = mandos
281
for client in clients:
282
self.run_on_one_client(client)
283
284
class PrintCmd(Command):
285
"""Abstract class for commands printing client details"""
286
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
287
"Created", "Interval", "Host", "KeyID",
288
"Fingerprint", "CheckerRunning", "LastEnabled",
289
"ApprovalPending", "ApprovedByDefault",
290
"LastApprovalRequest", "ApprovalDelay",
291
"ApprovalDuration", "Checker", "ExtendedTimeout",
292
"Expires", "LastCheckerStatus")
293
def run(self, mandos, clients):
294
print(self.output(clients))
295
296
class PropertyCmd(Command):
297
"""Abstract class for Actions for setting one client property"""
298
def run_on_one_client(self, client):
299
"""Set the Client's D-Bus property"""
300
client.Set(client_interface, self.property, self.value_to_set,
301
dbus_interface=dbus.PROPERTIES_IFACE)
302
303
class ValueArgumentMixIn(object):
304
"""Mixin class for commands taking a value as argument"""
305
def __init__(self, value):
306
self.value_to_set = value
307
308
class MillisecondsValueArgumentMixIn(ValueArgumentMixIn):
309
"""Mixin class for commands taking a value argument as
310
milliseconds."""
311
@property
312
def value_to_set(self):
313
return self._vts
314
@value_to_set.setter
315
def value_to_set(self, value):
316
"""When setting, convert value to a datetime.timedelta"""
317
self._vts = string_to_delta(value).total_seconds() * 1000
318
319
# Actual (non-abstract) command classes
320
321
class PrintTableCmd(PrintCmd):
322
def __init__(self, verbose=False):
323
self.verbose = verbose
324
325
def output(self, clients):
326
if self.verbose:
327
keywords = self.all_keywords
328
else:
329
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
330
return str(self.TableOfClients(clients.values(), keywords))
331
332
class TableOfClients(object):
333
tableheaders = {
334
"Name": "Name",
335
"Enabled": "Enabled",
336
"Timeout": "Timeout",
337
"LastCheckedOK": "Last Successful Check",
338
"LastApprovalRequest": "Last Approval Request",
339
"Created": "Created",
340
"Interval": "Interval",
341
"Host": "Host",
342
"Fingerprint": "Fingerprint",
343
"KeyID": "Key ID",
344
"CheckerRunning": "Check Is Running",
345
"LastEnabled": "Last Enabled",
346
"ApprovalPending": "Approval Is Pending",
347
"ApprovedByDefault": "Approved By Default",
348
"ApprovalDelay": "Approval Delay",
349
"ApprovalDuration": "Approval Duration",
350
"Checker": "Checker",
351
"ExtendedTimeout": "Extended Timeout",
352
"Expires": "Expires",
353
"LastCheckerStatus": "Last Checker Status",
354
}
355
356
def __init__(self, clients, keywords, tableheaders=None):
357
self.clients = clients
358
self.keywords = keywords
359
if tableheaders is not None:
360
self.tableheaders = tableheaders
361
362
def __str__(self):
363
return "\n".join(self.rows())
364
365
if sys.version_info.major == 2:
366
__unicode__ = __str__
367
def __str__(self):
368
return str(self).encode(locale.getpreferredencoding())
369
370
def rows(self):
371
format_string = self.row_formatting_string()
372
rows = [self.header_line(format_string)]
373
rows.extend(self.client_line(client, format_string)
374
for client in self.clients)
375
return rows
376
377
def row_formatting_string(self):
378
"Format string used to format table rows"
379
return " ".join("{{{key}:{width}}}".format(
380
width=max(len(self.tableheaders[key]),
381
*(len(self.string_from_client(client, key))
382
for client in self.clients)),
383
key=key)
384
for key in self.keywords)
385
386
def string_from_client(self, client, key):
387
return self.valuetostring(client[key], key)
388
389
@staticmethod
390
def valuetostring(value, keyword):
391
if isinstance(value, dbus.Boolean):
392
return "Yes" if value else "No"
393
if keyword in ("Timeout", "Interval", "ApprovalDelay",
394
"ApprovalDuration", "ExtendedTimeout"):
395
return milliseconds_to_string(value)
396
return str(value)
397
398
def header_line(self, format_string):
399
return format_string.format(**self.tableheaders)
400
401
def client_line(self, client, format_string):
402
return format_string.format(
403
**{key: self.string_from_client(client, key)
404
for key in self.keywords})
405
406
407
408
class DumpJSONCmd(PrintCmd):
409
def output(self, clients):
410
data = {client["Name"]:
411
{key: self.dbus_boolean_to_bool(client[key])
412
for key in self.all_keywords}
413
for client in clients.values()}
414
return json.dumps(data, indent=4, separators=(',', ': '))
415
@staticmethod
416
def dbus_boolean_to_bool(value):
417
if isinstance(value, dbus.Boolean):
418
value = bool(value)
419
return value
420
421
class IsEnabledCmd(Command):
422
def run_on_one_client(self, client):
423
if self.is_enabled(client):
424
sys.exit(0)
425
sys.exit(1)
426
def is_enabled(self, client):
427
return client.Get(client_interface, "Enabled",
428
dbus_interface=dbus.PROPERTIES_IFACE)
429
430
class RemoveCmd(Command):
431
def run_on_one_client(self, client):
432
self.mandos.RemoveClient(client.__dbus_object_path__)
433
434
class ApproveCmd(Command):
435
def run_on_one_client(self, client):
436
client.Approve(dbus.Boolean(True),
437
dbus_interface=client_interface)
438
439
class DenyCmd(Command):
440
def run_on_one_client(self, client):
441
client.Approve(dbus.Boolean(False),
442
dbus_interface=client_interface)
443
444
class EnableCmd(PropertyCmd):
445
property = "Enabled"
446
value_to_set = dbus.Boolean(True)
447
448
class DisableCmd(PropertyCmd):
449
property = "Enabled"
450
value_to_set = dbus.Boolean(False)
451
452
class BumpTimeoutCmd(PropertyCmd):
453
property = "LastCheckedOK"
454
value_to_set = ""
455
456
class StartCheckerCmd(PropertyCmd):
457
property = "CheckerRunning"
458
value_to_set = dbus.Boolean(True)
459
460
class StopCheckerCmd(PropertyCmd):
461
property = "CheckerRunning"
462
value_to_set = dbus.Boolean(False)
463
464
class ApproveByDefaultCmd(PropertyCmd):
465
property = "ApprovedByDefault"
466
value_to_set = dbus.Boolean(True)
467
468
class DenyByDefaultCmd(PropertyCmd):
469
property = "ApprovedByDefault"
470
value_to_set = dbus.Boolean(False)
471
472
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
473
property = "Checker"
474
475
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
476
property = "Host"
477
478
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
479
property = "Secret"
480
481
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
482
property = "Timeout"
483
484
class SetExtendedTimeoutCmd(PropertyCmd,
485
MillisecondsValueArgumentMixIn):
486
property = "ExtendedTimeout"
487
488
class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
489
property = "Interval"
490
491
class SetApprovalDelayCmd(PropertyCmd,
492
MillisecondsValueArgumentMixIn):
493
property = "ApprovalDelay"
494
495
class SetApprovalDurationCmd(PropertyCmd,
496
MillisecondsValueArgumentMixIn):
497
property = "ApprovalDuration"
247
498
248
499
def has_actions(options):
249
500
return any((options.enable,
265
516
options.approve,
266
517
options.deny))
267
518
268
269
def main():
270
parser = argparse.ArgumentParser()
519
def add_command_line_options(parser):
271
520
parser.add_argument("--version", action="version",
272
version = "%(prog)s {}".format(version),
521
version="%(prog)s {}".format(version),
273
522
help="show version number and exit")
274
523
parser.add_argument("-a", "--all", action="store_true",
275
524
help="Select all clients")
276
525
parser.add_argument("-v", "--verbose", action="store_true",
277
526
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")
527
parser.add_argument("-j", "--dump-json", action="store_true",
528
help="Dump client data in JSON format")
529
enable_disable = parser.add_mutually_exclusive_group()
530
enable_disable.add_argument("-e", "--enable", action="store_true",
531
help="Enable client")
532
enable_disable.add_argument("-d", "--disable",
533
action="store_true",
534
help="disable client")
282
535
parser.add_argument("-b", "--bump-timeout", action="store_true",
283
536
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")
537
start_stop_checker = parser.add_mutually_exclusive_group()
538
start_stop_checker.add_argument("--start-checker",
539
action="store_true",
540
help="Start checker for client")
541
start_stop_checker.add_argument("--stop-checker",
542
action="store_true",
543
help="Stop checker for client")
288
544
parser.add_argument("-V", "--is-enabled", action="store_true",
289
545
help="Check if client is enabled")
290
546
parser.add_argument("-r", "--remove", action="store_true",
297
553
help="Set extended timeout for client")
298
554
parser.add_argument("-i", "--interval",
299
555
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")
556
approve_deny_default = parser.add_mutually_exclusive_group()
557
approve_deny_default.add_argument(
558
"--approve-by-default", action="store_true",
559
default=None, dest="approved_by_default",
560
help="Set client to be approved by default")
561
approve_deny_default.add_argument(
562
"--deny-by-default", action="store_false",
563
dest="approved_by_default",
564
help="Set client to be denied by default")
306
565
parser.add_argument("--approval-delay",
307
566
help="Set delay before client approve/deny")
308
567
parser.add_argument("--approval-duration",
311
570
parser.add_argument("-s", "--secret",
312
571
type=argparse.FileType(mode="rb"),
313
572
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")
573
approve_deny = parser.add_mutually_exclusive_group()
574
approve_deny.add_argument(
575
"-A", "--approve", action="store_true",
576
help="Approve any current client request")
577
approve_deny.add_argument("-D", "--deny", action="store_true",
578
help="Deny any current client request")
318
579
parser.add_argument("--check", action="store_true",
319
580
help="Run self-test")
320
581
parser.add_argument("client", nargs="*", help="Client name")
582
583
584
def commands_and_clients_from_options(options):
585
586
commands = []
587
588
if options.dump_json:
589
commands.append(DumpJSONCmd())
590
591
if options.enable:
592
commands.append(EnableCmd())
593
594
if options.disable:
595
commands.append(DisableCmd())
596
597
if options.bump_timeout:
598
commands.append(BumpTimeoutCmd(options.bump_timeout))
599
600
if options.start_checker:
601
commands.append(StartCheckerCmd())
602
603
if options.stop_checker:
604
commands.append(StopCheckerCmd())
605
606
if options.is_enabled:
607
commands.append(IsEnabledCmd())
608
609
if options.remove:
610
commands.append(RemoveCmd())
611
612
if options.checker is not None:
613
commands.append(SetCheckerCmd())
614
615
if options.timeout is not None:
616
commands.append(SetTimeoutCmd(options.timeout))
617
618
if options.extended_timeout:
619
commands.append(
620
SetExtendedTimeoutCmd(options.extended_timeout))
621
622
if options.interval is not None:
623
command.append(SetIntervalCmd(options.interval))
624
625
if options.approved_by_default is not None:
626
if options.approved_by_default:
627
command.append(ApproveByDefaultCmd())
628
else:
629
command.append(DenyByDefaultCmd())
630
631
if options.approval_delay is not None:
632
command.append(SetApprovalDelayCmd(options.approval_delay))
633
634
if options.approval_duration is not None:
635
command.append(
636
SetApprovalDurationCmd(options.approval_duration))
637
638
if options.host is not None:
639
command.append(SetHostCmd(options.host))
640
641
if options.secret is not None:
642
command.append(SetSecretCmd(options.secret))
643
644
if options.approve:
645
commands.append(ApproveCmd())
646
647
if options.deny:
648
commands.append(DenyCmd())
649
650
# If no command option has been given, show table of clients,
651
# optionally verbosely
652
if not commands:
653
commands.append(PrintTableCmd(verbose=options.verbose))
654
655
return commands, options.client
656
657
658
def main():
659
parser = argparse.ArgumentParser()
660
661
add_command_line_options(parser)
662
321
663
options = parser.parse_args()
322
664
323
665
if has_actions(options) and not (options.client or options.all):
324
666
parser.error("Options require clients names or --all.")
325
667
if options.verbose and has_actions(options):
326
parser.error("--verbose can only be used alone or with"
327
" --all.")
668
parser.error("--verbose can only be used alone.")
669
if options.dump_json and (options.verbose
670
or has_actions(options)):
671
parser.error("--dump-json can only be used alone.")
328
672
if options.all and not has_actions(options):
329
673
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
674
if options.is_enabled and len(options.client) > 1:
675
parser.error("--is-enabled requires exactly one client")
676
677
commands, clientnames = commands_and_clients_from_options(options)
678
335
679
try:
336
680
bus = dbus.SystemBus()
337
681
mandos_dbus_objc = bus.get_object(busname, server_path)
338
682
except dbus.exceptions.DBusException:
339
print("Could not connect to Mandos server", file=sys.stderr)
683
log.critical("Could not connect to Mandos server")
340
684
sys.exit(1)
341
685
342
686
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)
687
dbus_interface=server_interface)
688
mandos_serv_object_manager = dbus.Interface(
689
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
690
691
# Filter out log message from dbus module
692
dbus_logger = logging.getLogger("dbus.proxies")
693
class NullFilter(logging.Filter):
694
def filter(self, record):
695
return False
696
dbus_filter = NullFilter()
350
697
try:
351
try:
352
mandos_clients = mandos_serv.GetAllClientsWithProperties()
353
finally:
354
#restore stderr
355
os.dup2(stderrcopy, sys.stderr.fileno())
356
os.close(stderrcopy)
357
except dbus.exceptions.DBusException:
358
print("Access denied: Accessing mandos server through dbus.",
359
file=sys.stderr)
698
dbus_logger.addFilter(dbus_filter)
699
mandos_clients = {path: ifs_and_props[client_interface]
700
for path, ifs_and_props in
701
mandos_serv_object_manager
702
.GetManagedObjects().items()
703
if client_interface in ifs_and_props}
704
except dbus.exceptions.DBusException as e:
705
log.critical("Failed to access Mandos server through D-Bus:"
706
"\n%s", e)
360
707
sys.exit(1)
361
708
finally:
709
# restore dbus logger
710
dbus_logger.removeFilter(dbus_filter)
711
362
712
# 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() }
713
clients = {}
714
715
if not clientnames:
716
clients = {bus.get_object(busname, path): properties
717
for path, properties in mandos_clients.items()}
368
718
else:
369
for name in options.client:
719
for name in clientnames:
370
720
for path, client in mandos_clients.items():
371
721
if client["Name"] == name:
372
722
client_objc = bus.get_object(busname, path)
373
723
clients[client_objc] = client
374
724
break
375
725
else:
376
print("Client not found on server: {!r}"
377
.format(name), file=sys.stderr)
726
log.critical("Client not found on server: %r", name)
378
727
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
728
729
# Run all commands on clients
730
for command in commands:
731
command.run(mandos_serv, clients)
732
733
734
class Test_milliseconds_to_string(unittest.TestCase):
735
def test_all(self):
736
self.assertEqual(milliseconds_to_string(93785000),
737
"1T02:03:05")
738
def test_no_days(self):
739
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
740
def test_all_zero(self):
741
self.assertEqual(milliseconds_to_string(0), "00:00:00")
742
def test_no_fractional_seconds(self):
743
self.assertEqual(milliseconds_to_string(400), "00:00:00")
744
self.assertEqual(milliseconds_to_string(900), "00:00:00")
745
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
746
747
class Test_string_to_delta(unittest.TestCase):
748
def test_handles_basic_rfc3339(self):
749
self.assertEqual(string_to_delta("PT2H"),
750
datetime.timedelta(0, 7200))
751
def test_falls_back_to_pre_1_6_1_with_warning(self):
752
# assertLogs only exists in Python 3.4
753
if hasattr(self, "assertLogs"):
754
with self.assertLogs(log, logging.WARNING):
755
value = string_to_delta("2h")
756
else:
757
class WarningFilter(logging.Filter):
758
"""Don't show, but record the presence of, warnings"""
759
def filter(self, record):
760
is_warning = record.levelno >= logging.WARNING
761
self.found = is_warning or getattr(self, "found",
762
False)
763
return not is_warning
764
warning_filter = WarningFilter()
765
log.addFilter(warning_filter)
766
try:
767
value = string_to_delta("2h")
768
finally:
769
log.removeFilter(warning_filter)
770
self.assertTrue(getattr(warning_filter, "found", False))
771
self.assertEqual(value, datetime.timedelta(0, 7200))
772
773
774
class TestCmd(unittest.TestCase):
775
"""Abstract class for tests of command classes"""
776
def setUp(self):
777
testcase = self
778
class MockClient(object):
779
def __init__(self, name, **attributes):
780
self.__dbus_object_path__ = "objpath_{}".format(name)
781
self.attributes = attributes
782
self.attributes["Name"] = name
783
self.calls = []
784
def Set(self, interface, property, value, dbus_interface):
785
testcase.assertEqual(interface, client_interface)
786
testcase.assertEqual(dbus_interface,
787
dbus.PROPERTIES_IFACE)
788
self.attributes[property] = value
789
self.calls.append(("Set", (interface, property, value,
790
dbus_interface)))
791
def Get(self, interface, property, dbus_interface):
792
testcase.assertEqual(interface, client_interface)
793
testcase.assertEqual(dbus_interface,
794
dbus.PROPERTIES_IFACE)
795
self.calls.append(("Get", (interface, property,
796
dbus_interface)))
797
return self.attributes[property]
798
def Approve(self, approve, dbus_interface):
799
testcase.assertEqual(dbus_interface, client_interface)
800
self.calls.append(("Approve", (approve,
801
dbus_interface)))
802
def __getitem__(self, key):
803
return self.attributes[key]
804
def __setitem__(self, key, value):
805
self.attributes[key] = value
806
self.clients = collections.OrderedDict([
807
("foo",
808
MockClient(
809
"foo",
810
KeyID=("92ed150794387c03ce684574b1139a65"
811
"94a34f895daaaf09fd8ea90a27cddb12"),
812
Secret=b"secret",
813
Host="foo.example.org",
814
Enabled=dbus.Boolean(True),
815
Timeout=300000,
816
LastCheckedOK="2019-02-03T00:00:00",
817
Created="2019-01-02T00:00:00",
818
Interval=120000,
819
Fingerprint=("778827225BA7DE539C5A"
820
"7CFA59CFF7CDBD9A5920"),
821
CheckerRunning=dbus.Boolean(False),
822
LastEnabled="2019-01-03T00:00:00",
823
ApprovalPending=dbus.Boolean(False),
824
ApprovedByDefault=dbus.Boolean(True),
825
LastApprovalRequest="",
826
ApprovalDelay=0,
827
ApprovalDuration=1000,
828
Checker="fping -q -- %(host)s",
829
ExtendedTimeout=900000,
830
Expires="2019-02-04T00:00:00",
831
LastCheckerStatus=0)),
832
("barbar",
833
MockClient(
834
"barbar",
835
KeyID=("0558568eedd67d622f5c83b35a115f79"
836
"6ab612cff5ad227247e46c2b020f441c"),
837
Secret=b"secretbar",
838
Host="192.0.2.3",
839
Enabled=dbus.Boolean(True),
840
Timeout=300000,
841
LastCheckedOK="2019-02-04T00:00:00",
842
Created="2019-01-03T00:00:00",
843
Interval=120000,
844
Fingerprint=("3E393AEAEFB84C7E89E2"
845
"F547B3A107558FCA3A27"),
846
CheckerRunning=dbus.Boolean(True),
847
LastEnabled="2019-01-04T00:00:00",
848
ApprovalPending=dbus.Boolean(False),
849
ApprovedByDefault=dbus.Boolean(False),
850
LastApprovalRequest="2019-01-03T00:00:00",
851
ApprovalDelay=30000,
852
ApprovalDuration=1000,
853
Checker=":",
854
ExtendedTimeout=900000,
855
Expires="2019-02-05T00:00:00",
856
LastCheckerStatus=-2)),
857
])
858
self.client = self.clients["foo"]
859
860
class TestPrintTableCmd(TestCmd):
861
def test_normal(self):
862
output = PrintTableCmd().output(self.clients)
863
expected_output = """
864
Name Enabled Timeout Last Successful Check
865
foo Yes 00:05:00 2019-02-03T00:00:00
866
barbar Yes 00:05:00 2019-02-04T00:00:00
867
"""[1:-1]
868
self.assertEqual(output, expected_output)
869
def test_verbose(self):
870
output = PrintTableCmd(verbose=True).output(self.clients)
871
expected_output = """
872
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
873
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
874
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
875
"""[1:-1]
876
self.assertEqual(output, expected_output)
877
def test_one_client(self):
878
output = PrintTableCmd().output({"foo": self.client})
879
expected_output = """
880
Name Enabled Timeout Last Successful Check
881
foo Yes 00:05:00 2019-02-03T00:00:00
882
"""[1:-1]
883
self.assertEqual(output, expected_output)
884
885
class TestDumpJSONCmd(TestCmd):
886
def setUp(self):
887
self.expected_json = {
888
"foo": {
889
"Name": "foo",
890
"KeyID": ("92ed150794387c03ce684574b1139a65"
891
"94a34f895daaaf09fd8ea90a27cddb12"),
892
"Host": "foo.example.org",
893
"Enabled": True,
894
"Timeout": 300000,
895
"LastCheckedOK": "2019-02-03T00:00:00",
896
"Created": "2019-01-02T00:00:00",
897
"Interval": 120000,
898
"Fingerprint": ("778827225BA7DE539C5A"
899
"7CFA59CFF7CDBD9A5920"),
900
"CheckerRunning": False,
901
"LastEnabled": "2019-01-03T00:00:00",
902
"ApprovalPending": False,
903
"ApprovedByDefault": True,
904
"LastApprovalRequest": "",
905
"ApprovalDelay": 0,
906
"ApprovalDuration": 1000,
907
"Checker": "fping -q -- %(host)s",
908
"ExtendedTimeout": 900000,
909
"Expires": "2019-02-04T00:00:00",
910
"LastCheckerStatus": 0,
911
},
912
"barbar": {
913
"Name": "barbar",
914
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
915
"6ab612cff5ad227247e46c2b020f441c"),
916
"Host": "192.0.2.3",
917
"Enabled": True,
918
"Timeout": 300000,
919
"LastCheckedOK": "2019-02-04T00:00:00",
920
"Created": "2019-01-03T00:00:00",
921
"Interval": 120000,
922
"Fingerprint": ("3E393AEAEFB84C7E89E2"
923
"F547B3A107558FCA3A27"),
924
"CheckerRunning": True,
925
"LastEnabled": "2019-01-04T00:00:00",
926
"ApprovalPending": False,
927
"ApprovedByDefault": False,
928
"LastApprovalRequest": "2019-01-03T00:00:00",
929
"ApprovalDelay": 30000,
930
"ApprovalDuration": 1000,
931
"Checker": ":",
932
"ExtendedTimeout": 900000,
933
"Expires": "2019-02-05T00:00:00",
934
"LastCheckerStatus": -2,
935
},
936
}
937
return super(TestDumpJSONCmd, self).setUp()
938
def test_normal(self):
939
json_data = json.loads(DumpJSONCmd().output(self.clients))
940
self.assertDictEqual(json_data, self.expected_json)
941
def test_one_client(self):
942
clients = {"foo": self.client}
943
json_data = json.loads(DumpJSONCmd().output(clients))
944
expected_json = {"foo": self.expected_json["foo"]}
945
self.assertDictEqual(json_data, expected_json)
946
947
class TestIsEnabledCmd(TestCmd):
948
def test_is_enabled(self):
949
self.assertTrue(all(IsEnabledCmd().is_enabled(client)
950
for client in self.clients.values()))
951
def test_is_enabled_does_get_attribute(self):
952
self.assertTrue(IsEnabledCmd().is_enabled(self.client))
953
self.assertListEqual(self.client.calls,
954
[("Get",
955
("se.recompile.Mandos.Client",
956
"Enabled",
957
"org.freedesktop.DBus.Properties"))])
958
def test_is_enabled_run_exits_successfully(self):
959
with self.assertRaises(SystemExit) as e:
960
IsEnabledCmd().run(None, [self.client])
961
if e.exception.code is not None:
962
self.assertEqual(e.exception.code, 0)
963
else:
964
self.assertIsNone(e.exception.code)
965
def test_is_enabled_run_exits_with_failure(self):
966
self.client["Enabled"] = dbus.Boolean(False)
967
with self.assertRaises(SystemExit) as e:
968
IsEnabledCmd().run(None, [self.client])
969
if isinstance(e.exception.code, int):
970
self.assertNotEqual(e.exception.code, 0)
971
else:
972
self.assertIsNotNone(e.exception.code)
973
974
class TestRemoveCmd(TestCmd):
975
def test_remove(self):
976
class MockMandos(object):
977
def __init__(self):
978
self.calls = []
979
def RemoveClient(self, dbus_path):
980
self.calls.append(("RemoveClient", (dbus_path,)))
981
mandos = MockMandos()
982
RemoveCmd().run(mandos, [self.client])
983
self.assertEqual(len(mandos.calls), 1)
984
self.assertListEqual(mandos.calls,
985
[("RemoveClient",
986
(self.client.__dbus_object_path__,))])
987
988
class TestApproveCmd(TestCmd):
989
def test_approve(self):
990
ApproveCmd().run(None, [self.client])
991
self.assertListEqual(self.client.calls,
992
[("Approve", (True, client_interface))])
993
class TestDenyCmd(TestCmd):
994
def test_approve(self):
995
DenyCmd().run(None, [self.client])
996
self.assertListEqual(self.client.calls,
997
[("Approve", (False, client_interface))])
998
999
1000
1001
def should_only_run_tests():
1002
parser = argparse.ArgumentParser(add_help=False)
1003
parser.add_argument("--check", action='store_true')
1004
args, unknown_args = parser.parse_known_args()
1005
run_tests = args.check
1006
if run_tests:
1007
# Remove --check argument from sys.argv
1008
sys.argv[1:] = unknown_args
1009
return run_tests
1010
1011
# Add all tests from doctest strings
1012
def load_tests(loader, tests, none):
1013
import doctest
1014
tests.addTests(doctest.DocTestSuite())
1015
return tests
458
1016
459
1017
if __name__ == "__main__":
460
main()
1018
if should_only_run_tests():
1019
# Call using ./tdd-python-script --check [--verbose]
1020
unittest.main()
1021
else:
1022
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0