/mandos/trunk

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

  • Committer: Teddy Hogeborn
  • Date: 2019-02-09 23:36:11 UTC
  • Revision ID: teddy@recompile.se-20190209233611-qurtq0kpsoct9uwf
Doc fix: Minor clarification

* mandos-clients.conf.xml (OPTIONS/checker): Be more clear that it's
  specifically an SSH key fingerprint that is being compared, and no
  other kind of fingerprint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
1
1
#!/usr/bin/python
2
2
# -*- mode: python; coding: utf-8 -*-
3
 
# 
 
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
 
# 
6
 
# Copyright © 2008-2016 Teddy Hogeborn
7
 
# Copyright © 2008-2016 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
 
5
#
 
6
# Copyright © 2008-2018 Teddy Hogeborn
 
7
# Copyright © 2008-2018 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
11
13
# the Free Software Foundation, either version 3 of the License, or
12
14
# (at your option) any later version.
13
15
#
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
#     Mandos is distributed in the hope that it will be useful, but
 
17
#     WITHOUT ANY WARRANTY; without even the implied warranty of
16
18
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
19
#     GNU General Public License for more details.
18
 
# 
 
20
#
19
21
# 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
 
# 
 
22
# along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
23
#
23
24
# Contact the authors at <mandos@recompile.se>.
24
 
# 
 
25
#
25
26
 
26
27
from __future__ import (division, absolute_import, print_function,
27
28
                        unicode_literals)
38
39
import re
39
40
import os
40
41
import collections
41
 
import doctest
42
42
import json
43
43
 
44
44
import dbus
58
58
    "Interval": "Interval",
59
59
    "Host": "Host",
60
60
    "Fingerprint": "Fingerprint",
 
61
    "KeyID": "Key ID",
61
62
    "CheckerRunning": "Check Is Running",
62
63
    "LastEnabled": "Last Enabled",
63
64
    "ApprovalPending": "Approval Is Pending",
75
76
server_path = "/"
76
77
server_interface = domain + ".Mandos"
77
78
client_interface = domain + ".Mandos.Client"
78
 
version = "1.7.10"
 
79
version = "1.7.20"
79
80
 
80
81
 
81
82
try:
83
84
except AttributeError:
84
85
    dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
85
86
 
 
87
 
86
88
def milliseconds_to_string(ms):
87
89
    td = datetime.timedelta(0, 0, 0, ms)
88
 
    return ("{days}{hours:02}:{minutes:02}:{seconds:02}".format(
89
 
        days = "{}T".format(td.days) if td.days else "",
90
 
        hours = td.seconds // 3600,
91
 
        minutes = (td.seconds % 3600) // 60,
92
 
        seconds = td.seconds % 60))
 
90
    return ("{days}{hours:02}:{minutes:02}:{seconds:02}"
 
91
            .format(days="{}T".format(td.days) if td.days else "",
 
92
                    hours=td.seconds // 3600,
 
93
                    minutes=(td.seconds % 3600) // 60,
 
94
                    seconds=td.seconds % 60))
93
95
 
94
96
 
95
97
def rfc3339_duration_to_delta(duration):
96
98
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
97
 
    
 
99
 
98
100
    >>> rfc3339_duration_to_delta("P7D")
99
101
    datetime.timedelta(7)
100
102
    >>> rfc3339_duration_to_delta("PT60S")
110
112
    >>> rfc3339_duration_to_delta("P1DT3M20S")
111
113
    datetime.timedelta(1, 200)
112
114
    """
113
 
    
 
115
 
114
116
    # Parsing an RFC 3339 duration with regular expressions is not
115
117
    # possible - there would have to be multiple places for the same
116
118
    # values, like seconds.  The current code, while more esoteric, is
117
119
    # cleaner without depending on a parsing library.  If Python had a
118
120
    # built-in library for parsing we would use it, but we'd like to
119
121
    # avoid excessive use of external libraries.
120
 
    
 
122
 
121
123
    # New type for defining tokens, syntax, and semantics all-in-one
122
124
    Token = collections.namedtuple("Token", (
123
125
        "regexp",  # To match token; if "value" is not None, must have
156
158
                           frozenset((token_year, token_month,
157
159
                                      token_day, token_time,
158
160
                                      token_week)))
159
 
    # Define starting values
160
 
    value = datetime.timedelta() # Value so far
 
161
    # Define starting values:
 
162
    # Value so far
 
163
    value = datetime.timedelta()
161
164
    found_token = None
162
 
    followers = frozenset((token_duration, )) # Following valid tokens
163
 
    s = duration                # String left to parse
 
165
    # Following valid tokens
 
166
    followers = frozenset((token_duration, ))
 
167
    # String left to parse
 
168
    s = duration
164
169
    # Loop until end token is found
165
170
    while found_token is not token_end:
166
171
        # Search for any currently valid tokens
190
195
 
191
196
def string_to_delta(interval):
192
197
    """Parse a string and return a datetime.timedelta
193
 
    
 
198
 
194
199
    >>> string_to_delta('7d')
195
200
    datetime.timedelta(7)
196
201
    >>> string_to_delta('60s')
204
209
    >>> string_to_delta('5m 30s')
205
210
    datetime.timedelta(0, 330)
206
211
    """
207
 
    
 
212
 
208
213
    try:
209
214
        return rfc3339_duration_to_delta(interval)
210
215
    except ValueError:
211
216
        pass
212
 
    
 
217
 
213
218
    value = datetime.timedelta(0)
214
219
    regexp = re.compile(r"(\d+)([dsmhw]?)")
215
 
    
 
220
 
216
221
    for num, suffix in regexp.findall(interval):
217
222
        if suffix == "d":
218
223
            value += datetime.timedelta(int(num))
237
242
                       "ApprovalDuration", "ExtendedTimeout"):
238
243
            return milliseconds_to_string(value)
239
244
        return str(value)
240
 
    
 
245
 
241
246
    # Create format string to print table rows
242
247
    format_string = " ".join("{{{key}:{width}}}".format(
243
 
        width = max(len(tablewords[key]),
244
 
                    max(len(valuetostring(client[key], key))
245
 
                        for client in clients)),
246
 
        key = key)
 
248
        width=max(len(tablewords[key]),
 
249
                  max(len(valuetostring(client[key], key))
 
250
                      for client in clients)),
 
251
        key=key)
247
252
                             for key in keywords)
248
253
    # Print header line
249
254
    print(format_string.format(**tablewords))
250
255
    for client in clients:
251
 
        print(format_string.format(**{
252
 
            key: valuetostring(client[key], key)
253
 
            for key in keywords }))
 
256
        print(format_string
 
257
              .format(**{key: valuetostring(client[key], key)
 
258
                         for key in keywords}))
254
259
 
255
260
 
256
261
def has_actions(options):
277
282
def main():
278
283
    parser = argparse.ArgumentParser()
279
284
    parser.add_argument("--version", action="version",
280
 
                        version = "%(prog)s {}".format(version),
 
285
                        version="%(prog)s {}".format(version),
281
286
                        help="show version number and exit")
282
287
    parser.add_argument("-a", "--all", action="store_true",
283
288
                        help="Select all clients")
329
334
                        help="Run self-test")
330
335
    parser.add_argument("client", nargs="*", help="Client name")
331
336
    options = parser.parse_args()
332
 
    
 
337
 
333
338
    if has_actions(options) and not (options.client or options.all):
334
339
        parser.error("Options require clients names or --all.")
335
340
    if options.verbose and has_actions(options):
336
341
        parser.error("--verbose can only be used alone.")
337
 
    if options.dump_json and (options.verbose or has_actions(options)):
 
342
    if options.dump_json and (options.verbose
 
343
                              or has_actions(options)):
338
344
        parser.error("--dump-json can only be used alone.")
339
345
    if options.all and not has_actions(options):
340
346
        parser.error("--all requires an action.")
341
 
    
 
347
 
342
348
    if options.check:
 
349
        import doctest
343
350
        fail_count, test_count = doctest.testmod()
344
351
        sys.exit(os.EX_OK if fail_count == 0 else 1)
345
 
    
 
352
 
346
353
    try:
347
354
        bus = dbus.SystemBus()
348
355
        mandos_dbus_objc = bus.get_object(busname, server_path)
349
356
    except dbus.exceptions.DBusException:
350
357
        print("Could not connect to Mandos server", file=sys.stderr)
351
358
        sys.exit(1)
352
 
    
 
359
 
353
360
    mandos_serv = dbus.Interface(mandos_dbus_objc,
354
 
                                 dbus_interface = server_interface)
 
361
                                 dbus_interface=server_interface)
355
362
    mandos_serv_object_manager = dbus.Interface(
356
 
        mandos_dbus_objc, dbus_interface = dbus.OBJECT_MANAGER_IFACE)
357
 
    
358
 
    #block stderr since dbus library prints to stderr
 
363
        mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)
 
364
 
 
365
    # block stderr since dbus library prints to stderr
359
366
    null = os.open(os.path.devnull, os.O_RDWR)
360
367
    stderrcopy = os.dup(sys.stderr.fileno())
361
368
    os.dup2(null, sys.stderr.fileno())
362
369
    os.close(null)
363
370
    try:
364
371
        try:
365
 
            mandos_clients = { path: ifs_and_props[client_interface]
366
 
                               for path, ifs_and_props in
367
 
                               mandos_serv_object_manager
368
 
                               .GetManagedObjects().items()
369
 
                               if client_interface in ifs_and_props }
 
372
            mandos_clients = {path: ifs_and_props[client_interface]
 
373
                              for path, ifs_and_props in
 
374
                              mandos_serv_object_manager
 
375
                              .GetManagedObjects().items()
 
376
                              if client_interface in ifs_and_props}
370
377
        finally:
371
 
            #restore stderr
 
378
            # restore stderr
372
379
            os.dup2(stderrcopy, sys.stderr.fileno())
373
380
            os.close(stderrcopy)
374
381
    except dbus.exceptions.DBusException as e:
375
 
        print("Access denied: Accessing mandos server through D-Bus: {}"
376
 
              .format(e), file=sys.stderr)
 
382
        print("Access denied: "
 
383
              "Accessing mandos server through D-Bus: {}".format(e),
 
384
              file=sys.stderr)
377
385
        sys.exit(1)
378
 
    
 
386
 
379
387
    # Compile dict of (clients: properties) to process
380
 
    clients={}
381
 
    
 
388
    clients = {}
 
389
 
382
390
    if options.all or not options.client:
383
 
        clients = { bus.get_object(busname, path): properties
384
 
                    for path, properties in mandos_clients.items() }
 
391
        clients = {bus.get_object(busname, path): properties
 
392
                   for path, properties in mandos_clients.items()}
385
393
    else:
386
394
        for name in options.client:
387
395
            for path, client in mandos_clients.items():
393
401
                print("Client not found on server: {!r}"
394
402
                      .format(name), file=sys.stderr)
395
403
                sys.exit(1)
396
 
    
 
404
 
397
405
    if not has_actions(options) and clients:
398
406
        if options.verbose or options.dump_json:
399
407
            keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",
400
 
                        "Created", "Interval", "Host", "Fingerprint",
401
 
                        "CheckerRunning", "LastEnabled",
402
 
                        "ApprovalPending", "ApprovedByDefault",
403
 
                        "LastApprovalRequest", "ApprovalDelay",
404
 
                        "ApprovalDuration", "Checker",
405
 
                        "ExtendedTimeout", "Expires",
 
408
                        "Created", "Interval", "Host", "KeyID",
 
409
                        "Fingerprint", "CheckerRunning",
 
410
                        "LastEnabled", "ApprovalPending",
 
411
                        "ApprovedByDefault", "LastApprovalRequest",
 
412
                        "ApprovalDelay", "ApprovalDuration",
 
413
                        "Checker", "ExtendedTimeout", "Expires",
406
414
                        "LastCheckerStatus")
407
415
        else:
408
416
            keywords = defaultkeywords
409
 
        
 
417
 
410
418
        if options.dump_json:
411
419
            json.dump({client["Name"]: {key:
412
420
                                        bool(client[key])
413
421
                                        if isinstance(client[key],
414
422
                                                      dbus.Boolean)
415
423
                                        else client[key]
416
 
                                        for key in keywords }
417
 
                       for client in clients.values() },
418
 
                      fp = sys.stdout, indent = 4,
419
 
                      separators = (',', ': '))
 
424
                                        for key in keywords}
 
425
                       for client in clients.values()},
 
426
                      fp=sys.stdout, indent=4,
 
427
                      separators=(',', ': '))
420
428
            print()
421
429
        else:
422
430
            print_clients(clients.values(), keywords)
423
431
    else:
424
432
        # Process each client in the list by all selected options
425
433
        for client in clients:
426
 
            
 
434
 
427
435
            def set_client_prop(prop, value):
428
436
                """Set a Client D-Bus property"""
429
437
                client.Set(client_interface, prop, value,
430
438
                           dbus_interface=dbus.PROPERTIES_IFACE)
431
 
            
 
439
 
432
440
            def set_client_prop_ms(prop, value):
433
441
                """Set a Client D-Bus property, converted
434
442
                from a string to milliseconds."""
435
443
                set_client_prop(prop,
436
444
                                string_to_delta(value).total_seconds()
437
445
                                * 1000)
438
 
            
 
446
 
439
447
            if options.remove:
440
448
                mandos_serv.RemoveClient(client.__dbus_object_path__)
441
449
            if options.enable:
449
457
            if options.stop_checker:
450
458
                set_client_prop("CheckerRunning", dbus.Boolean(False))
451
459
            if options.is_enabled:
452
 
                sys.exit(0 if client.Get(client_interface,
453
 
                                         "Enabled",
454
 
                                         dbus_interface=
455
 
                                         dbus.PROPERTIES_IFACE)
456
 
                         else 1)
 
460
                if client.Get(client_interface, "Enabled",
 
461
                              dbus_interface=dbus.PROPERTIES_IFACE):
 
462
                    sys.exit(0)
 
463
                else:
 
464
                    sys.exit(1)
457
465
            if options.checker is not None:
458
466
                set_client_prop("Checker", options.checker)
459
467
            if options.host is not None: