To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos-ctl
- browse files at revision 4
- compare with another revision
- download diff
- download tarball
- view history from revision 4
- Committer: Teddy Hogeborn
- Date: 2007-12-19 07:58:13 UTC
- Revision ID: teddy@fukt.bsnet.se-20071219075813-5u1w3gujvttj83qs
* server.py (Client.created, Client.next_check): New.
(string_to_delta): New.
(main): New options "--check" and "--interval". Use string_to_delta to
parse arguments to "--timeout" and "--interval".
(string_to_delta): New.
(main): New options "--check" and "--interval". Use string_to_delta to
parse arguments to "--timeout" and "--interval".
- files added:
- bad-ca.pem
- files removed:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- debian/upstream
- network-hooks.d
- plugin-helpers
- plugins.d
- files renamed:
- clients.conf => mandos-clients.conf
- mandos => server.py
- files modified:
- Makefile
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
244
try:
245
return rfc3339_duration_to_delta(interval)
246
except ValueError as e:
247
log.warning("%s - Parsing as pre-1.6.1 interval instead",
248
' '.join(e.args))
249
return parse_pre_1_6_1_interval(interval)
250
251
252
def parse_pre_1_6_1_interval(interval):
253
"""Parse an interval string as documented by Mandos before 1.6.1, and
254
return a datetime.timedelta
255
>>> parse_pre_1_6_1_interval('7d')
256
datetime.timedelta(7)
257
>>> parse_pre_1_6_1_interval('60s')
258
datetime.timedelta(0, 60)
259
>>> parse_pre_1_6_1_interval('60m')
260
datetime.timedelta(0, 3600)
261
>>> parse_pre_1_6_1_interval('24h')
262
datetime.timedelta(1)
263
>>> parse_pre_1_6_1_interval('1w')
264
datetime.timedelta(7)
265
>>> parse_pre_1_6_1_interval('5m 30s')
266
datetime.timedelta(0, 330)
267
>>> parse_pre_1_6_1_interval('')
268
datetime.timedelta(0)
269
>>> # Ignore unknown characters, allow any order and repetitions
270
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')
271
datetime.timedelta(2, 480, 18000)
272
273
"""
274
275
value = datetime.timedelta(0)
276
regexp = re.compile(r"(\d+)([dsmhw]?)")
277
278
for num, suffix in regexp.findall(interval):
279
if suffix == "d":
280
value += datetime.timedelta(int(num))
281
elif suffix == "s":
282
value += datetime.timedelta(0, int(num))
283
elif suffix == "m":
284
value += datetime.timedelta(0, 0, 0, 0, int(num))
285
elif suffix == "h":
286
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
287
elif suffix == "w":
288
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
289
elif suffix == "":
290
value += datetime.timedelta(0, 0, 0, int(num))
291
return value
292
293
294
def print_clients(clients, keywords):
295
def valuetostring(value, keyword):
296
if isinstance(value, dbus.Boolean):
297
return "Yes" if value else "No"
298
if keyword in ("Timeout", "Interval", "ApprovalDelay",
299
"ApprovalDuration", "ExtendedTimeout"):
300
return milliseconds_to_string(value)
301
return str(value)
302
303
# Create format string to print table rows
304
format_string = " ".join("{{{key}:{width}}}".format(
305
width=max(len(tablewords[key]),
306
max(len(valuetostring(client[key], key))
307
for client in clients)),
308
key=key)
309
for key in keywords)
310
# Print header line
311
print(format_string.format(**tablewords))
312
for client in clients:
313
print(format_string
314
.format(**{key: valuetostring(client[key], key)
315
for key in keywords}))
316
317
318
def has_actions(options):
319
return any((options.enable,
320
options.disable,
321
options.bump_timeout,
322
options.start_checker,
323
options.stop_checker,
324
options.is_enabled,
325
options.remove,
326
options.checker is not None,
327
options.timeout is not None,
328
options.extended_timeout is not None,
329
options.interval is not None,
330
options.approved_by_default is not None,
331
options.approval_delay is not None,
332
options.approval_duration is not None,
333
options.host is not None,
334
options.secret is not None,
335
options.approve,
336
options.deny))
337
338
339
def main():
340
parser = argparse.ArgumentParser()
341
parser.add_argument("--version", action="version",
342
version="%(prog)s {}".format(version),
343
help="show version number and exit")
344
parser.add_argument("-a", "--all", action="store_true",
345
help="Select all clients")
346
parser.add_argument("-v", "--verbose", action="store_true",
347
help="Print all fields")
348
parser.add_argument("-j", "--dump-json", action="store_true",
349
help="Dump client data in JSON format")
350
parser.add_argument("-e", "--enable", action="store_true",
351
help="Enable client")
352
parser.add_argument("-d", "--disable", action="store_true",
353
help="disable client")
354
parser.add_argument("-b", "--bump-timeout", action="store_true",
355
help="Bump timeout for client")
356
parser.add_argument("--start-checker", action="store_true",
357
help="Start checker for client")
358
parser.add_argument("--stop-checker", action="store_true",
359
help="Stop checker for client")
360
parser.add_argument("-V", "--is-enabled", action="store_true",
361
help="Check if client is enabled")
362
parser.add_argument("-r", "--remove", action="store_true",
363
help="Remove client")
364
parser.add_argument("-c", "--checker",
365
help="Set checker command for client")
366
parser.add_argument("-t", "--timeout",
367
help="Set timeout for client")
368
parser.add_argument("--extended-timeout",
369
help="Set extended timeout for client")
370
parser.add_argument("-i", "--interval",
371
help="Set checker interval for client")
372
parser.add_argument("--approve-by-default", action="store_true",
373
default=None, dest="approved_by_default",
374
help="Set client to be approved by default")
375
parser.add_argument("--deny-by-default", action="store_false",
376
dest="approved_by_default",
377
help="Set client to be denied by default")
378
parser.add_argument("--approval-delay",
379
help="Set delay before client approve/deny")
380
parser.add_argument("--approval-duration",
381
help="Set duration of one client approval")
382
parser.add_argument("-H", "--host", help="Set host for client")
383
parser.add_argument("-s", "--secret",
384
type=argparse.FileType(mode="rb"),
385
help="Set password blob (file) for client")
386
parser.add_argument("-A", "--approve", action="store_true",
387
help="Approve any current client request")
388
parser.add_argument("-D", "--deny", action="store_true",
389
help="Deny any current client request")
390
parser.add_argument("--check", action="store_true",
391
help="Run self-test")
392
parser.add_argument("client", nargs="*", help="Client name")
393
options = parser.parse_args()
394
395
if has_actions(options) and not (options.client or options.all):
396
parser.error("Options require clients names or --all.")
397
if options.verbose and has_actions(options):
398
parser.error("--verbose can only be used alone.")
399
if options.dump_json and (options.verbose
400
or has_actions(options)):
401
parser.error("--dump-json can only be used alone.")
402
if options.all and not has_actions(options):
403
parser.error("--all requires an action.")
404
405
try:
406
bus = dbus.SystemBus()
407
mandos_dbus_objc = bus.get_object(busname, server_path)
408
except dbus.exceptions.DBusException:
409
log.critical("Could not connect to Mandos server")
410
sys.exit(1)
411
412
mandos_serv = dbus.Interface(mandos_dbus_objc,
413
dbus_interface=server_interface)
414
mandos_serv_object_manager = dbus.Interface(
415
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
416
417
# block stderr since dbus library prints to stderr
418
null = os.open(os.path.devnull, os.O_RDWR)
419
stderrcopy = os.dup(sys.stderr.fileno())
420
os.dup2(null, sys.stderr.fileno())
421
os.close(null)
422
try:
423
try:
424
mandos_clients = {path: ifs_and_props[client_interface]
425
for path, ifs_and_props in
426
mandos_serv_object_manager
427
.GetManagedObjects().items()
428
if client_interface in ifs_and_props}
429
finally:
430
# restore stderr
431
os.dup2(stderrcopy, sys.stderr.fileno())
432
os.close(stderrcopy)
433
except dbus.exceptions.DBusException as e:
434
log.critical("Failed to access Mandos server through D-Bus:"
435
"\n%s", e)
436
sys.exit(1)
437
438
# Compile dict of (clients: properties) to process
439
clients = {}
440
441
if options.all or not options.client:
442
clients = {bus.get_object(busname, path): properties
443
for path, properties in mandos_clients.items()}
444
else:
445
for name in options.client:
446
for path, client in mandos_clients.items():
447
if client["Name"] == name:
448
client_objc = bus.get_object(busname, path)
449
clients[client_objc] = client
450
break
451
else:
452
log.critical("Client not found on server: %r", name)
453
sys.exit(1)
454
455
if not has_actions(options) and clients:
456
if options.verbose or options.dump_json:
457
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
458
"Created", "Interval", "Host", "KeyID",
459
"Fingerprint", "CheckerRunning",
460
"LastEnabled", "ApprovalPending",
461
"ApprovedByDefault", "LastApprovalRequest",
462
"ApprovalDelay", "ApprovalDuration",
463
"Checker", "ExtendedTimeout", "Expires",
464
"LastCheckerStatus")
465
else:
466
keywords = defaultkeywords
467
468
if options.dump_json:
469
json.dump({client["Name"]: {key:
470
bool(client[key])
471
if isinstance(client[key],
472
dbus.Boolean)
473
else client[key]
474
for key in keywords}
475
for client in clients.values()},
476
fp=sys.stdout, indent=4,
477
separators=(',', ': '))
478
print()
479
else:
480
print_clients(clients.values(), keywords)
481
else:
482
# Process each client in the list by all selected options
483
for client in clients:
484
485
def set_client_prop(prop, value):
486
"""Set a Client D-Bus property"""
487
client.Set(client_interface, prop, value,
488
dbus_interface=dbus.PROPERTIES_IFACE)
489
490
def set_client_prop_ms(prop, value):
491
"""Set a Client D-Bus property, converted
492
from a string to milliseconds."""
493
set_client_prop(prop,
494
string_to_delta(value).total_seconds()
495
* 1000)
496
497
if options.remove:
498
mandos_serv.RemoveClient(client.__dbus_object_path__)
499
if options.enable:
500
set_client_prop("Enabled", dbus.Boolean(True))
501
if options.disable:
502
set_client_prop("Enabled", dbus.Boolean(False))
503
if options.bump_timeout:
504
set_client_prop("LastCheckedOK", "")
505
if options.start_checker:
506
set_client_prop("CheckerRunning", dbus.Boolean(True))
507
if options.stop_checker:
508
set_client_prop("CheckerRunning", dbus.Boolean(False))
509
if options.is_enabled:
510
if client.Get(client_interface, "Enabled",
511
dbus_interface=dbus.PROPERTIES_IFACE):
512
sys.exit(0)
513
else:
514
sys.exit(1)
515
if options.checker is not None:
516
set_client_prop("Checker", options.checker)
517
if options.host is not None:
518
set_client_prop("Host", options.host)
519
if options.interval is not None:
520
set_client_prop_ms("Interval", options.interval)
521
if options.approval_delay is not None:
522
set_client_prop_ms("ApprovalDelay",
523
options.approval_delay)
524
if options.approval_duration is not None:
525
set_client_prop_ms("ApprovalDuration",
526
options.approval_duration)
527
if options.timeout is not None:
528
set_client_prop_ms("Timeout", options.timeout)
529
if options.extended_timeout is not None:
530
set_client_prop_ms("ExtendedTimeout",
531
options.extended_timeout)
532
if options.secret is not None:
533
set_client_prop("Secret",
534
dbus.ByteArray(options.secret.read()))
535
if options.approved_by_default is not None:
536
set_client_prop("ApprovedByDefault",
537
dbus.Boolean(options
538
.approved_by_default))
539
if options.approve:
540
client.Approve(dbus.Boolean(True),
541
dbus_interface=client_interface)
542
elif options.deny:
543
client.Approve(dbus.Boolean(False),
544
dbus_interface=client_interface)
545
546
547
class Test_milliseconds_to_string(unittest.TestCase):
548
def test_all(self):
549
self.assertEqual(milliseconds_to_string(93785000),
550
"1T02:03:05")
551
def test_no_days(self):
552
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
553
def test_all_zero(self):
554
self.assertEqual(milliseconds_to_string(0), "00:00:00")
555
def test_no_fractional_seconds(self):
556
self.assertEqual(milliseconds_to_string(400), "00:00:00")
557
self.assertEqual(milliseconds_to_string(900), "00:00:00")
558
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
559
560
561
def should_only_run_tests():
562
parser = argparse.ArgumentParser(add_help=False)
563
parser.add_argument("--check", action='store_true')
564
args, unknown_args = parser.parse_known_args()
565
run_tests = args.check
566
if run_tests:
567
# Remove --check argument from sys.argv
568
sys.argv[1:] = unknown_args
569
return run_tests
570
571
# Add all tests from doctest strings
572
def load_tests(loader, tests, none):
573
import doctest
574
tests.addTests(doctest.DocTestSuite())
575
return tests
576
577
if __name__ == "__main__":
578
if should_only_run_tests():
579
# Call using ./tdd-python-script --check [--verbose]
580
unittest.main()
581
else:
582
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0