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 505.3.11
- compare with another revision
- download diff
- download tarball
- view history from revision 505.3.11
- Committer: Teddy Hogeborn
- Date: 2011-11-24 21:12:35 UTC
- mto: (505.2.9 mandos-client-network-hooks)
- mto: This revision was merged to the branch mainline in revision 525.
- Revision ID: teddy@recompile.se-20111124211235-drbwkp12g6fdn59c
* Makefile (run-client): Add "--network-hook-dir" option.
* plugin-runner.c (main): Only try to work around Debian bug #633582
if started as root.
* plugins.d/mandos-client.c (run_network_hooks): Bug fix: Run all
network hooks, not
just the first one.
Also add debug output.
(main): Only try to work around Debian bug #633582 or run network
hooks as root if started as root.
* plugin-runner.c (main): Only try to work around Debian bug #633582
if started as root.
* plugins.d/mandos-client.c (run_network_hooks): Bug fix: Run all
network hooks, not
just the first one.
Also add debug output.
(main): Only try to work around Debian bug #633582 or run network
hooks as root if started as root.
- files added:
- initramfs-tools-hook-conf
- files removed:
- bugs.xml
- debian/upstream
- plugin-helpers
- files modified:
- .bzrignore
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-2011 Teddy Hogeborn
7
# Copyright © 2008-2011 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 <http://www.gnu.org/licenses/>.
21
#
24
22
# Contact the authors at <mandos@recompile.se>.
25
#
23
#
26
24
27
25
from __future__ import (division, absolute_import, print_function,
28
26
unicode_literals)
29
27
30
try:
31
from future_builtins import *
32
except ImportError:
33
pass
34
35
28
import sys
29
import dbus
36
30
import argparse
37
31
import locale
38
32
import datetime
39
33
import re
40
34
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
35
62
36
locale.setlocale(locale.LC_ALL, "")
63
37
38
tablewords = {
39
"Name": "Name",
40
"Enabled": "Enabled",
41
"Timeout": "Timeout",
42
"LastCheckedOK": "Last Successful Check",
43
"LastApprovalRequest": "Last Approval Request",
44
"Created": "Created",
45
"Interval": "Interval",
46
"Host": "Host",
47
"Fingerprint": "Fingerprint",
48
"CheckerRunning": "Check Is Running",
49
"LastEnabled": "Last Enabled",
50
"ApprovalPending": "Approval Is Pending",
51
"ApprovedByDefault": "Approved By Default",
52
"ApprovalDelay": "Approval Delay",
53
"ApprovalDuration": "Approval Duration",
54
"Checker": "Checker",
55
"ExtendedTimeout" : "Extended Timeout"
56
}
57
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
64
58
domain = "se.recompile"
65
59
busname = domain + ".Mandos"
66
60
server_path = "/"
67
61
server_interface = domain + ".Mandos"
68
62
client_interface = domain + ".Mandos.Client"
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
63
version = "1.4.1"
64
65
def timedelta_to_milliseconds(td):
66
"""Convert a datetime.timedelta object to milliseconds"""
67
return ((td.days * 24 * 60 * 60 * 1000)
68
+ (td.seconds * 1000)
69
+ (td.microseconds // 1000))
77
70
78
71
def milliseconds_to_string(ms):
79
72
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
86
87
def rfc3339_duration_to_delta(duration):
88
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
89
90
>>> rfc3339_duration_to_delta("P7D")
91
datetime.timedelta(7)
92
>>> rfc3339_duration_to_delta("PT60S")
93
datetime.timedelta(0, 60)
94
>>> rfc3339_duration_to_delta("PT60M")
95
datetime.timedelta(0, 3600)
96
>>> rfc3339_duration_to_delta("P60M")
97
datetime.timedelta(1680)
98
>>> rfc3339_duration_to_delta("PT24H")
99
datetime.timedelta(1)
100
>>> rfc3339_duration_to_delta("P1W")
101
datetime.timedelta(7)
102
>>> rfc3339_duration_to_delta("PT5M30S")
103
datetime.timedelta(0, 330)
104
>>> rfc3339_duration_to_delta("P1DT3M20S")
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'
135
"""
136
137
# Parsing an RFC 3339 duration with regular expressions is not
138
# possible - there would have to be multiple places for the same
139
# values, like seconds. The current code, while more esoteric, is
140
# cleaner without depending on a parsing library. If Python had a
141
# built-in library for parsing we would use it, but we'd like to
142
# avoid excessive use of external libraries.
143
144
# New type for defining tokens, syntax, and semantics all-in-one
145
Token = collections.namedtuple("Token", (
146
"regexp", # To match token; if "value" is not None, must have
147
# a "group" containing digits
148
"value", # datetime.timedelta or None
149
"followers")) # Tokens valid after this token
150
# RFC 3339 "duration" tokens, syntax, and semantics; taken from
151
# the "duration" ABNF definition in RFC 3339, Appendix A.
152
token_end = Token(re.compile(r"$"), None, frozenset())
153
token_second = Token(re.compile(r"(\d+)S"),
154
datetime.timedelta(seconds=1),
155
frozenset((token_end, )))
156
token_minute = Token(re.compile(r"(\d+)M"),
157
datetime.timedelta(minutes=1),
158
frozenset((token_second, token_end)))
159
token_hour = Token(re.compile(r"(\d+)H"),
160
datetime.timedelta(hours=1),
161
frozenset((token_minute, token_end)))
162
token_time = Token(re.compile(r"T"),
163
None,
164
frozenset((token_hour, token_minute,
165
token_second)))
166
token_day = Token(re.compile(r"(\d+)D"),
167
datetime.timedelta(days=1),
168
frozenset((token_time, token_end)))
169
token_month = Token(re.compile(r"(\d+)M"),
170
datetime.timedelta(weeks=4),
171
frozenset((token_day, token_end)))
172
token_year = Token(re.compile(r"(\d+)Y"),
173
datetime.timedelta(weeks=52),
174
frozenset((token_month, token_end)))
175
token_week = Token(re.compile(r"(\d+)W"),
176
datetime.timedelta(weeks=1),
177
frozenset((token_end, )))
178
token_duration = Token(re.compile(r"P"), None,
179
frozenset((token_year, token_month,
180
token_day, token_time,
181
token_week)))
182
# Define starting values:
183
# Value so far
184
value = datetime.timedelta()
185
found_token = None
186
# Following valid tokens
187
followers = frozenset((token_duration, ))
188
# String left to parse
189
s = duration
190
# Loop until end token is found
191
while found_token is not token_end:
192
# Search for any currently valid tokens
193
for token in followers:
194
match = token.regexp.match(s)
195
if match is not None:
196
# Token found
197
if token.value is not None:
198
# Value found, parse digits
199
factor = int(match.group(1), 10)
200
# Add to value so far
201
value += factor * token.value
202
# Strip token from string
203
s = token.regexp.sub("", s, 1)
204
# Go to found token
205
found_token = token
206
# Set valid next tokens
207
followers = found_token.followers
208
break
209
else:
210
# No currently valid tokens were found
211
raise ValueError("Invalid RFC 3339 duration: {!r}"
212
.format(duration))
213
# End token found
214
return value
215
73
return ("%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"
74
% { "days": "%dT" % td.days if td.days else "",
75
"hours": td.seconds // 3600,
76
"minutes": (td.seconds % 3600) // 60,
77
"seconds": td.seconds % 60,
78
})
216
79
217
80
def string_to_delta(interval):
218
"""Parse a string and return a datetime.timedelta"""
219
220
try:
221
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')
81
"""Parse a string and return a datetime.timedelta
82
83
>>> string_to_delta("7d")
233
84
datetime.timedelta(7)
234
>>> parse_pre_1_6_1_interval('60s')
85
>>> string_to_delta("60s")
235
86
datetime.timedelta(0, 60)
236
>>> parse_pre_1_6_1_interval('60m')
87
>>> string_to_delta("60m")
237
88
datetime.timedelta(0, 3600)
238
>>> parse_pre_1_6_1_interval('24h')
89
>>> string_to_delta("24h")
239
90
datetime.timedelta(1)
240
>>> parse_pre_1_6_1_interval('1w')
91
>>> string_to_delta("1w")
241
92
datetime.timedelta(7)
242
>>> parse_pre_1_6_1_interval('5m 30s')
93
>>> string_to_delta("5m 30s")
243
94
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
95
"""
251
252
value = datetime.timedelta(0)
253
regexp = re.compile(r"(\d+)([dsmhw]?)")
254
255
for num, suffix in regexp.findall(interval):
256
if suffix == "d":
257
value += datetime.timedelta(int(num))
258
elif suffix == "s":
259
value += datetime.timedelta(0, int(num))
260
elif suffix == "m":
261
value += datetime.timedelta(0, 0, 0, 0, int(num))
262
elif suffix == "h":
263
value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
264
elif suffix == "w":
265
value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
266
elif suffix == "":
267
value += datetime.timedelta(0, 0, 0, int(num))
268
return value
269
270
271
class TableOfClients(object):
272
tablewords = {
273
"Name": "Name",
274
"Enabled": "Enabled",
275
"Timeout": "Timeout",
276
"LastCheckedOK": "Last Successful Check",
277
"LastApprovalRequest": "Last Approval Request",
278
"Created": "Created",
279
"Interval": "Interval",
280
"Host": "Host",
281
"Fingerprint": "Fingerprint",
282
"KeyID": "Key ID",
283
"CheckerRunning": "Check Is Running",
284
"LastEnabled": "Last Enabled",
285
"ApprovalPending": "Approval Is Pending",
286
"ApprovedByDefault": "Approved By Default",
287
"ApprovalDelay": "Approval Delay",
288
"ApprovalDuration": "Approval Duration",
289
"Checker": "Checker",
290
"ExtendedTimeout": "Extended Timeout",
291
"Expires": "Expires",
292
"LastCheckerStatus": "Last Checker Status",
293
}
294
295
def __init__(self, clients, keywords, tablewords=None):
296
self.clients = clients
297
self.keywords = keywords
298
if tablewords is not None:
299
self.tablewords = tablewords
300
301
def __str__(self):
302
return "\n".join(self.rows())
303
304
if sys.version_info.major == 2:
305
__unicode__ = __str__
306
def __str__(self):
307
return str(self).encode(locale.getpreferredencoding())
308
309
def rows(self):
310
format_string = self.row_formatting_string()
311
rows = [self.header_line(format_string)]
312
rows.extend(self.client_line(client, format_string)
313
for client in self.clients)
314
return rows
315
316
def row_formatting_string(self):
317
"Format string used to format table rows"
318
return " ".join("{{{key}:{width}}}".format(
319
width=max(len(self.tablewords[key]),
320
*(len(self.string_from_client(client, key))
321
for client in self.clients)),
322
key=key)
323
for key in self.keywords)
324
325
def string_from_client(self, client, key):
326
return self.valuetostring(client[key], key)
327
328
@staticmethod
96
timevalue = datetime.timedelta(0)
97
regexp = re.compile("\d+[dsmhw]")
98
99
for s in regexp.findall(interval):
100
try:
101
suffix = unicode(s[-1])
102
value = int(s[:-1])
103
if suffix == "d":
104
delta = datetime.timedelta(value)
105
elif suffix == "s":
106
delta = datetime.timedelta(0, value)
107
elif suffix == "m":
108
delta = datetime.timedelta(0, 0, 0, 0, value)
109
elif suffix == "h":
110
delta = datetime.timedelta(0, 0, 0, 0, 0, value)
111
elif suffix == "w":
112
delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)
113
else:
114
raise ValueError
115
except (ValueError, IndexError):
116
raise ValueError
117
timevalue += delta
118
return timevalue
119
120
def print_clients(clients, keywords):
329
121
def valuetostring(value, keyword):
330
if isinstance(value, dbus.Boolean):
122
if type(value) is dbus.Boolean:
331
123
return "Yes" if value else "No"
332
124
if keyword in ("Timeout", "Interval", "ApprovalDelay",
333
"ApprovalDuration", "ExtendedTimeout"):
125
"ApprovalDuration"):
334
126
return milliseconds_to_string(value)
335
return str(value)
336
337
def header_line(self, format_string):
338
return format_string.format(**self.tablewords)
339
340
def client_line(self, client, format_string):
341
return format_string.format(
342
**{key: self.string_from_client(client, key)
343
for key in self.keywords})
344
345
346
## Classes for commands.
347
348
# Abstract classes first
349
class Command(object):
350
"""Abstract class for commands"""
351
def run(self, clients):
352
"""Normal commands should implement run_on_one_client(), but
353
commands which want to operate on all clients at the same time
354
can override this run() method instead."""
355
for client in clients:
356
self.run_on_one_client(client)
357
358
class PrintCmd(Command):
359
"""Abstract class for commands printing client details"""
360
all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
361
"Created", "Interval", "Host", "KeyID",
362
"Fingerprint", "CheckerRunning", "LastEnabled",
363
"ApprovalPending", "ApprovedByDefault",
364
"LastApprovalRequest", "ApprovalDelay",
365
"ApprovalDuration", "Checker", "ExtendedTimeout",
366
"Expires", "LastCheckerStatus")
367
def run(self, clients):
368
print(self.output(clients))
369
370
class PropertyCmd(Command):
371
"""Abstract class for Actions for setting one client property"""
372
def run_on_one_client(self, client):
373
"""Set the Client's D-Bus property"""
374
client.Set(client_interface, self.property, self.value_to_set,
375
dbus_interface=dbus.PROPERTIES_IFACE)
376
377
class ValueArgumentMixIn(object):
378
"""Mixin class for commands taking a value as argument"""
379
def __init__(self, value):
380
self.value_to_set = value
381
382
class MillisecondsValueArgumentMixIn(ValueArgumentMixIn):
383
"""Mixin class for commands taking a value argument as
384
milliseconds."""
385
@property
386
def value_to_set(self):
387
return self._vts
388
@value_to_set.setter
389
def value_to_set(self, value):
390
"""When setting, convert value to a datetime.timedelta"""
391
self._vts = string_to_delta(value).total_seconds() * 1000
392
393
# Actual (non-abstract) command classes
394
395
class PrintTableCmd(PrintCmd):
396
def __init__(self, verbose=False):
397
self.verbose = verbose
398
def output(self, clients):
399
if self.verbose:
400
keywords = self.all_keywords
401
else:
402
keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
403
return str(TableOfClients(clients.values(), keywords))
404
405
class DumpJSONCmd(PrintCmd):
406
def output(self, clients):
407
data = {client["Name"]:
408
{key: self.dbus_boolean_to_bool(client[key])
409
for key in self.all_keywords}
410
for client in clients.values()}
411
return json.dumps(data, indent=4, separators=(',', ': '))
412
@staticmethod
413
def dbus_boolean_to_bool(value):
414
if isinstance(value, dbus.Boolean):
415
value = bool(value)
416
return value
417
418
class IsEnabledCmd(Command):
419
def run_on_one_client(self, client):
420
if self.is_enabled(client):
421
sys.exit(0)
422
sys.exit(1)
423
def is_enabled(self, client):
424
return client.Get(client_interface, "Enabled",
425
dbus_interface=dbus.PROPERTIES_IFACE)
426
427
class RemoveCmd(Command):
428
def __init__(self, mandos):
429
self.mandos = mandos
430
def run_on_one_client(self, client):
431
self.mandos.RemoveClient(client.__dbus_object_path__)
432
433
class ApproveCmd(Command):
434
def run_on_one_client(self, client):
435
client.Approve(dbus.Boolean(True),
436
dbus_interface=client_interface)
437
438
class DenyCmd(Command):
439
def run_on_one_client(self, client):
440
client.Approve(dbus.Boolean(False),
441
dbus_interface=client_interface)
442
443
class EnableCmd(PropertyCmd):
444
property = "Enabled"
445
value_to_set = dbus.Boolean(True)
446
447
class DisableCmd(PropertyCmd):
448
property = "Enabled"
449
value_to_set = dbus.Boolean(False)
450
451
class BumpTimeoutCmd(PropertyCmd):
452
property = "LastCheckedOK"
453
value_to_set = ""
454
455
class StartCheckerCmd(PropertyCmd):
456
property = "CheckerRunning"
457
value_to_set = dbus.Boolean(True)
458
459
class StopCheckerCmd(PropertyCmd):
460
property = "CheckerRunning"
461
value_to_set = dbus.Boolean(False)
462
463
class ApproveByDefaultCmd(PropertyCmd):
464
property = "ApprovedByDefault"
465
value_to_set = dbus.Boolean(True)
466
467
class DenyByDefaultCmd(PropertyCmd):
468
property = "ApprovedByDefault"
469
value_to_set = dbus.Boolean(False)
470
471
class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):
472
property = "Checker"
473
474
class SetHostCmd(PropertyCmd, ValueArgumentMixIn):
475
property = "Host"
476
477
class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):
478
property = "Secret"
479
480
class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
481
property = "Timeout"
482
483
class SetExtendedTimeoutCmd(PropertyCmd,
484
MillisecondsValueArgumentMixIn):
485
property = "ExtendedTimeout"
486
487
class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):
488
property = "Interval"
489
490
class SetApprovalDelayCmd(PropertyCmd,
491
MillisecondsValueArgumentMixIn):
492
property = "ApprovalDelay"
493
494
class SetApprovalDurationCmd(PropertyCmd,
495
MillisecondsValueArgumentMixIn):
496
property = "ApprovalDuration"
127
return unicode(value)
128
129
# Create format string to print table rows
130
format_string = " ".join("%%-%ds" %
131
max(len(tablewords[key]),
132
max(len(valuetostring(client[key],
133
key))
134
for client in
135
clients))
136
for key in keywords)
137
# Print header line
138
print(format_string % tuple(tablewords[key] for key in keywords))
139
for client in clients:
140
print(format_string % tuple(valuetostring(client[key], key)
141
for key in keywords))
497
142
498
143
def has_actions(options):
499
144
return any((options.enable,
515
160
options.approve,
516
161
options.deny))
517
162
518
519
163
def main():
520
164
parser = argparse.ArgumentParser()
521
165
parser.add_argument("--version", action="version",
522
version="%(prog)s {}".format(version),
166
version = "%%prog %s" % version,
523
167
help="show version number and exit")
524
168
parser.add_argument("-a", "--all", action="store_true",
525
169
help="Select all clients")
526
170
parser.add_argument("-v", "--verbose", action="store_true",
527
171
help="Print all fields")
528
parser.add_argument("-j", "--dump-json", action="store_true",
529
help="Dump client data in JSON format")
530
enable_disable = parser.add_mutually_exclusive_group()
531
enable_disable.add_argument("-e", "--enable", action="store_true",
532
help="Enable client")
533
enable_disable.add_argument("-d", "--disable",
534
action="store_true",
535
help="disable client")
172
parser.add_argument("-e", "--enable", action="store_true",
173
help="Enable client")
174
parser.add_argument("-d", "--disable", action="store_true",
175
help="disable client")
536
176
parser.add_argument("-b", "--bump-timeout", action="store_true",
537
177
help="Bump timeout for client")
538
start_stop_checker = parser.add_mutually_exclusive_group()
539
start_stop_checker.add_argument("--start-checker",
540
action="store_true",
541
help="Start checker for client")
542
start_stop_checker.add_argument("--stop-checker",
543
action="store_true",
544
help="Stop checker for client")
178
parser.add_argument("--start-checker", action="store_true",
179
help="Start checker for client")
180
parser.add_argument("--stop-checker", action="store_true",
181
help="Stop checker for client")
545
182
parser.add_argument("-V", "--is-enabled", action="store_true",
546
183
help="Check if client is enabled")
547
184
parser.add_argument("-r", "--remove", action="store_true",
554
191
help="Set extended timeout for client")
555
192
parser.add_argument("-i", "--interval",
556
193
help="Set checker interval for client")
557
approve_deny_default = parser.add_mutually_exclusive_group()
558
approve_deny_default.add_argument(
559
"--approve-by-default", action="store_true",
560
default=None, dest="approved_by_default",
561
help="Set client to be approved by default")
562
approve_deny_default.add_argument(
563
"--deny-by-default", action="store_false",
564
dest="approved_by_default",
565
help="Set client to be denied by default")
194
parser.add_argument("--approve-by-default", action="store_true",
195
default=None, dest="approved_by_default",
196
help="Set client to be approved by default")
197
parser.add_argument("--deny-by-default", action="store_false",
198
dest="approved_by_default",
199
help="Set client to be denied by default")
566
200
parser.add_argument("--approval-delay",
567
201
help="Set delay before client approve/deny")
568
202
parser.add_argument("--approval-duration",
569
203
help="Set duration of one client approval")
570
204
parser.add_argument("-H", "--host", help="Set host for client")
571
parser.add_argument("-s", "--secret",
572
type=argparse.FileType(mode="rb"),
205
parser.add_argument("-s", "--secret", type=file,
573
206
help="Set password blob (file) for client")
574
approve_deny = parser.add_mutually_exclusive_group()
575
approve_deny.add_argument(
576
"-A", "--approve", action="store_true",
577
help="Approve any current client request")
578
approve_deny.add_argument("-D", "--deny", action="store_true",
579
help="Deny any current client request")
580
parser.add_argument("--check", action="store_true",
581
help="Run self-test")
207
parser.add_argument("-A", "--approve", action="store_true",
208
help="Approve any current client request")
209
parser.add_argument("-D", "--deny", action="store_true",
210
help="Deny any current client request")
582
211
parser.add_argument("client", nargs="*", help="Client name")
583
212
options = parser.parse_args()
584
585
if has_actions(options) and not (options.client or options.all):
213
214
if has_actions(options) and not options.client and not options.all:
586
215
parser.error("Options require clients names or --all.")
587
216
if options.verbose and has_actions(options):
588
parser.error("--verbose can only be used alone.")
589
if options.dump_json and (options.verbose
590
or has_actions(options)):
591
parser.error("--dump-json can only be used alone.")
217
parser.error("--verbose can only be used alone or with"
218
" --all.")
592
219
if options.all and not has_actions(options):
593
220
parser.error("--all requires an action.")
594
if options.is_enabled and len(options.client) > 1:
595
parser.error("--is-enabled requires exactly one client")
596
221
597
222
try:
598
223
bus = dbus.SystemBus()
599
224
mandos_dbus_objc = bus.get_object(busname, server_path)
600
225
except dbus.exceptions.DBusException:
601
log.critical("Could not connect to Mandos server")
226
print("Could not connect to Mandos server",
227
file=sys.stderr)
602
228
sys.exit(1)
603
229
604
230
mandos_serv = dbus.Interface(mandos_dbus_objc,
605
dbus_interface=server_interface)
606
mandos_serv_object_manager = dbus.Interface(
607
mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
608
609
commands = []
610
611
if options.dump_json:
612
commands.append(DumpJSONCmd())
613
614
if options.enable:
615
commands.append(EnableCmd())
616
617
if options.disable:
618
commands.append(DisableCmd())
619
620
if options.bump_timeout:
621
commands.append(BumpTimeoutCmd(options.bump_timeout))
622
623
if options.start_checker:
624
commands.append(StartCheckerCmd())
625
626
if options.stop_checker:
627
commands.append(StopCheckerCmd())
628
629
if options.is_enabled:
630
commands.append(IsEnabledCmd())
631
632
if options.remove:
633
commands.append(RemoveCmd(mandos_serv))
634
635
if options.checker is not None:
636
commands.append(SetCheckerCmd())
637
638
if options.timeout is not None:
639
commands.append(SetTimeoutCmd(options.timeout))
640
641
if options.extended_timeout:
642
commands.append(
643
SetExtendedTimeoutCmd(options.extended_timeout))
644
645
if options.interval is not None:
646
command.append(SetIntervalCmd(options.interval))
647
648
if options.approved_by_default is not None:
649
if options.approved_by_default:
650
command.append(ApproveByDefaultCmd())
651
else:
652
command.append(DenyByDefaultCmd())
653
654
if options.approval_delay is not None:
655
command.append(SetApprovalDelayCmd(options.approval_delay))
656
657
if options.approval_duration is not None:
658
command.append(
659
SetApprovalDurationCmd(options.approval_duration))
660
661
if options.host is not None:
662
command.append(SetHostCmd(options.host))
663
664
if options.secret is not None:
665
command.append(SetSecretCmd(options.secret))
666
667
if options.approve:
668
commands.append(ApproveCmd())
669
670
if options.deny:
671
commands.append(DenyCmd())
672
673
# If no command option has been given, show table of clients,
674
# optionally verbosely
675
if not commands:
676
commands.append(PrintTableCmd(verbose=options.verbose))
677
678
# block stderr since dbus library prints to stderr
231
dbus_interface = server_interface)
232
233
#block stderr since dbus library prints to stderr
679
234
null = os.open(os.path.devnull, os.O_RDWR)
680
235
stderrcopy = os.dup(sys.stderr.fileno())
681
236
os.dup2(null, sys.stderr.fileno())
682
237
os.close(null)
683
238
try:
684
239
try:
685
mandos_clients = {path: ifs_and_props[client_interface]
686
for path, ifs_and_props in
687
mandos_serv_object_manager
688
.GetManagedObjects().items()
689
if client_interface in ifs_and_props}
240
mandos_clients = mandos_serv.GetAllClientsWithProperties()
690
241
finally:
691
# restore stderr
242
#restore stderr
692
243
os.dup2(stderrcopy, sys.stderr.fileno())
693
244
os.close(stderrcopy)
694
except dbus.exceptions.DBusException as e:
695
log.critical("Failed to access Mandos server through D-Bus:"
696
"\n%s", e)
245
except dbus.exceptions.DBusException, e:
246
print("Access denied: Accessing mandos server through dbus.",
247
file=sys.stderr)
697
248
sys.exit(1)
698
249
699
250
# Compile dict of (clients: properties) to process
700
clients = {}
701
251
clients={}
252
702
253
if options.all or not options.client:
703
clients = {bus.get_object(busname, path): properties
704
for path, properties in mandos_clients.items()}
254
clients = dict((bus.get_object(busname, path), properties)
255
for path, properties in
256
mandos_clients.iteritems())
705
257
else:
706
258
for name in options.client:
707
for path, client in mandos_clients.items():
259
for path, client in mandos_clients.iteritems():
708
260
if client["Name"] == name:
709
261
client_objc = bus.get_object(busname, path)
710
262
clients[client_objc] = client
711
263
break
712
264
else:
713
log.critical("Client not found on server: %r", name)
265
print("Client not found on server: %r" % name,
266
file=sys.stderr)
714
267
sys.exit(1)
715
716
# Run all commands on clients
717
for command in commands:
718
command.run(clients)
719
720
721
class Test_milliseconds_to_string(unittest.TestCase):
722
def test_all(self):
723
self.assertEqual(milliseconds_to_string(93785000),
724
"1T02:03:05")
725
def test_no_days(self):
726
self.assertEqual(milliseconds_to_string(7385000), "02:03:05")
727
def test_all_zero(self):
728
self.assertEqual(milliseconds_to_string(0), "00:00:00")
729
def test_no_fractional_seconds(self):
730
self.assertEqual(milliseconds_to_string(400), "00:00:00")
731
self.assertEqual(milliseconds_to_string(900), "00:00:00")
732
self.assertEqual(milliseconds_to_string(1900), "00:00:01")
733
734
class Test_string_to_delta(unittest.TestCase):
735
def test_handles_basic_rfc3339(self):
736
self.assertEqual(string_to_delta("PT2H"),
737
datetime.timedelta(0, 7200))
738
def test_falls_back_to_pre_1_6_1_with_warning(self):
739
# assertLogs only exists in Python 3.4
740
if hasattr(self, "assertLogs"):
741
with self.assertLogs(log, logging.WARNING):
742
value = string_to_delta("2h")
268
269
if not has_actions(options) and clients:
270
if options.verbose:
271
keywords = ("Name", "Enabled", "Timeout",
272
"LastCheckedOK", "Created", "Interval",
273
"Host", "Fingerprint", "CheckerRunning",
274
"LastEnabled", "ApprovalPending",
275
"ApprovedByDefault",
276
"LastApprovalRequest", "ApprovalDelay",
277
"ApprovalDuration", "Checker",
278
"ExtendedTimeout")
743
279
else:
744
value = string_to_delta("2h")
745
self.assertEqual(value, datetime.timedelta(0, 7200))
746
747
class Test_TableOfClients(unittest.TestCase):
748
def setUp(self):
749
self.tablewords = {
750
"Attr1": "X",
751
"AttrTwo": "Yy",
752
"AttrThree": "Zzz",
753
"Bool": "A D-BUS Boolean",
754
"NonDbusBoolean": "A Non-D-BUS Boolean",
755
"Integer": "An Integer",
756
"Timeout": "Timedelta 1",
757
"Interval": "Timedelta 2",
758
"ApprovalDelay": "Timedelta 3",
759
"ApprovalDuration": "Timedelta 4",
760
"ExtendedTimeout": "Timedelta 5",
761
"String": "A String",
762
}
763
self.keywords = ["Attr1", "AttrTwo"]
764
self.clients = [
765
{
766
"Attr1": "x1",
767
"AttrTwo": "y1",
768
"AttrThree": "z1",
769
"Bool": dbus.Boolean(False),
770
"NonDbusBoolean": False,
771
"Integer": 0,
772
"Timeout": 0,
773
"Interval": 1000,
774
"ApprovalDelay": 2000,
775
"ApprovalDuration": 3000,
776
"ExtendedTimeout": 4000,
777
"String": "",
778
},
779
{
780
"Attr1": "x2",
781
"AttrTwo": "y2",
782
"AttrThree": "z2",
783
"Bool": dbus.Boolean(True),
784
"NonDbusBoolean": True,
785
"Integer": 1,
786
"Timeout": 93785000,
787
"Interval": 93786000,
788
"ApprovalDelay": 93787000,
789
"ApprovalDuration": 93788000,
790
"ExtendedTimeout": 93789000,
791
"String": "A huge string which will not fit," * 10,
792
},
793
]
794
def test_short_header(self):
795
text = str(TableOfClients(self.clients, self.keywords,
796
self.tablewords))
797
expected_text = """
798
X Yy
799
x1 y1
800
x2 y2
801
"""[1:-1]
802
self.assertEqual(text, expected_text)
803
def test_booleans(self):
804
keywords = ["Bool", "NonDbusBoolean"]
805
text = str(TableOfClients(self.clients, keywords,
806
self.tablewords))
807
expected_text = """
808
A D-BUS Boolean A Non-D-BUS Boolean
809
No False
810
Yes True
811
"""[1:-1]
812
self.assertEqual(text, expected_text)
813
def test_milliseconds_detection(self):
814
keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",
815
"ApprovalDuration", "ExtendedTimeout"]
816
text = str(TableOfClients(self.clients, keywords,
817
self.tablewords))
818
expected_text = """
819
An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5
820
0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04
821
1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09
822
"""[1:-1]
823
self.assertEqual(text, expected_text)
824
def test_empty_and_long_string_values(self):
825
keywords = ["String"]
826
text = str(TableOfClients(self.clients, keywords,
827
self.tablewords))
828
expected_text = """
829
A String
830
831
A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,
832
"""[1:-1]
833
self.assertEqual(text, expected_text)
834
835
836
837
def should_only_run_tests():
838
parser = argparse.ArgumentParser(add_help=False)
839
parser.add_argument("--check", action='store_true')
840
args, unknown_args = parser.parse_known_args()
841
run_tests = args.check
842
if run_tests:
843
# Remove --check argument from sys.argv
844
sys.argv[1:] = unknown_args
845
return run_tests
846
847
# Add all tests from doctest strings
848
def load_tests(loader, tests, none):
849
import doctest
850
tests.addTests(doctest.DocTestSuite())
851
return tests
280
keywords = defaultkeywords
281
282
print_clients(clients.values(), keywords)
283
else:
284
# Process each client in the list by all selected options
285
for client in clients:
286
if options.remove:
287
mandos_serv.RemoveClient(client.__dbus_object_path__)
288
if options.enable:
289
client.Enable(dbus_interface=client_interface)
290
if options.disable:
291
client.Disable(dbus_interface=client_interface)
292
if options.bump_timeout:
293
client.CheckedOK(dbus_interface=client_interface)
294
if options.start_checker:
295
client.StartChecker(dbus_interface=client_interface)
296
if options.stop_checker:
297
client.StopChecker(dbus_interface=client_interface)
298
if options.is_enabled:
299
sys.exit(0 if client.Get(client_interface,
300
"Enabled",
301
dbus_interface=
302
dbus.PROPERTIES_IFACE)
303
else 1)
304
if options.checker is not None:
305
client.Set(client_interface, "Checker",
306
options.checker,
307
dbus_interface=dbus.PROPERTIES_IFACE)
308
if options.host is not None:
309
client.Set(client_interface, "Host", options.host,
310
dbus_interface=dbus.PROPERTIES_IFACE)
311
if options.interval is not None:
312
client.Set(client_interface, "Interval",
313
timedelta_to_milliseconds
314
(string_to_delta(options.interval)),
315
dbus_interface=dbus.PROPERTIES_IFACE)
316
if options.approval_delay is not None:
317
client.Set(client_interface, "ApprovalDelay",
318
timedelta_to_milliseconds
319
(string_to_delta(options.
320
approval_delay)),
321
dbus_interface=dbus.PROPERTIES_IFACE)
322
if options.approval_duration is not None:
323
client.Set(client_interface, "ApprovalDuration",
324
timedelta_to_milliseconds
325
(string_to_delta(options.
326
approval_duration)),
327
dbus_interface=dbus.PROPERTIES_IFACE)
328
if options.timeout is not None:
329
client.Set(client_interface, "Timeout",
330
timedelta_to_milliseconds
331
(string_to_delta(options.timeout)),
332
dbus_interface=dbus.PROPERTIES_IFACE)
333
if options.extended_timeout is not None:
334
client.Set(client_interface, "ExtendedTimeout",
335
timedelta_to_milliseconds
336
(string_to_delta(options.extended_timeout)),
337
dbus_interface=dbus.PROPERTIES_IFACE)
338
if options.secret is not None:
339
client.Set(client_interface, "Secret",
340
dbus.ByteArray(open(options.secret,
341
"rb").read()),
342
dbus_interface=dbus.PROPERTIES_IFACE)
343
if options.approved_by_default is not None:
344
client.Set(client_interface, "ApprovedByDefault",
345
dbus.Boolean(options
346
.approved_by_default),
347
dbus_interface=dbus.PROPERTIES_IFACE)
348
if options.approve:
349
client.Approve(dbus.Boolean(True),
350
dbus_interface=client_interface)
351
elif options.deny:
352
client.Approve(dbus.Boolean(False),
353
dbus_interface=client_interface)
852
354
853
355
if __name__ == "__main__":
854
if should_only_run_tests():
855
# Call using ./tdd-python-script --check [--verbose]
856
unittest.main()
857
else:
858
main()
356
main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0