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 222
- compare with another revision
- download diff
- download tarball
- view history from revision 222
- Committer: Teddy Hogeborn
- Date: 2008-10-01 18:41:06 UTC
- Revision ID: teddy@fukt.bsnet.se-20081001184106-r728au6iv0lq8orm
Tags: version-1.0-2
* debian/changelog: Add Debian revision number to old revision too.
- files added:
- debian/mandos-client.config
- files removed:
- DBUS-API
- debian/source
- debian/upstream
- network-hooks.d
- plugin-helpers
- files modified:
- .bzrignore
added
removed
mandos-ctl
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
#
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
13
# the Free Software Foundation, either version 3 of the License, or
14
# (at your option) any later version.
15
#
16
# Mandos is distributed in the hope that it will be useful, but
17
# WITHOUT ANY WARRANTY; without even the implied warranty of
18
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19
# GNU General Public License for more details.
20
#
21
# 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
#
24
# Contact the authors at <mandos@recompile.se>.
25
#
26
27
from __future__ import (division, absolute_import, print_function,
28
unicode_literals)
29
30
try:
31
from future_builtins import *
32
except ImportError:
33
pass
34
35
import sys
36
import argparse
37
import locale
38
import datetime
39
import re
40
import os
41
import collections
42
import json
43
import unittest
44
import logging
45
46
import dbus
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
59
if sys.version_info.major == 2:
60
str = unicode
61
62
locale.setlocale(locale.LC_ALL, "")
63
64
tablewords = {
65
"Name": "Name",
66
"Enabled": "Enabled",
67
"Timeout": "Timeout",
68
"LastCheckedOK": "Last Successful Check",
69
"LastApprovalRequest": "Last Approval Request",
70
"Created": "Created",
71
"Interval": "Interval",
72
"Host": "Host",
73
"Fingerprint": "Fingerprint",
74
"KeyID": "Key ID",
75
"CheckerRunning": "Check Is Running",
76
"LastEnabled": "Last Enabled",
77
"ApprovalPending": "Approval Is Pending",
78
"ApprovedByDefault": "Approved By Default",
79
"ApprovalDelay": "Approval Delay",
80
"ApprovalDuration": "Approval Duration",
81
"Checker": "Checker",
82
"ExtendedTimeout": "Extended Timeout",
83
"Expires": "Expires",
84
"LastCheckerStatus": "Last Checker Status",
85
}
86
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
87
domain = "se.recompile"
88
busname = domain + ".Mandos"
89
server_path = "/"
90
server_interface = domain + ".Mandos"
91
client_interface = domain + ".Mandos.Client"
92
version = "1.8.3"
93
94
95
try:
96
dbus.OBJECT_MANAGER_IFACE
97
except AttributeError:
98
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
99
100
101
def milliseconds_to_string(ms):
102
td = datetime.timedelta(0, 0, 0, ms)
103
return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
104
.format(days="{}T".format(td.days) if td.days else "",
105
hours=td.seconds // 3600,
106
minutes=(td.seconds % 3600) // 60,
107
seconds=td.seconds % 60))
108
109
110
def rfc3339_duration_to_delta(duration):
111
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
112
113
>>> rfc3339_duration_to_delta("P7D")
114
datetime.timedelta(7)
115
>>> rfc3339_duration_to_delta("PT60S")
116
datetime.timedelta(0, 60)
117
>>> rfc3339_duration_to_delta("PT60M")
118
datetime.timedelta(0, 3600)
119
>>> rfc3339_duration_to_delta("P60M")
120
datetime.timedelta(1680)
121
>>> rfc3339_duration_to_delta("PT24H")
122
datetime.timedelta(1)
123
>>> rfc3339_duration_to_delta("P1W")
124
datetime.timedelta(7)
125
>>> rfc3339_duration_to_delta("PT5M30S")
126
datetime.timedelta(0, 330)
127
>>> rfc3339_duration_to_delta("P1DT3M20S")
128
datetime.timedelta(1, 200)
129
>>> # Can not be empty:
130
>>> rfc3339_duration_to_delta("")
131
Traceback (most recent call last):
132
...
133
ValueError: Invalid RFC 3339 duration: u''
134
>>> # Must start with "P":
135
>>> rfc3339_duration_to_delta("1D")
136
Traceback (most recent call last):
137
...
138
ValueError: Invalid RFC 3339 duration: u'1D'
139
>>> # Must use correct order
140
>>> rfc3339_duration_to_delta("PT1S2M")
141
Traceback (most recent call last):
142
...
143
ValueError: Invalid RFC 3339 duration: u'PT1S2M'
144
>>> # Time needs time marker
145
>>> rfc3339_duration_to_delta("P1H2S")
146
Traceback (most recent call last):
147
...
148
ValueError: Invalid RFC 3339 duration: u'P1H2S'
149
>>> # Weeks can not be combined with anything else
150
>>> rfc3339_duration_to_delta("P1D2W")
151
Traceback (most recent call last):
152
...
153
ValueError: Invalid RFC 3339 duration: u'P1D2W'
154
>>> rfc3339_duration_to_delta("P2W2H")
155
Traceback (most recent call last):
156
...
157
ValueError: Invalid RFC 3339 duration: u'P2W2H'
158
"""
159
160
# Parsing an RFC 3339 duration with regular expressions is not
161
# possible - there would have to be multiple places for the same
162
# values, like seconds. The current code, while more esoteric, is
163
# cleaner without depending on a parsing library. If Python had a
164
# built-in library for parsing we would use it, but we'd like to
165
# avoid excessive use of external libraries.
166
167
# New type for defining tokens, syntax, and semantics all-in-one
168
Token = collections.namedtuple("Token", (
169
"regexp", # To match token; if "value" is not None, must have
170
# a "group" containing digits
171
"value", # datetime.timedelta or None
172
"followers")) # Tokens valid after this token
173
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
174
# the "duration" ABNF definition in RFC 3339, Appendix A.
175
token_end = Token(re.compile(r"$"), None, frozenset())
176
token_second = Token(re.compile(r"(\d+)S"),
177
datetime.timedelta(seconds=1),
178
frozenset((token_end, )))
179
token_minute = Token(re.compile(r"(\d+)M"),
180
datetime.timedelta(minutes=1),
181
frozenset((token_second, token_end)))
182
token_hour = Token(re.compile(r"(\d+)H"),
183
datetime.timedelta(hours=1),
184
frozenset((token_minute, token_end)))
185
token_time = Token(re.compile(r"T"),
186
None,
187
frozenset((token_hour, token_minute,
188
token_second)))
189
token_day = Token(re.compile(r"(\d+)D"),
190
datetime.timedelta(days=1),
191
frozenset((token_time, token_end)))
192
token_month = Token(re.compile(r"(\d+)M"),
193
datetime.timedelta(weeks=4),
194
frozenset((token_day, token_end)))
195
token_year = Token(re.compile(r"(\d+)Y"),
196
datetime.timedelta(weeks=52),
197
frozenset((token_month, token_end)))
198
token_week = Token(re.compile(r"(\d+)W"),
199
datetime.timedelta(weeks=1),
200
frozenset((token_end, )))
201
token_duration = Token(re.compile(r"P"), None,
202
frozenset((token_year, token_month,
203
token_day, token_time,
204
token_week)))
205
# Define starting values:
206
# Value so far
207
value = datetime.timedelta()
208
found_token = None
209
# Following valid tokens
210
followers = frozenset((token_duration, ))
211
# String left to parse
212
s = duration
213
# Loop until end token is found
214
while found_token is not token_end:
215
# Search for any currently valid tokens
216
for token in followers:
217
match = token.regexp.match(s)
218
if match is not None:
219
# Token found
220
if token.value is not None:
221
# Value found, parse digits
222
factor = int(match.group(1), 10)
223
# Add to value so far
224
value += factor * token.value
225
# Strip token from string
226
s = token.regexp.sub("", s, 1)
227
# Go to found token
228
found_token = token
229
# Set valid next tokens
230
followers = found_token.followers
231
break
232
else:
233
# No currently valid tokens were found
234
raise ValueError("Invalid RFC 3339 duration: {!r}"
235
.format(duration))
236
# End token found
237
return value
238
239
240
def string_to_delta(interval):
241
"""Parse a string and return a datetime.timedelta
242
243
>>> string_to_delta('7d')
244
datetime.timedelta(7)
245
>>> string_to_delta('60s')
246
datetime.timedelta(0, 60)
247
>>> string_to_delta('60m')
248
datetime.timedelta(0, 3600)
249
>>> string_to_delta('24h')
250
datetime.timedelta(1)
251
>>> string_to_delta('1w')
252
datetime.timedelta(7)
253
>>> string_to_delta('5m 30s')
254
datetime.timedelta(0, 330)
255
"""
256
257
try:
258
return rfc3339_duration_to_delta(interval)
259
except ValueError:
260
pass
261
262
value = datetime.timedelta(0)
263
regexp = re.compile(r"(\d+)([dsmhw]?)")
264
265
for num, suffix in regexp.findall(interval):
266
if suffix == "d":
267
value += datetime.timedelta(int(num))
268
elif suffix == "s":
269
value += datetime.timedelta(0, int(num))
270
elif suffix == "m":
271
value += datetime.timedelta(0, 0, 0, 0, int(num))
272
elif suffix == "h":
273
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
274
elif suffix == "w":
275
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
276
elif suffix == "":
277
value += datetime.timedelta(0, 0, 0, int(num))
278
return value
279
280
281
def print_clients(clients, keywords):
282
def valuetostring(value, keyword):
283
if isinstance(value, dbus.Boolean):
284
return "Yes" if value else "No"
285
if keyword in ("Timeout", "Interval", "ApprovalDelay",
286
"ApprovalDuration", "ExtendedTimeout"):
287
return milliseconds_to_string(value)
288
return str(value)
289
290
# Create format string to print table rows
291
format_string = " ".join("{{{key}:{width}}}".format(
292
width=max(len(tablewords[key]),
293
max(len(valuetostring(client[key], key))
294
for client in clients)),
295
key=key)
296
for key in keywords)
297
# Print header line
298
print(format_string.format(**tablewords))
299
for client in clients:
300
print(format_string
301
.format(**{key: valuetostring(client[key], key)
302
for key in keywords}))
303
304
305
def has_actions(options):
306
return any((options.enable,
307
options.disable,
308
options.bump_timeout,
309
options.start_checker,
310
options.stop_checker,
311
options.is_enabled,
312
options.remove,
313
options.checker is not None,
314
options.timeout is not None,
315
options.extended_timeout is not None,
316
options.interval is not None,
317
options.approved_by_default is not None,
318
options.approval_delay is not None,
319
options.approval_duration is not None,
320
options.host is not None,
321
options.secret is not None,
322
options.approve,
323
options.deny))
324
325
326
def main():
327
parser = argparse.ArgumentParser()
328
parser.add_argument("--version", action="version",
329
version="%(prog)s {}".format(version),
330
help="show version number and exit")
331
parser.add_argument("-a", "--all", action="store_true",
332
help="Select all clients")
333
parser.add_argument("-v", "--verbose", action="store_true",
334
help="Print all fields")
335
parser.add_argument("-j", "--dump-json", action="store_true",
336
help="Dump client data in JSON format")
337
parser.add_argument("-e", "--enable", action="store_true",
338
help="Enable client")
339
parser.add_argument("-d", "--disable", action="store_true",
340
help="disable client")
341
parser.add_argument("-b", "--bump-timeout", action="store_true",
342
help="Bump timeout for client")
343
parser.add_argument("--start-checker", action="store_true",
344
help="Start checker for client")
345
parser.add_argument("--stop-checker", action="store_true",
346
help="Stop checker for client")
347
parser.add_argument("-V", "--is-enabled", action="store_true",
348
help="Check if client is enabled")
349
parser.add_argument("-r", "--remove", action="store_true",
350
help="Remove client")
351
parser.add_argument("-c", "--checker",
352
help="Set checker command for client")
353
parser.add_argument("-t", "--timeout",
354
help="Set timeout for client")
355
parser.add_argument("--extended-timeout",
356
help="Set extended timeout for client")
357
parser.add_argument("-i", "--interval",
358
help="Set checker interval for client")
359
parser.add_argument("--approve-by-default", action="store_true",
360
default=None, dest="approved_by_default",
361
help="Set client to be approved by default")
362
parser.add_argument("--deny-by-default", action="store_false",
363
dest="approved_by_default",
364
help="Set client to be denied by default")
365
parser.add_argument("--approval-delay",
366
help="Set delay before client approve/deny")
367
parser.add_argument("--approval-duration",
368
help="Set duration of one client approval")
369
parser.add_argument("-H", "--host", help="Set host for client")
370
parser.add_argument("-s", "--secret",
371
type=argparse.FileType(mode="rb"),
372
help="Set password blob (file) for client")
373
parser.add_argument("-A", "--approve", action="store_true",
374
help="Approve any current client request")
375
parser.add_argument("-D", "--deny", action="store_true",
376
help="Deny any current client request")
377
parser.add_argument("--check", action="store_true",
378
help="Run self-test")
379
parser.add_argument("client", nargs="*", help="Client name")
380
options = parser.parse_args()
381
382
if has_actions(options) and not (options.client or options.all):
383
parser.error("Options require clients names or --all.")
384
if options.verbose and has_actions(options):
385
parser.error("--verbose can only be used alone.")
386
if options.dump_json and (options.verbose
387
or has_actions(options)):
388
parser.error("--dump-json can only be used alone.")
389
if options.all and not has_actions(options):
390
parser.error("--all requires an action.")
391
392
try:
393
bus = dbus.SystemBus()
394
mandos_dbus_objc = bus.get_object(busname, server_path)
395
except dbus.exceptions.DBusException:
396
log.critical("Could not connect to Mandos server")
397
sys.exit(1)
398
399
mandos_serv = dbus.Interface(mandos_dbus_objc,
400
dbus_interface=server_interface)
401
mandos_serv_object_manager = dbus.Interface(
402
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
403
404
# block stderr since dbus library prints to stderr
405
null = os.open(os.path.devnull, os.O_RDWR)
406
stderrcopy = os.dup(sys.stderr.fileno())
407
os.dup2(null, sys.stderr.fileno())
408
os.close(null)
409
try:
410
try:
411
mandos_clients = {path: ifs_and_props[client_interface]
412
for path, ifs_and_props in
413
mandos_serv_object_manager
414
.GetManagedObjects().items()
415
if client_interface in ifs_and_props}
416
finally:
417
# restore stderr
418
os.dup2(stderrcopy, sys.stderr.fileno())
419
os.close(stderrcopy)
420
except dbus.exceptions.DBusException as e:
421
log.critical("Failed to access Mandos server through D-Bus:"
422
"\n%s", e)
423
sys.exit(1)
424
425
# Compile dict of (clients: properties) to process
426
clients = {}
427
428
if options.all or not options.client:
429
clients = {bus.get_object(busname, path): properties
430
for path, properties in mandos_clients.items()}
431
else:
432
for name in options.client:
433
for path, client in mandos_clients.items():
434
if client["Name"] == name:
435
client_objc = bus.get_object(busname, path)
436
clients[client_objc] = client
437
break
438
else:
439
log.critical("Client not found on server: %r", name)
440
sys.exit(1)
441
442
if not has_actions(options) and clients:
443
if options.verbose or options.dump_json:
444
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
445
"Created", "Interval", "Host", "KeyID",
446
"Fingerprint", "CheckerRunning",
447
"LastEnabled", "ApprovalPending",
448
"ApprovedByDefault", "LastApprovalRequest",
449
"ApprovalDelay", "ApprovalDuration",
450
"Checker", "ExtendedTimeout", "Expires",
451
"LastCheckerStatus")
452
else:
453
keywords = defaultkeywords
454
455
if options.dump_json:
456
json.dump({client["Name"]: {key:
457
bool(client[key])
458
if isinstance(client[key],
459
dbus.Boolean)
460
else client[key]
461
for key in keywords}
462
for client in clients.values()},
463
fp=sys.stdout, indent=4,
464
separators=(',', ': '))
465
print()
466
else:
467
print_clients(clients.values(), keywords)
468
else:
469
# Process each client in the list by all selected options
470
for client in clients:
471
472
def set_client_prop(prop, value):
473
"""Set a Client D-Bus property"""
474
client.Set(client_interface, prop, value,
475
dbus_interface=dbus.PROPERTIES_IFACE)
476
477
def set_client_prop_ms(prop, value):
478
"""Set a Client D-Bus property, converted
479
from a string to milliseconds."""
480
set_client_prop(prop,
481
string_to_delta(value).total_seconds()
482
* 1000)
483
484
if options.remove:
485
mandos_serv.RemoveClient(client.__dbus_object_path__)
486
if options.enable:
487
set_client_prop("Enabled", dbus.Boolean(True))
488
if options.disable:
489
set_client_prop("Enabled", dbus.Boolean(False))
490
if options.bump_timeout:
491
set_client_prop("LastCheckedOK", "")
492
if options.start_checker:
493
set_client_prop("CheckerRunning", dbus.Boolean(True))
494
if options.stop_checker:
495
set_client_prop("CheckerRunning", dbus.Boolean(False))
496
if options.is_enabled:
497
if client.Get(client_interface, "Enabled",
498
dbus_interface=dbus.PROPERTIES_IFACE):
499
sys.exit(0)
500
else:
501
sys.exit(1)
502
if options.checker is not None:
503
set_client_prop("Checker", options.checker)
504
if options.host is not None:
505
set_client_prop("Host", options.host)
506
if options.interval is not None:
507
set_client_prop_ms("Interval", options.interval)
508
if options.approval_delay is not None:
509
set_client_prop_ms("ApprovalDelay",
510
options.approval_delay)
511
if options.approval_duration is not None:
512
set_client_prop_ms("ApprovalDuration",
513
options.approval_duration)
514
if options.timeout is not None:
515
set_client_prop_ms("Timeout", options.timeout)
516
if options.extended_timeout is not None:
517
set_client_prop_ms("ExtendedTimeout",
518
options.extended_timeout)
519
if options.secret is not None:
520
set_client_prop("Secret",
521
dbus.ByteArray(options.secret.read()))
522
if options.approved_by_default is not None:
523
set_client_prop("ApprovedByDefault",
524
dbus.Boolean(options
525
.approved_by_default))
526
if options.approve:
527
client.Approve(dbus.Boolean(True),
528
dbus_interface=client_interface)
529
elif options.deny:
530
client.Approve(dbus.Boolean(False),
531
dbus_interface=client_interface)
532
533
534
class Test_milliseconds_to_string(unittest.TestCase):
535
def test_all(self):
536
self.assertEqual(milliseconds_to_string(93785000),
537
"1T02:03:05")
538
def test_no_days(self):
539
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
540
def test_all_zero(self):
541
self.assertEqual(milliseconds_to_string(0), "00:00:00")
542
def test_no_fractional_seconds(self):
543
self.assertEqual(milliseconds_to_string(400), "00:00:00")
544
self.assertEqual(milliseconds_to_string(900), "00:00:00")
545
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
546
547
548
def should_only_run_tests():
549
parser = argparse.ArgumentParser(add_help=False)
550
parser.add_argument("--check", action='store_true')
551
args, unknown_args = parser.parse_known_args()
552
run_tests = args.check
553
if run_tests:
554
# Remove --check argument from sys.argv
555
sys.argv[1:] = unknown_args
556
return run_tests
557
558
# Add all tests from doctest strings
559
def load_tests(loader, tests, none):
560
import doctest
561
tests.addTests(doctest.DocTestSuite())
562
return tests
563
564
if __name__ == "__main__":
565
if should_only_run_tests():
566
# Call using ./tdd-python-script --check [--verbose]
567
unittest.main()
568
else:
569
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0