/mandos/release

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

  • Committer: Teddy Hogeborn
  • Date: 2015-08-10 08:25:01 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150810082501-rb7w2dre1flqiqe2
Refactor D-Bus annotation class out from D-Bus properties class.

* mandos (DBusObjectWithAnnotations): New; factored out D-Bus
                                      annotations code from
                                      DBusObjectWithProperties class.
  (DBusObjectWithProperties): Inherit from DBusObjectWithAnnotations.
  (main/MandosDBusService): - '' -
  (main/MandosDBusService._foo): Removed interface annotation for
                                 "o.f.D.Property.EmitsChangedSignal";
                                 this object has no properties.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
 
1
#!/usr/bin/python
 
2
# -*- mode: python; coding: utf-8 -*-
 
3
# 
 
4
# Mandos Monitor - Control and monitor the Mandos server
 
5
# 
 
6
# Copyright © 2008-2015 Teddy Hogeborn
 
7
# Copyright © 2008-2015 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
 
11
# the Free Software Foundation, either version 3 of the License, or
 
12
# (at your option) any later version.
 
13
#
 
14
#     This program is distributed in the hope that it will be useful,
 
15
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
#     GNU General Public License for more details.
 
18
# 
 
19
# You should have received a copy of the GNU General Public License
 
20
# along with this program.  If not, see
 
21
# <http://www.gnu.org/licenses/>.
 
22
# 
 
23
# Contact the authors at <mandos@recompile.se>.
 
24
# 
 
25
 
 
26
from __future__ import (division, absolute_import, print_function,
 
27
                        unicode_literals)
 
28
 
 
29
try:
 
30
    from future_builtins import *
 
31
except ImportError:
 
32
    pass
 
33
 
 
34
import sys
 
35
import argparse
 
36
import locale
 
37
import datetime
 
38
import re
 
39
import os
 
40
import collections
 
41
import doctest
 
42
 
 
43
import dbus
 
44
 
 
45
if sys.version_info.major == 2:
 
46
    str = unicode
 
47
 
 
48
locale.setlocale(locale.LC_ALL, "")
 
49
 
 
50
tablewords = {
 
51
    "Name": "Name",
 
52
    "Enabled": "Enabled",
 
53
    "Timeout": "Timeout",
 
54
    "LastCheckedOK": "Last Successful Check",
 
55
    "LastApprovalRequest": "Last Approval Request",
 
56
    "Created": "Created",
 
57
    "Interval": "Interval",
 
58
    "Host": "Host",
 
59
    "Fingerprint": "Fingerprint",
 
60
    "CheckerRunning": "Check Is Running",
 
61
    "LastEnabled": "Last Enabled",
 
62
    "ApprovalPending": "Approval Is Pending",
 
63
    "ApprovedByDefault": "Approved By Default",
 
64
    "ApprovalDelay": "Approval Delay",
 
65
    "ApprovalDuration": "Approval Duration",
 
66
    "Checker": "Checker",
 
67
    "ExtendedTimeout": "Extended Timeout"
 
68
}
 
69
defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")
 
70
domain = "se.recompile"
 
71
busname = domain + ".Mandos"
 
72
server_path = "/"
 
73
server_interface = domain + ".Mandos"
 
74
client_interface = domain + ".Mandos.Client"
 
75
version = "1.6.9"
 
76
 
 
77
 
 
78
def milliseconds_to_string(ms):
 
79
    td = datetime.timedelta(0, 0, 0, ms)
 
80
    return ("{days}{hours:02}:{minutes:02}:{seconds:02}".format(
 
81
        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("PT24H")
 
97
    datetime.timedelta(1)
 
98
    >>> rfc3339_duration_to_delta("P1W")
 
99
    datetime.timedelta(7)
 
100
    >>> rfc3339_duration_to_delta("PT5M30S")
 
101
    datetime.timedelta(0, 330)
 
102
    >>> rfc3339_duration_to_delta("P1DT3M20S")
 
103
    datetime.timedelta(1, 200)
 
104
    """
 
105
    
 
106
    # Parsing an RFC 3339 duration with regular expressions is not
 
107
    # possible - there would have to be multiple places for the same
 
108
    # values, like seconds.  The current code, while more esoteric, is
 
109
    # cleaner without depending on a parsing library.  If Python had a
 
110
    # built-in library for parsing we would use it, but we'd like to
 
111
    # avoid excessive use of external libraries.
 
112
    
 
113
    # New type for defining tokens, syntax, and semantics all-in-one
 
114
    Token = collections.namedtuple("Token", (
 
115
        "regexp",  # To match token; if "value" is not None, must have
 
116
                   # a "group" containing digits
 
117
        "value",   # datetime.timedelta or None
 
118
        "followers"))           # Tokens valid after this token
 
119
    # RFC 3339 "duration" tokens, syntax, and semantics; taken from
 
120
    # the "duration" ABNF definition in RFC 3339, Appendix A.
 
121
    token_end = Token(re.compile(r"$"), None, frozenset())
 
122
    token_second = Token(re.compile(r"(\d+)S"),
 
123
                         datetime.timedelta(seconds=1),
 
124
                         frozenset((token_end, )))
 
125
    token_minute = Token(re.compile(r"(\d+)M"),
 
126
                         datetime.timedelta(minutes=1),
 
127
                         frozenset((token_second, token_end)))
 
128
    token_hour = Token(re.compile(r"(\d+)H"),
 
129
                       datetime.timedelta(hours=1),
 
130
                       frozenset((token_minute, token_end)))
 
131
    token_time = Token(re.compile(r"T"),
 
132
                       None,
 
133
                       frozenset((token_hour, token_minute,
 
134
                                  token_second)))
 
135
    token_day = Token(re.compile(r"(\d+)D"),
 
136
                      datetime.timedelta(days=1),
 
137
                      frozenset((token_time, token_end)))
 
138
    token_month = Token(re.compile(r"(\d+)M"),
 
139
                        datetime.timedelta(weeks=4),
 
140
                        frozenset((token_day, token_end)))
 
141
    token_year = Token(re.compile(r"(\d+)Y"),
 
142
                       datetime.timedelta(weeks=52),
 
143
                       frozenset((token_month, token_end)))
 
144
    token_week = Token(re.compile(r"(\d+)W"),
 
145
                       datetime.timedelta(weeks=1),
 
146
                       frozenset((token_end, )))
 
147
    token_duration = Token(re.compile(r"P"), None,
 
148
                           frozenset((token_year, token_month,
 
149
                                      token_day, token_time,
 
150
                                      token_week)))
 
151
    # Define starting values
 
152
    value = datetime.timedelta() # Value so far
 
153
    found_token = None
 
154
    followers = frozenset((token_duration, )) # Following valid tokens
 
155
    s = duration                # String left to parse
 
156
    # Loop until end token is found
 
157
    while found_token is not token_end:
 
158
        # Search for any currently valid tokens
 
159
        for token in followers:
 
160
            match = token.regexp.match(s)
 
161
            if match is not None:
 
162
                # Token found
 
163
                if token.value is not None:
 
164
                    # Value found, parse digits
 
165
                    factor = int(match.group(1), 10)
 
166
                    # Add to value so far
 
167
                    value += factor * token.value
 
168
                # Strip token from string
 
169
                s = token.regexp.sub("", s, 1)
 
170
                # Go to found token
 
171
                found_token = token
 
172
                # Set valid next tokens
 
173
                followers = found_token.followers
 
174
                break
 
175
        else:
 
176
            # No currently valid tokens were found
 
177
            raise ValueError("Invalid RFC 3339 duration: {!r}"
 
178
                             .format(duration))
 
179
    # End token found
 
180
    return value
 
181
 
 
182
 
 
183
def string_to_delta(interval):
 
184
    """Parse a string and return a datetime.timedelta
 
185
    
 
186
    >>> string_to_delta('7d')
 
187
    datetime.timedelta(7)
 
188
    >>> string_to_delta('60s')
 
189
    datetime.timedelta(0, 60)
 
190
    >>> string_to_delta('60m')
 
191
    datetime.timedelta(0, 3600)
 
192
    >>> string_to_delta('24h')
 
193
    datetime.timedelta(1)
 
194
    >>> string_to_delta('1w')
 
195
    datetime.timedelta(7)
 
196
    >>> string_to_delta('5m 30s')
 
197
    datetime.timedelta(0, 330)
 
198
    """
 
199
    
 
200
    try:
 
201
        return rfc3339_duration_to_delta(interval)
 
202
    except ValueError:
 
203
        pass
 
204
    
 
205
    value = datetime.timedelta(0)
 
206
    regexp = re.compile(r"(\d+)([dsmhw]?)")
 
207
    
 
208
    for num, suffix in regexp.findall(interval):
 
209
        if suffix == "d":
 
210
            value += datetime.timedelta(int(num))
 
211
        elif suffix == "s":
 
212
            value += datetime.timedelta(0, int(num))
 
213
        elif suffix == "m":
 
214
            value += datetime.timedelta(0, 0, 0, 0, int(num))
 
215
        elif suffix == "h":
 
216
            value += datetime.timedelta(0, 0, 0, 0, 0, int(num))
 
217
        elif suffix == "w":
 
218
            value += datetime.timedelta(0, 0, 0, 0, 0, 0, int(num))
 
219
        elif suffix == "":
 
220
            value += datetime.timedelta(0, 0, 0, int(num))
 
221
    return value
 
222
 
 
223
 
 
224
def print_clients(clients, keywords):
 
225
    def valuetostring(value, keyword):
 
226
        if type(value) is dbus.Boolean:
 
227
            return "Yes" if value else "No"
 
228
        if keyword in ("Timeout", "Interval", "ApprovalDelay",
 
229
                       "ApprovalDuration", "ExtendedTimeout"):
 
230
            return milliseconds_to_string(value)
 
231
        return str(value)
 
232
    
 
233
    # Create format string to print table rows
 
234
    format_string = " ".join("{{{key}:{width}}}".format(
 
235
        width = max(len(tablewords[key]),
 
236
                    max(len(valuetostring(client[key], key))
 
237
                        for client in clients)),
 
238
        key = key)
 
239
                             for key in keywords)
 
240
    # Print header line
 
241
    print(format_string.format(**tablewords))
 
242
    for client in clients:
 
243
        print(format_string.format(**{
 
244
            key: valuetostring(client[key], key)
 
245
            for key in keywords }))
 
246
 
 
247
 
 
248
def has_actions(options):
 
249
    return any((options.enable,
 
250
                options.disable,
 
251
                options.bump_timeout,
 
252
                options.start_checker,
 
253
                options.stop_checker,
 
254
                options.is_enabled,
 
255
                options.remove,
 
256
                options.checker is not None,
 
257
                options.timeout is not None,
 
258
                options.extended_timeout is not None,
 
259
                options.interval is not None,
 
260
                options.approved_by_default is not None,
 
261
                options.approval_delay is not None,
 
262
                options.approval_duration is not None,
 
263
                options.host is not None,
 
264
                options.secret is not None,
 
265
                options.approve,
 
266
                options.deny))
 
267
 
 
268
 
 
269
def main():
 
270
    parser = argparse.ArgumentParser()
 
271
    parser.add_argument("--version", action="version",
 
272
                        version = "%(prog)s {}".format(version),
 
273
                        help="show version number and exit")
 
274
    parser.add_argument("-a", "--all", action="store_true",
 
275
                        help="Select all clients")
 
276
    parser.add_argument("-v", "--verbose", action="store_true",
 
277
                        help="Print all fields")
 
278
    parser.add_argument("-e", "--enable", action="store_true",
 
279
                        help="Enable client")
 
280
    parser.add_argument("-d", "--disable", action="store_true",
 
281
                        help="disable client")
 
282
    parser.add_argument("-b", "--bump-timeout", action="store_true",
 
283
                        help="Bump timeout for client")
 
284
    parser.add_argument("--start-checker", action="store_true",
 
285
                        help="Start checker for client")
 
286
    parser.add_argument("--stop-checker", action="store_true",
 
287
                        help="Stop checker for client")
 
288
    parser.add_argument("-V", "--is-enabled", action="store_true",
 
289
                        help="Check if client is enabled")
 
290
    parser.add_argument("-r", "--remove", action="store_true",
 
291
                        help="Remove client")
 
292
    parser.add_argument("-c", "--checker",
 
293
                        help="Set checker command for client")
 
294
    parser.add_argument("-t", "--timeout",
 
295
                        help="Set timeout for client")
 
296
    parser.add_argument("--extended-timeout",
 
297
                        help="Set extended timeout for client")
 
298
    parser.add_argument("-i", "--interval",
 
299
                        help="Set checker interval for client")
 
300
    parser.add_argument("--approve-by-default", action="store_true",
 
301
                        default=None, dest="approved_by_default",
 
302
                        help="Set client to be approved by default")
 
303
    parser.add_argument("--deny-by-default", action="store_false",
 
304
                        dest="approved_by_default",
 
305
                        help="Set client to be denied by default")
 
306
    parser.add_argument("--approval-delay",
 
307
                        help="Set delay before client approve/deny")
 
308
    parser.add_argument("--approval-duration",
 
309
                        help="Set duration of one client approval")
 
310
    parser.add_argument("-H", "--host", help="Set host for client")
 
311
    parser.add_argument("-s", "--secret",
 
312
                        type=argparse.FileType(mode="rb"),
 
313
                        help="Set password blob (file) for client")
 
314
    parser.add_argument("-A", "--approve", action="store_true",
 
315
                        help="Approve any current client request")
 
316
    parser.add_argument("-D", "--deny", action="store_true",
 
317
                        help="Deny any current client request")
 
318
    parser.add_argument("--check", action="store_true",
 
319
                        help="Run self-test")
 
320
    parser.add_argument("client", nargs="*", help="Client name")
 
321
    options = parser.parse_args()
 
322
    
 
323
    if has_actions(options) and not (options.client or options.all):
 
324
        parser.error("Options require clients names or --all.")
 
325
    if options.verbose and has_actions(options):
 
326
        parser.error("--verbose can only be used alone or with"
 
327
                     " --all.")
 
328
    if options.all and not has_actions(options):
 
329
        parser.error("--all requires an action.")
 
330
 
 
331
    if options.check:
 
332
        fail_count, test_count = doctest.testmod()
 
333
        sys.exit(os.EX_OK if fail_count == 0 else 1)
 
334
    
 
335
    try:
 
336
        bus = dbus.SystemBus()
 
337
        mandos_dbus_objc = bus.get_object(busname, server_path)
 
338
    except dbus.exceptions.DBusException:
 
339
        print("Could not connect to Mandos server", file=sys.stderr)
 
340
        sys.exit(1)
 
341
    
 
342
    mandos_serv = dbus.Interface(mandos_dbus_objc,
 
343
                                 dbus_interface = server_interface)
 
344
    
 
345
    #block stderr since dbus library prints to stderr
 
346
    null = os.open(os.path.devnull, os.O_RDWR)
 
347
    stderrcopy = os.dup(sys.stderr.fileno())
 
348
    os.dup2(null, sys.stderr.fileno())
 
349
    os.close(null)
 
350
    try:
 
351
        try:
 
352
            mandos_clients = mandos_serv.GetAllClientsWithProperties()
 
353
        finally:
 
354
            #restore stderr
 
355
            os.dup2(stderrcopy, sys.stderr.fileno())
 
356
            os.close(stderrcopy)
 
357
    except dbus.exceptions.DBusException:
 
358
        print("Access denied: Accessing mandos server through dbus.",
 
359
              file=sys.stderr)
 
360
        sys.exit(1)
 
361
    
 
362
    # Compile dict of (clients: properties) to process
 
363
    clients={}
 
364
    
 
365
    if options.all or not options.client:
 
366
        clients = { bus.get_object(busname, path): properties
 
367
                    for path, properties in mandos_clients.items() }
 
368
    else:
 
369
        for name in options.client:
 
370
            for path, client in mandos_clients.items():
 
371
                if client["Name"] == name:
 
372
                    client_objc = bus.get_object(busname, path)
 
373
                    clients[client_objc] = client
 
374
                    break
 
375
            else:
 
376
                print("Client not found on server: {!r}"
 
377
                      .format(name), file=sys.stderr)
 
378
                sys.exit(1)
 
379
    
 
380
    if not has_actions(options) and clients:
 
381
        if options.verbose:
 
382
            keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
 
383
                        "Created", "Interval", "Host", "Fingerprint",
 
384
                        "CheckerRunning", "LastEnabled",
 
385
                        "ApprovalPending", "ApprovedByDefault",
 
386
                        "LastApprovalRequest", "ApprovalDelay",
 
387
                        "ApprovalDuration", "Checker",
 
388
                        "ExtendedTimeout")
 
389
        else:
 
390
            keywords = defaultkeywords
 
391
        
 
392
        print_clients(clients.values(), keywords)
 
393
    else:
 
394
        # Process each client in the list by all selected options
 
395
        for client in clients:
 
396
            
 
397
            def set_client_prop(prop, value):
 
398
                """Set a Client D-Bus property"""
 
399
                client.Set(client_interface, prop, value,
 
400
                           dbus_interface=dbus.PROPERTIES_IFACE)
 
401
            
 
402
            def set_client_prop_ms(prop, value):
 
403
                """Set a Client D-Bus property, converted
 
404
                from a string to milliseconds."""
 
405
                set_client_prop(prop,
 
406
                                string_to_delta(value).total_seconds()
 
407
                                * 1000)
 
408
            
 
409
            if options.remove:
 
410
                mandos_serv.RemoveClient(client.__dbus_object_path__)
 
411
            if options.enable:
 
412
                set_client_prop("Enabled", dbus.Boolean(True))
 
413
            if options.disable:
 
414
                set_client_prop("Enabled", dbus.Boolean(False))
 
415
            if options.bump_timeout:
 
416
                set_client_prop("LastCheckedOK", "")
 
417
            if options.start_checker:
 
418
                set_client_prop("CheckerRunning", dbus.Boolean(True))
 
419
            if options.stop_checker:
 
420
                set_client_prop("CheckerRunning", dbus.Boolean(False))
 
421
            if options.is_enabled:
 
422
                sys.exit(0 if client.Get(client_interface,
 
423
                                         "Enabled",
 
424
                                         dbus_interface=
 
425
                                         dbus.PROPERTIES_IFACE)
 
426
                         else 1)
 
427
            if options.checker is not None:
 
428
                set_client_prop("Checker", options.checker)
 
429
            if options.host is not None:
 
430
                set_client_prop("Host", options.host)
 
431
            if options.interval is not None:
 
432
                set_client_prop_ms("Interval", options.interval)
 
433
            if options.approval_delay is not None:
 
434
                set_client_prop_ms("ApprovalDelay",
 
435
                                   options.approval_delay)
 
436
            if options.approval_duration is not None:
 
437
                set_client_prop_ms("ApprovalDuration",
 
438
                                   options.approval_duration)
 
439
            if options.timeout is not None:
 
440
                set_client_prop_ms("Timeout", options.timeout)
 
441
            if options.extended_timeout is not None:
 
442
                set_client_prop_ms("ExtendedTimeout",
 
443
                                   options.extended_timeout)
 
444
            if options.secret is not None:
 
445
                set_client_prop("Secret",
 
446
                                dbus.ByteArray(options.secret.read()))
 
447
            if options.approved_by_default is not None:
 
448
                set_client_prop("ApprovedByDefault",
 
449
                                dbus.Boolean(options
 
450
                                             .approved_by_default))
 
451
            if options.approve:
 
452
                client.Approve(dbus.Boolean(True),
 
453
                               dbus_interface=client_interface)
 
454
            elif options.deny:
 
455
                client.Approve(dbus.Boolean(False),
 
456
                               dbus_interface=client_interface)
 
457
 
 
458
 
 
459
if __name__ == "__main__":
 
460
    main()