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