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 816
- compare with another revision
- download diff
- download tarball
- view history from revision 816
- Committer: Teddy Hogeborn
- Date: 2016-03-02 17:35:23 UTC
- Revision ID: teddy@recompile.se-20160302173523-rdhzeatfxr582i2c
Use "nogroup" as a fallback group, not "nobody".
* Makefile (GROUP): Use "nogroup" as a fallback group, not "nobody".
* mandos (main): - '' -
* Makefile (GROUP): Use "nogroup" as a fallback group, not "nobody".
* mandos (main): - '' -
- 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
41
import doctest
45
42
46
43
import dbus
47
44
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
59
45
if sys.version_info.major == 2:
60
46
str = unicode
61
47
62
48
locale.setlocale(locale.LC_ALL, "")
63
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")
64
70
domain = "se.recompile"
65
71
busname = domain + ".Mandos"
66
72
server_path = "/"
67
73
server_interface = domain + ".Mandos"
68
74
client_interface = domain + ".Mandos.Client"
69
version = "1.8.3"
75
version = "1.7.3"
70
76
71
77
72
78
try:
74
80
except AttributeError:
75
81
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
76
82
77
78
83
def milliseconds_to_string(ms):
79
84
td = datetime.timedelta(0, 0, 0, ms)
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
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))
85
90
86
91
87
92
def rfc3339_duration_to_delta(duration):
88
93
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
89
94
90
95
>>> rfc3339_duration_to_delta("P7D")
91
96
datetime.timedelta(7)
92
97
>>> rfc3339_duration_to_delta("PT60S")
93
98
datetime.timedelta(0, 60)
94
99
>>> rfc3339_duration_to_delta("PT60M")
95
100
datetime.timedelta(0, 3600)
96
>>> rfc3339_duration_to_delta("P60M")
97
datetime.timedelta(1680)
98
101
>>> rfc3339_duration_to_delta("PT24H")
99
102
datetime.timedelta(1)
100
103
>>> rfc3339_duration_to_delta("P1W")
103
106
datetime.timedelta(0, 330)
104
107
>>> rfc3339_duration_to_delta("P1DT3M20S")
105
108
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'
135
109
"""
136
110
137
111
# Parsing an RFC 3339 duration with regular expressions is not
138
112
# possible - there would have to be multiple places for the same
139
113
# values, like seconds. The current code, while more esoteric, is
140
114
# cleaner without depending on a parsing library. If Python had a
141
115
# built-in library for parsing we would use it, but we'd like to
142
116
# avoid excessive use of external libraries.
143
117
144
118
# New type for defining tokens, syntax, and semantics all-in-one
145
119
Token = collections.namedtuple("Token", (
146
120
"regexp", # To match token; if "value" is not None, must have
179
153
frozenset((token_year, token_month,
180
154
token_day, token_time,
181
155
token_week)))
182
# Define starting values:
183
# Value so far
184
value = datetime.timedelta()
156
# Define starting values
157
value = datetime.timedelta() # Value so far
185
158
found_token = None
186
# Following valid tokens
187
followers = frozenset((token_duration, ))
188
# String left to parse
189
s = duration
159
followers = frozenset((token_duration, )) # Following valid tokens
160
s = duration # String left to parse
190
161
# Loop until end token is found
191
162
while found_token is not token_end:
192
163
# Search for any currently valid tokens
215
186
216
187
217
188
def string_to_delta(interval):
218
"""Parse a string and return a datetime.timedelta"""
219
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
220
205
try:
221
206
return rfc3339_duration_to_delta(interval)
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
207
except ValueError:
208
pass
209
252
210
value = datetime.timedelta(0)
253
211
regexp = re.compile(r"(\d+)([dsmhw]?)")
254
212
255
213
for num, suffix in regexp.findall(interval):
256
214
if suffix == "d":
257
215
value += datetime.timedelta(int(num))
268
226
return value
269
227
270
228
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"
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
498
252
499
253
def has_actions(options):
500
254
return any((options.enable,
516
270
options.approve,
517
271
options.deny))
518
272
519
def add_command_line_options(parser):
273
274
def main():
275
parser = argparse.ArgumentParser()
520
276
parser.add_argument("--version", action="version",
521
version="%(prog)s {}".format(version),
277
version = "%(prog)s {}".format(version),
522
278
help="show version number and exit")
523
279
parser.add_argument("-a", "--all", action="store_true",
524
280
help="Select all clients")
525
281
parser.add_argument("-v", "--verbose", action="store_true",
526
282
help="Print all fields")
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")
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")
535
287
parser.add_argument("-b", "--bump-timeout", action="store_true",
536
288
help="Bump timeout 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")
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")
544
293
parser.add_argument("-V", "--is-enabled", action="store_true",
545
294
help="Check if client is enabled")
546
295
parser.add_argument("-r", "--remove", action="store_true",
553
302
help="Set extended timeout for client")
554
303
parser.add_argument("-i", "--interval",
555
304
help="Set checker interval for client")
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")
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")
565
311
parser.add_argument("--approval-delay",
566
312
help="Set delay before client approve/deny")
567
313
parser.add_argument("--approval-duration",
570
316
parser.add_argument("-s", "--secret",
571
317
type=argparse.FileType(mode="rb"),
572
318
help="Set password blob (file) for client")
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")
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")
579
323
parser.add_argument("--check", action="store_true",
580
324
help="Run self-test")
581
325
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
663
326
options = parser.parse_args()
664
327
665
328
if has_actions(options) and not (options.client or options.all):
666
329
parser.error("Options require clients names or --all.")
667
330
if options.verbose and has_actions(options):
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.")
331
parser.error("--verbose can only be used alone or with"
332
" --all.")
672
333
if options.all and not has_actions(options):
673
334
parser.error("--all requires an action.")
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
336
if options.check:
337
fail_count, test_count = doctest.testmod()
338
sys.exit(os.EX_OK if fail_count == 0 else 1)
339
679
340
try:
680
341
bus = dbus.SystemBus()
681
342
mandos_dbus_objc = bus.get_object(busname, server_path)
682
343
except dbus.exceptions.DBusException:
683
log.critical("Could not connect to Mandos server")
344
print("Could not connect to Mandos server", file=sys.stderr)
684
345
sys.exit(1)
685
346
686
347
mandos_serv = dbus.Interface(mandos_dbus_objc,
687
dbus_interface=server_interface)
348
dbus_interface = server_interface)
688
349
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()
697
dbus_logger.addFilter(dbus_filter)
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)
698
357
try:
699
358
try:
700
mandos_clients = {path: ifs_and_props[client_interface]
701
for path, ifs_and_props in
702
mandos_serv_object_manager
703
.GetManagedObjects().items()
704
if client_interface in ifs_and_props}
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 }
705
364
finally:
706
# restore dbus logger
707
dbus_logger.removeFilter(dbus_filter)
365
#restore stderr
366
os.dup2(stderrcopy, sys.stderr.fileno())
367
os.close(stderrcopy)
708
368
except dbus.exceptions.DBusException as e:
709
log.critical("Failed to access Mandos server through D-Bus:"
710
"\n%s", e)
369
print("Access denied: Accessing mandos server through D-Bus: {}"
370
.format(e), file=sys.stderr)
711
371
sys.exit(1)
712
372
713
373
# Compile dict of (clients: properties) to process
714
clients = {}
715
716
if not clientnames:
717
clients = {bus.get_object(busname, path): properties
718
for path, 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() }
719
379
else:
720
for name in clientnames:
380
for name in options.client:
721
381
for path, client in mandos_clients.items():
722
382
if client["Name"] == name:
723
383
client_objc = bus.get_object(busname, path)
724
384
clients[client_objc] = client
725
385
break
726
386
else:
727
log.critical("Client not found on server: %r", name)
387
print("Client not found on server: {!r}"
388
.format(name), file=sys.stderr)
728
389
sys.exit(1)
729
730
# Run all commands on clients
731
for command in commands:
732
command.run(mandos_serv, clients)
733
734
735
class Test_milliseconds_to_string(unittest.TestCase):
736
def test_all(self):
737
self.assertEqual(milliseconds_to_string(93785000),
738
"1T02:03:05")
739
def test_no_days(self):
740
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
741
def test_all_zero(self):
742
self.assertEqual(milliseconds_to_string(0), "00:00:00")
743
def test_no_fractional_seconds(self):
744
self.assertEqual(milliseconds_to_string(400), "00:00:00")
745
self.assertEqual(milliseconds_to_string(900), "00:00:00")
746
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
747
748
class Test_string_to_delta(unittest.TestCase):
749
def test_handles_basic_rfc3339(self):
750
self.assertEqual(string_to_delta("PT2H"),
751
datetime.timedelta(0, 7200))
752
def test_falls_back_to_pre_1_6_1_with_warning(self):
753
# assertLogs only exists in Python 3.4
754
if hasattr(self, "assertLogs"):
755
with self.assertLogs(log, logging.WARNING):
756
value = string_to_delta("2h")
757
else:
758
class WarningFilter(logging.Filter):
759
"""Don't show, but record the presence of, warnings"""
760
def filter(self, record):
761
is_warning = record.levelno >= logging.WARNING
762
self.found = is_warning or getattr(self, "found",
763
False)
764
return not is_warning
765
warning_filter = WarningFilter()
766
log.addFilter(warning_filter)
767
try:
768
value = string_to_delta("2h")
769
finally:
770
log.removeFilter(warning_filter)
771
self.assertTrue(getattr(warning_filter, "found", False))
772
self.assertEqual(value, datetime.timedelta(0, 7200))
773
774
775
class TestCmd(unittest.TestCase):
776
"""Abstract class for tests of command classes"""
777
def setUp(self):
778
testcase = self
779
class MockClient(object):
780
def __init__(self, name, **attributes):
781
self.__dbus_object_path__ = "objpath_{}".format(name)
782
self.attributes = attributes
783
self.attributes["Name"] = name
784
self.calls = []
785
def Set(self, interface, property, value, dbus_interface):
786
testcase.assertEqual(interface, client_interface)
787
testcase.assertEqual(dbus_interface,
788
dbus.PROPERTIES_IFACE)
789
self.attributes[property] = value
790
self.calls.append(("Set", (interface, property, value,
791
dbus_interface)))
792
def Get(self, interface, property, dbus_interface):
793
testcase.assertEqual(interface, client_interface)
794
testcase.assertEqual(dbus_interface,
795
dbus.PROPERTIES_IFACE)
796
self.calls.append(("Get", (interface, property,
797
dbus_interface)))
798
return self.attributes[property]
799
def __getitem__(self, key):
800
return self.attributes[key]
801
def __setitem__(self, key, value):
802
self.attributes[key] = value
803
self.clients = collections.OrderedDict([
804
("foo",
805
MockClient(
806
"foo",
807
KeyID=("92ed150794387c03ce684574b1139a65"
808
"94a34f895daaaf09fd8ea90a27cddb12"),
809
Secret=b"secret",
810
Host="foo.example.org",
811
Enabled=dbus.Boolean(True),
812
Timeout=300000,
813
LastCheckedOK="2019-02-03T00:00:00",
814
Created="2019-01-02T00:00:00",
815
Interval=120000,
816
Fingerprint=("778827225BA7DE539C5A"
817
"7CFA59CFF7CDBD9A5920"),
818
CheckerRunning=dbus.Boolean(False),
819
LastEnabled="2019-01-03T00:00:00",
820
ApprovalPending=dbus.Boolean(False),
821
ApprovedByDefault=dbus.Boolean(True),
822
LastApprovalRequest="",
823
ApprovalDelay=0,
824
ApprovalDuration=1000,
825
Checker="fping -q -- %(host)s",
826
ExtendedTimeout=900000,
827
Expires="2019-02-04T00:00:00",
828
LastCheckerStatus=0)),
829
("barbar",
830
MockClient(
831
"barbar",
832
KeyID=("0558568eedd67d622f5c83b35a115f79"
833
"6ab612cff5ad227247e46c2b020f441c"),
834
Secret=b"secretbar",
835
Host="192.0.2.3",
836
Enabled=dbus.Boolean(True),
837
Timeout=300000,
838
LastCheckedOK="2019-02-04T00:00:00",
839
Created="2019-01-03T00:00:00",
840
Interval=120000,
841
Fingerprint=("3E393AEAEFB84C7E89E2"
842
"F547B3A107558FCA3A27"),
843
CheckerRunning=dbus.Boolean(True),
844
LastEnabled="2019-01-04T00:00:00",
845
ApprovalPending=dbus.Boolean(False),
846
ApprovedByDefault=dbus.Boolean(False),
847
LastApprovalRequest="2019-01-03T00:00:00",
848
ApprovalDelay=30000,
849
ApprovalDuration=1000,
850
Checker=":",
851
ExtendedTimeout=900000,
852
Expires="2019-02-05T00:00:00",
853
LastCheckerStatus=-2)),
854
])
855
856
class TestPrintTableCmd(TestCmd):
857
def test_normal(self):
858
output = PrintTableCmd().output(self.clients)
859
expected_output = """
860
Name Enabled Timeout Last Successful Check
861
foo Yes 00:05:00 2019-02-03T00:00:00
862
barbar Yes 00:05:00 2019-02-04T00:00:00
863
"""[1:-1]
864
self.assertEqual(output, expected_output)
865
def test_verbose(self):
866
output = PrintTableCmd(verbose=True).output(self.clients)
867
expected_output = """
868
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
869
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
870
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
871
"""[1:-1]
872
self.assertEqual(output, expected_output)
873
def test_one_client(self):
874
output = PrintTableCmd().output({"foo": self.clients["foo"]})
875
expected_output = """
876
Name Enabled Timeout Last Successful Check
877
foo Yes 00:05:00 2019-02-03T00:00:00
878
"""[1:-1]
879
self.assertEqual(output, expected_output)
880
881
class TestDumpJSONCmd(TestCmd):
882
def setUp(self):
883
self.expected_json = {
884
"foo": {
885
"Name": "foo",
886
"KeyID": ("92ed150794387c03ce684574b1139a65"
887
"94a34f895daaaf09fd8ea90a27cddb12"),
888
"Host": "foo.example.org",
889
"Enabled": True,
890
"Timeout": 300000,
891
"LastCheckedOK": "2019-02-03T00:00:00",
892
"Created": "2019-01-02T00:00:00",
893
"Interval": 120000,
894
"Fingerprint": ("778827225BA7DE539C5A"
895
"7CFA59CFF7CDBD9A5920"),
896
"CheckerRunning": False,
897
"LastEnabled": "2019-01-03T00:00:00",
898
"ApprovalPending": False,
899
"ApprovedByDefault": True,
900
"LastApprovalRequest": "",
901
"ApprovalDelay": 0,
902
"ApprovalDuration": 1000,
903
"Checker": "fping -q -- %(host)s",
904
"ExtendedTimeout": 900000,
905
"Expires": "2019-02-04T00:00:00",
906
"LastCheckerStatus": 0,
907
},
908
"barbar": {
909
"Name": "barbar",
910
"KeyID": ("0558568eedd67d622f5c83b35a115f79"
911
"6ab612cff5ad227247e46c2b020f441c"),
912
"Host": "192.0.2.3",
913
"Enabled": True,
914
"Timeout": 300000,
915
"LastCheckedOK": "2019-02-04T00:00:00",
916
"Created": "2019-01-03T00:00:00",
917
"Interval": 120000,
918
"Fingerprint": ("3E393AEAEFB84C7E89E2"
919
"F547B3A107558FCA3A27"),
920
"CheckerRunning": True,
921
"LastEnabled": "2019-01-04T00:00:00",
922
"ApprovalPending": False,
923
"ApprovedByDefault": False,
924
"LastApprovalRequest": "2019-01-03T00:00:00",
925
"ApprovalDelay": 30000,
926
"ApprovalDuration": 1000,
927
"Checker": ":",
928
"ExtendedTimeout": 900000,
929
"Expires": "2019-02-05T00:00:00",
930
"LastCheckerStatus": -2,
931
},
932
}
933
return super(TestDumpJSONCmd, self).setUp()
934
def test_normal(self):
935
json_data = json.loads(DumpJSONCmd().output(self.clients))
936
self.assertDictEqual(json_data, self.expected_json)
937
def test_one_client(self):
938
clients = {"foo": self.clients["foo"]}
939
json_data = json.loads(DumpJSONCmd().output(clients))
940
expected_json = {"foo": self.expected_json["foo"]}
941
self.assertDictEqual(json_data, expected_json)
942
943
class TestIsEnabledCmd(TestCmd):
944
def test_is_enabled(self):
945
self.assertTrue(all(IsEnabledCmd().is_enabled(client)
946
for client in self.clients.values()))
947
def test_is_enabled_does_get_attribute(self):
948
client = self.clients["foo"]
949
self.assertTrue(IsEnabledCmd().is_enabled(client))
950
self.assertListEqual(client.calls,
951
[("Get",
952
("se.recompile.Mandos.Client",
953
"Enabled",
954
"org.freedesktop.DBus.Properties"))])
955
def test_is_enabled_run_exits_successfully(self):
956
client = self.clients["foo"]
957
with self.assertRaises(SystemExit) as e:
958
IsEnabledCmd().run_on_one_client(client)
959
if e.exception.code is not None:
960
self.assertEqual(e.exception.code, 0)
961
else:
962
self.assertIsNone(e.exception.code)
963
def test_is_enabled_run_exits_with_failure(self):
964
client = self.clients["foo"]
965
client["Enabled"] = dbus.Boolean(False)
966
with self.assertRaises(SystemExit) as e:
967
IsEnabledCmd().run_on_one_client(client)
968
if isinstance(e.exception.code, int):
969
self.assertNotEqual(e.exception.code, 0)
970
else:
971
self.assertIsNotNone(e.exception.code)
972
973
974
975
def should_only_run_tests():
976
parser = argparse.ArgumentParser(add_help=False)
977
parser.add_argument("--check", action='store_true')
978
args, unknown_args = parser.parse_known_args()
979
run_tests = args.check
980
if run_tests:
981
# Remove --check argument from sys.argv
982
sys.argv[1:] = unknown_args
983
return run_tests
984
985
# Add all tests from doctest strings
986
def load_tests(loader, tests, none):
987
import doctest
988
tests.addTests(doctest.DocTestSuite())
989
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
990
469
991
470
if __name__ == "__main__":
992
if should_only_run_tests():
993
# Call using ./tdd-python-script --check [--verbose]
994
unittest.main()
995
else:
996
main()
471
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0