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

  • Committer: Teddy Hogeborn
  • Date: 2017-02-22 21:45:35 UTC
  • Revision ID: teddy@recompile.se-20170222214535-milf6w0b1krwpaex
http://bugs.debian.org/855589
Server bug fix: Use the mandos.conf "zeroconf" and "restore" options

Allow the "zeroconf" and "restore" options to actually work from the
mandos.conf file, in addition to command line options.

Closes: 855589
Reported-by: Pablo Abelenda <pabelenda@igalia.com>
Suggested-by: Pablo Abelenda <pabelenda@igalia.com>

Show diffs side-by-side

added added

removed removed

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