/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-monitor

  • Committer: Teddy Hogeborn
  • Date: 2019-11-03 19:17:57 UTC
  • mto: This revision was merged to the branch mainline in revision 396.
  • Revision ID: teddy@recompile.se-20191103191757-1hdpp0u5fxa8iumo
INSTALL: Add "-" argument to "su" invocations.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-monitor
1
 
#!/usr/bin/python
 
1
#!/usr/bin/python3 -bbI
2
2
# -*- mode: python; coding: utf-8 -*-
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
 
# Copyright © 2009-2018 Teddy Hogeborn
7
 
# Copyright © 2009-2018 Björn Påhlsson
 
6
# Copyright © 2009-2019 Teddy Hogeborn
 
7
# Copyright © 2009-2019 Björn Påhlsson
8
8
#
9
9
# This file is part of Mandos.
10
10
#
33
33
 
34
34
import sys
35
35
import os
36
 
 
 
36
import warnings
37
37
import datetime
 
38
import locale
 
39
import logging
38
40
 
39
41
import urwid.curses_display
40
42
import urwid
44
46
 
45
47
import dbus
46
48
 
47
 
import locale
48
 
 
49
 
import logging
50
 
 
51
49
if sys.version_info.major == 2:
52
50
    str = unicode
53
51
 
54
 
locale.setlocale(locale.LC_ALL, '')
55
 
 
56
 
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
 
52
log = logging.getLogger(os.path.basename(sys.argv[0]))
 
53
logging.basicConfig(level="NOTSET", # Show all messages
 
54
                    format="%(message)s") # Show basic log messages
 
55
 
 
56
logging.captureWarnings(True)   # Show warnings via the logging system
 
57
 
 
58
locale.setlocale(locale.LC_ALL, "")
 
59
 
 
60
logging.getLogger("dbus.proxies").setLevel(logging.CRITICAL)
57
61
 
58
62
# Some useful constants
59
 
domain = 'se.recompile'
60
 
server_interface = domain + '.Mandos'
61
 
client_interface = domain + '.Mandos.Client'
62
 
version = "1.7.20"
 
63
domain = "se.recompile"
 
64
server_interface = domain + ".Mandos"
 
65
client_interface = domain + ".Mandos.Client"
 
66
version = "1.8.9"
63
67
 
64
68
try:
65
69
    dbus.OBJECT_MANAGER_IFACE
122
126
    """
123
127
 
124
128
    def __init__(self, server_proxy_object=None, update_hook=None,
125
 
                 delete_hook=None, logger=None, **kwargs):
 
129
                 delete_hook=None, **kwargs):
126
130
        # Called on update
127
131
        self.update_hook = update_hook
128
132
        # Called on delete
129
133
        self.delete_hook = delete_hook
130
134
        # Mandos Server proxy object
131
135
        self.server_proxy_object = server_proxy_object
132
 
        # Logger
133
 
        self.logger = logger
134
136
 
135
137
        self._update_timer_callback_tag = None
136
138
 
163
165
                                         self.rejected,
164
166
                                         client_interface,
165
167
                                         byte_arrays=True))
166
 
        self.logger('Created client {}'
167
 
                    .format(self.properties["Name"]), level=0)
 
168
        log.debug("Created client %s", self.properties["Name"])
168
169
 
169
170
    def using_timer(self, flag):
170
171
        """Call this method with True or False when timer should be
172
173
        """
173
174
        if flag and self._update_timer_callback_tag is None:
174
175
            # Will update the shown timer value every second
175
 
            self._update_timer_callback_tag = (GLib.timeout_add
176
 
                                               (1000,
177
 
                                                self.update_timer))
 
176
            self._update_timer_callback_tag = (
 
177
                GLib.timeout_add(1000,
 
178
                                 glib_safely(self.update_timer)))
178
179
        elif not (flag or self._update_timer_callback_tag is None):
179
180
            GLib.source_remove(self._update_timer_callback_tag)
180
181
            self._update_timer_callback_tag = None
181
182
 
182
183
    def checker_completed(self, exitstatus, condition, command):
183
184
        if exitstatus == 0:
184
 
            self.logger('Checker for client {} (command "{}")'
185
 
                        ' succeeded'.format(self.properties["Name"],
186
 
                                            command), level=0)
 
185
            log.debug('Checker for client %s (command "%s")'
 
186
                      " succeeded", self.properties["Name"], command)
187
187
            self.update()
188
188
            return
189
189
        # Checker failed
190
190
        if os.WIFEXITED(condition):
191
 
            self.logger('Checker for client {} (command "{}") failed'
192
 
                        ' with exit code {}'
193
 
                        .format(self.properties["Name"], command,
194
 
                                os.WEXITSTATUS(condition)))
 
191
            log.info('Checker for client %s (command "%s") failed'
 
192
                     " with exit code %d", self.properties["Name"],
 
193
                     command, os.WEXITSTATUS(condition))
195
194
        elif os.WIFSIGNALED(condition):
196
 
            self.logger('Checker for client {} (command "{}") was'
197
 
                        ' killed by signal {}'
198
 
                        .format(self.properties["Name"], command,
199
 
                                os.WTERMSIG(condition)))
 
195
            log.info('Checker for client %s (command "%s") was'
 
196
                     " killed by signal %d", self.properties["Name"],
 
197
                     command, os.WTERMSIG(condition))
200
198
        self.update()
201
199
 
202
200
    def checker_started(self, command):
203
201
        """Server signals that a checker started."""
204
 
        self.logger('Client {} started checker "{}"'
205
 
                    .format(self.properties["Name"],
206
 
                            command), level=0)
 
202
        log.debug('Client %s started checker "%s"',
 
203
                  self.properties["Name"], command)
207
204
 
208
205
    def got_secret(self):
209
 
        self.logger('Client {} received its secret'
210
 
                    .format(self.properties["Name"]))
 
206
        log.info("Client %s received its secret",
 
207
                 self.properties["Name"])
211
208
 
212
209
    def need_approval(self, timeout, default):
213
210
        if not default:
214
 
            message = 'Client {} needs approval within {} seconds'
 
211
            message = "Client %s needs approval within %f seconds"
215
212
        else:
216
 
            message = 'Client {} will get its secret in {} seconds'
217
 
        self.logger(message.format(self.properties["Name"],
218
 
                                   timeout/1000))
 
213
            message = "Client %s will get its secret in %f seconds"
 
214
        log.info(message, self.properties["Name"], timeout/1000)
219
215
 
220
216
    def rejected(self, reason):
221
 
        self.logger('Client {} was rejected; reason: {}'
222
 
                    .format(self.properties["Name"], reason))
 
217
        log.info("Client %s was rejected; reason: %s",
 
218
                 self.properties["Name"], reason)
223
219
 
224
220
    def selectable(self):
225
221
        """Make this a "selectable" widget.
251
247
        # Rebuild focus and non-focus widgets using current properties
252
248
 
253
249
        # Base part of a client. Name!
254
 
        base = '{name}: '.format(name=self.properties["Name"])
 
250
        base = "{name}: ".format(name=self.properties["Name"])
255
251
        if not self.properties["Enabled"]:
256
252
            message = "DISABLED"
257
253
            self.using_timer(False)
279
275
                timer = datetime.timedelta(0)
280
276
            else:
281
277
                expires = (datetime.datetime.strptime
282
 
                           (expires, '%Y-%m-%dT%H:%M:%S.%f'))
 
278
                           (expires, "%Y-%m-%dT%H:%M:%S.%f"))
283
279
                timer = max(expires - datetime.datetime.utcnow(),
284
280
                            datetime.timedelta())
285
 
            message = ('A checker has failed! Time until client'
286
 
                       ' gets disabled: {}'
 
281
            message = ("A checker has failed! Time until client"
 
282
                       " gets disabled: {}"
287
283
                       .format(str(timer).rsplit(".", 1)[0]))
288
284
            self.using_timer(True)
289
285
        else:
387
383
            self.update()
388
384
 
389
385
 
 
386
def glib_safely(func, retval=True):
 
387
    def safe_func(*args, **kwargs):
 
388
        try:
 
389
            return func(*args, **kwargs)
 
390
        except Exception:
 
391
            log.exception("")
 
392
            return retval
 
393
    return safe_func
 
394
 
 
395
 
390
396
class ConstrainedListBox(urwid.ListBox):
391
397
    """Like a normal urwid.ListBox, but will consume all "up" or
392
398
    "down" key presses, thus not allowing any containing widgets to
404
410
    """This is the entire user interface - the whole screen
405
411
    with boxes, lists of client widgets, etc.
406
412
    """
407
 
    def __init__(self, max_log_length=1000, log_level=1):
 
413
    def __init__(self, max_log_length=1000):
408
414
        DBusGMainLoop(set_as_default=True)
409
415
 
410
416
        self.screen = urwid.curses_display.Screen()
444
450
        self.clients_dict = {}
445
451
 
446
452
        # We will add Text widgets to this list
447
 
        self.log = []
 
453
        self.log = urwid.SimpleListWalker([])
448
454
        self.max_log_length = max_log_length
449
455
 
450
 
        self.log_level = log_level
451
 
 
452
456
        # We keep a reference to the log widget so we can remove it
453
457
        # from the ListWalker without it getting destroyed
454
458
        self.logbox = ConstrainedListBox(self.log)
458
462
        self.log_visible = True
459
463
        self.log_wrap = "any"
460
464
 
 
465
        self.loghandler = UILogHandler(self)
 
466
 
461
467
        self.rebuild()
462
 
        self.log_message_raw(("bold",
463
 
                              "Mandos Monitor version " + version))
464
 
        self.log_message_raw(("bold",
465
 
                              "q: Quit  ?: Help"))
 
468
        self.add_log_line(("bold",
 
469
                           "Mandos Monitor version " + version))
 
470
        self.add_log_line(("bold", "q: Quit  ?: Help"))
466
471
 
467
 
        self.busname = domain + '.Mandos'
 
472
        self.busname = domain + ".Mandos"
468
473
        self.main_loop = GLib.MainLoop()
469
474
 
470
 
    def client_not_found(self, fingerprint, address):
471
 
        self.log_message("Client with address {} and fingerprint {}"
472
 
                         " could not be found"
473
 
                         .format(address, fingerprint))
 
475
    def client_not_found(self, key_id, address):
 
476
        log.info("Client with address %s and key ID %s could"
 
477
                 " not be found", address, key_id)
474
478
 
475
479
    def rebuild(self):
476
480
        """This rebuilds the User Interface.
487
491
            self.uilist.append(self.logbox)
488
492
        self.topwidget = urwid.Pile(self.uilist)
489
493
 
490
 
    def log_message(self, message, level=1):
491
 
        """Log message formatted with timestamp"""
492
 
        if level < self.log_level:
493
 
            return
494
 
        timestamp = datetime.datetime.now().isoformat()
495
 
        self.log_message_raw("{}: {}".format(timestamp, message),
496
 
                             level=level)
497
 
 
498
 
    def log_message_raw(self, markup, level=1):
499
 
        """Add a log message to the log buffer."""
500
 
        if level < self.log_level:
501
 
            return
 
494
    def add_log_line(self, markup):
502
495
        self.log.append(urwid.Text(markup, wrap=self.log_wrap))
503
496
        if self.max_log_length:
504
497
            if len(self.log) > self.max_log_length:
505
 
                del self.log[0:len(self.log)-self.max_log_length-1]
506
 
        self.logbox.set_focus(len(self.logbox.body.contents),
 
498
                del self.log[0:(len(self.log) - self.max_log_length)]
 
499
        self.logbox.set_focus(len(self.logbox.body.contents)-1,
507
500
                              coming_from="above")
508
501
        self.refresh()
509
502
 
511
504
        """Toggle visibility of the log buffer."""
512
505
        self.log_visible = not self.log_visible
513
506
        self.rebuild()
514
 
        self.log_message("Log visibility changed to: {}"
515
 
                         .format(self.log_visible), level=0)
 
507
        log.debug("Log visibility changed to: %s", self.log_visible)
516
508
 
517
509
    def change_log_display(self):
518
510
        """Change type of log display.
523
515
            self.log_wrap = "clip"
524
516
        for textwidget in self.log:
525
517
            textwidget.set_wrap_mode(self.log_wrap)
526
 
        self.log_message("Wrap mode: {}".format(self.log_wrap),
527
 
                         level=0)
 
518
        log.debug("Wrap mode: %s", self.log_wrap)
528
519
 
529
520
    def find_and_remove_client(self, path, interfaces):
530
521
        """Find a client by its object path and remove it.
538
529
            client = self.clients_dict[path]
539
530
        except KeyError:
540
531
            # not found?
541
 
            self.log_message("Unknown client {!r} removed"
542
 
                             .format(path))
 
532
            log.warning("Unknown client %s removed", path)
543
533
            return
544
534
        client.delete()
545
535
 
558
548
            proxy_object=client_proxy_object,
559
549
            update_hook=self.refresh,
560
550
            delete_hook=self.remove_client,
561
 
            logger=self.log_message,
562
551
            properties=dict(ifs_and_props[client_interface])),
563
552
                        path=path)
564
553
 
584
573
 
585
574
    def run(self):
586
575
        """Start the main loop and exit when it's done."""
 
576
        log.addHandler(self.loghandler)
 
577
        self.orig_log_propagate = log.propagate
 
578
        log.propagate = False
 
579
        self.orig_log_level = log.level
 
580
        log.setLevel("INFO")
587
581
        self.bus = dbus.SystemBus()
588
582
        mandos_dbus_objc = self.bus.get_object(
589
583
            self.busname, "/", follow_name_owner_changes=True)
593
587
            mandos_clients = (self.mandos_serv
594
588
                              .GetAllClientsWithProperties())
595
589
            if not mandos_clients:
596
 
                self.log_message_raw(("bold",
597
 
                                      "Note: Server has no clients."))
 
590
                log.warning("Note: Server has no clients.")
598
591
        except dbus.exceptions.DBusException:
599
 
            self.log_message_raw(("bold",
600
 
                                  "Note: No Mandos server running."))
 
592
            log.warning("Note: No Mandos server running.")
601
593
            mandos_clients = dbus.Dictionary()
602
594
 
603
595
        (self.mandos_serv
623
615
                proxy_object=client_proxy_object,
624
616
                properties=client,
625
617
                update_hook=self.refresh,
626
 
                delete_hook=self.remove_client,
627
 
                logger=self.log_message),
 
618
                delete_hook=self.remove_client),
628
619
                            path=path)
629
620
 
630
621
        self.refresh()
631
 
        self._input_callback_tag = (GLib.io_add_watch
632
 
                                    (sys.stdin.fileno(),
633
 
                                     GLib.IO_IN,
634
 
                                     self.process_input))
 
622
        self._input_callback_tag = (
 
623
            GLib.io_add_watch(
 
624
                GLib.IOChannel.unix_new(sys.stdin.fileno()),
 
625
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
626
                glib_safely(self.process_input)))
635
627
        self.main_loop.run()
636
628
        # Main loop has finished, we should close everything now
637
629
        GLib.source_remove(self._input_callback_tag)
638
 
        self.screen.stop()
 
630
        with warnings.catch_warnings():
 
631
            warnings.simplefilter("ignore", BytesWarning)
 
632
            self.screen.stop()
639
633
 
640
634
    def stop(self):
641
635
        self.main_loop.quit()
 
636
        log.removeHandler(self.loghandler)
 
637
        log.propagate = self.orig_log_propagate
642
638
 
643
639
    def process_input(self, source, condition):
644
640
        keys = self.screen.get_input()
677
673
                if not self.log_visible:
678
674
                    self.log_visible = True
679
675
                    self.rebuild()
680
 
                self.log_message_raw(("bold",
681
 
                                      "  ".
682
 
                                      join(("q: Quit",
683
 
                                            "?: Help",
684
 
                                            "l: Log window toggle",
685
 
                                            "TAB: Switch window",
686
 
                                            "w: Wrap (log lines)",
687
 
                                            "v: Toggle verbose log",
688
 
                                            ))))
689
 
                self.log_message_raw(("bold",
690
 
                                      "  "
691
 
                                      .join(("Clients:",
692
 
                                             "+: Enable",
693
 
                                             "-: Disable",
694
 
                                             "R: Remove",
695
 
                                             "s: Start new checker",
696
 
                                             "S: Stop checker",
697
 
                                             "C: Checker OK",
698
 
                                             "a: Approve",
699
 
                                             "d: Deny"))))
 
676
                self.add_log_line(("bold",
 
677
                                   "  ".join(("q: Quit",
 
678
                                              "?: Help",
 
679
                                              "l: Log window toggle",
 
680
                                              "TAB: Switch window",
 
681
                                              "w: Wrap (log lines)",
 
682
                                              "v: Toggle verbose log",
 
683
                                   ))))
 
684
                self.add_log_line(("bold",
 
685
                                   "  ".join(("Clients:",
 
686
                                              "+: Enable",
 
687
                                              "-: Disable",
 
688
                                              "R: Remove",
 
689
                                              "s: Start new checker",
 
690
                                              "S: Stop checker",
 
691
                                              "C: Checker OK",
 
692
                                              "a: Approve",
 
693
                                              "d: Deny",
 
694
                                   ))))
700
695
                self.refresh()
701
696
            elif key == "tab":
702
697
                if self.topwidget.get_focus() is self.logbox:
705
700
                    self.topwidget.set_focus(self.logbox)
706
701
                self.refresh()
707
702
            elif key == "v":
708
 
                if self.log_level == 0:
709
 
                    self.log_level = 1
710
 
                    self.log_message("Verbose mode: Off")
 
703
                if log.level < logging.INFO:
 
704
                    log.setLevel(logging.INFO)
 
705
                    log.info("Verbose mode: Off")
711
706
                else:
712
 
                    self.log_level = 0
713
 
                    self.log_message("Verbose mode: On")
 
707
                    log.setLevel(logging.NOTSET)
 
708
                    log.info("Verbose mode: On")
714
709
            # elif (key == "end" or key == "meta >" or key == "G"
715
710
            #       or key == ">"):
716
711
            #     pass            # xxx end-of-buffer
735
730
        return True
736
731
 
737
732
 
 
733
class UILogHandler(logging.Handler):
 
734
    def __init__(self, ui, *args, **kwargs):
 
735
        self.ui = ui
 
736
        super(UILogHandler, self).__init__(*args, **kwargs)
 
737
        self.setFormatter(
 
738
            logging.Formatter("%(asctime)s: %(message)s"))
 
739
    def emit(self, record):
 
740
        msg = self.format(record)
 
741
        if record.levelno > logging.INFO:
 
742
            msg = ("bold", msg)
 
743
        self.ui.add_log_line(msg)
 
744
 
 
745
 
738
746
ui = UserInterface()
739
747
try:
740
748
    ui.run()
741
749
except KeyboardInterrupt:
742
 
    ui.screen.stop()
743
 
except Exception as e:
744
 
    ui.log_message(str(e))
745
 
    ui.screen.stop()
 
750
    with warnings.catch_warnings():
 
751
        warnings.filterwarnings("ignore", "", BytesWarning)
 
752
        ui.screen.stop()
 
753
except Exception:
 
754
    with warnings.catch_warnings():
 
755
        warnings.filterwarnings("ignore", "", BytesWarning)
 
756
        ui.screen.stop()
746
757
    raise