2
2
# -*- mode: python; coding: utf-8 -*-
4
4
# Mandos Monitor - Control and monitor the Mandos server
6
# Copyright © 2009-2014 Teddy Hogeborn
7
# Copyright © 2009-2014 Björn Påhlsson
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
6
# Copyright © 2009-2019 Teddy Hogeborn
7
# Copyright © 2009-2019 Björn Påhlsson
9
# This file is part of Mandos.
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.
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.
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
# along with Mandos. If not, see <http://www.gnu.org/licenses/>.
23
24
# Contact the authors at <mandos@recompile.se>.
26
27
from __future__ import (division, absolute_import, print_function,
41
42
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GObject as gobject
43
from gi.repository import GLib
51
if sys.version_info[0] == 2:
51
if sys.version_info.major == 2:
54
54
locale.setlocale(locale.LC_ALL, '')
57
56
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
59
58
# Some useful constants
60
59
domain = 'se.recompile'
61
60
server_interface = domain + '.Mandos'
62
61
client_interface = domain + '.Mandos.Client'
65
dbus.OBJECT_MANAGER_IFACE
66
except AttributeError:
67
dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
65
70
def isoformat_to_datetime(iso):
66
71
"Parse an ISO 8601 date string to a datetime.datetime()"
78
int(second), # Whole seconds
79
int(fraction*1000000)) # Microseconds
83
int(second), # Whole seconds
84
int(fraction*1000000)) # Microseconds
81
87
class MandosClientPropertyCache(object):
82
88
"""This wraps a Mandos Client D-Bus proxy object, caches the
86
92
def __init__(self, proxy_object=None, properties=None, **kwargs):
87
self.proxy = proxy_object # Mandos Client proxy object
93
self.proxy = proxy_object # Mandos Client proxy object
88
94
self.properties = dict() if properties is None else properties
89
95
self.property_changed_match = (
90
self.proxy.connect_to_signal("PropertyChanged",
91
self._property_changed,
96
self.proxy.connect_to_signal("PropertiesChanged",
97
self.properties_changed,
98
dbus.PROPERTIES_IFACE,
95
101
if properties is None:
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
99
= dbus.PROPERTIES_IFACE))
102
self.properties.update(self.proxy.GetAll(
104
dbus_interface=dbus.PROPERTIES_IFACE))
101
106
super(MandosClientPropertyCache, self).__init__(**kwargs)
103
def _property_changed(self, property, value):
104
"""Helper which takes positional arguments"""
105
return self.property_changed(property=property, value=value)
107
def property_changed(self, property=None, value=None):
108
"""This is called whenever we get a PropertyChanged signal
109
It updates the changed property in the "properties" dict.
108
def properties_changed(self, interface, properties, invalidated):
109
"""This is called whenever we get a PropertiesChanged signal
110
It updates the changed properties in the "properties" dict.
111
112
# Update properties dict with new value
112
self.properties[property] = value
113
if interface == client_interface:
114
self.properties.update(properties)
114
116
def delete(self):
115
117
self.property_changed_match.remove()
118
120
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
119
121
"""A Mandos Client which is visible on the screen.
122
124
def __init__(self, server_proxy_object=None, update_hook=None,
123
125
delete_hook=None, logger=None, **kwargs):
124
126
# Called on update
163
165
byte_arrays=True))
164
166
self.logger('Created client {}'
165
167
.format(self.properties["Name"]), level=0)
167
169
def using_timer(self, flag):
168
170
"""Call this method with True or False when timer should be
169
171
activated or deactivated.
171
173
if flag and self._update_timer_callback_tag is None:
172
174
# Will update the shown timer value every second
173
self._update_timer_callback_tag = (gobject.timeout_add
175
self._update_timer_callback_tag = (GLib.timeout_add
175
177
self.update_timer))
176
178
elif not (flag or self._update_timer_callback_tag is None):
177
gobject.source_remove(self._update_timer_callback_tag)
179
GLib.source_remove(self._update_timer_callback_tag)
178
180
self._update_timer_callback_tag = None
180
182
def checker_completed(self, exitstatus, condition, command):
181
183
if exitstatus == 0:
182
184
self.logger('Checker for client {} (command "{}")'
195
197
' killed by signal {}'
196
198
.format(self.properties["Name"], command,
197
199
os.WTERMSIG(condition)))
198
elif os.WCOREDUMP(condition):
199
self.logger('Checker for client {} (command "{}") dumped'
200
' core'.format(self.properties["Name"],
203
self.logger('Checker for client {} completed'
205
.format(self.properties["Name"]))
208
202
def checker_started(self, command):
209
203
"""Server signals that a checker started."""
210
204
self.logger('Client {} started checker "{}"'
211
205
.format(self.properties["Name"],
212
206
command), level=0)
214
208
def got_secret(self):
215
209
self.logger('Client {} received its secret'
216
210
.format(self.properties["Name"]))
218
212
def need_approval(self, timeout, default):
220
214
message = 'Client {} needs approval within {} seconds'
222
216
message = 'Client {} will get its secret in {} seconds'
223
217
self.logger(message.format(self.properties["Name"],
226
220
def rejected(self, reason):
227
221
self.logger('Client {} was rejected; reason: {}'
228
222
.format(self.properties["Name"], reason))
230
224
def selectable(self):
231
225
"""Make this a "selectable" widget.
232
226
This overrides the method from urwid.FlowWidget."""
235
229
def rows(self, maxcolrow, focus=False):
236
230
"""How many rows this widget will occupy might depend on
237
231
whether we have focus or not.
238
232
This overrides the method from urwid.FlowWidget"""
239
233
return self.current_widget(focus).rows(maxcolrow, focus=focus)
241
235
def current_widget(self, focus=False):
242
236
if focus or self.opened:
243
237
return self._focus_widget
244
238
return self._widget
246
240
def update(self):
247
241
"Called when what is visible on the screen should be updated."
248
242
# How to add standout mode to a style
249
with_standout = { "normal": "standout",
250
"bold": "bold-standout",
252
"underline-blink-standout",
253
"bold-underline-blink":
254
"bold-underline-blink-standout",
243
with_standout = {"normal": "standout",
244
"bold": "bold-standout",
246
"underline-blink-standout",
247
"bold-underline-blink":
248
"bold-underline-blink-standout",
257
251
# Rebuild focus and non-focus widgets using current properties
259
253
# Base part of a client. Name!
260
254
base = '{name}: '.format(name=self.properties["Name"])
261
255
if not self.properties["Enabled"]:
262
256
message = "DISABLED"
263
257
self.using_timer(False)
264
258
elif self.properties["ApprovalPending"]:
265
timeout = datetime.timedelta(milliseconds
259
timeout = datetime.timedelta(
260
milliseconds=self.properties["ApprovalDelay"])
268
261
last_approval_request = isoformat_to_datetime(
269
262
self.properties["LastApprovalRequest"])
270
263
if last_approval_request is not None:
313
306
# Run update hook, if any
314
307
if self.update_hook is not None:
315
308
self.update_hook()
317
310
def update_timer(self):
318
"""called by gobject. Will indefinitely loop until
319
gobject.source_remove() on tag is called"""
311
"""called by GLib. Will indefinitely loop until
312
GLib.source_remove() on tag is called
321
315
return True # Keep calling this
323
317
def delete(self, **kwargs):
324
318
if self._update_timer_callback_tag is not None:
325
gobject.source_remove(self._update_timer_callback_tag)
319
GLib.source_remove(self._update_timer_callback_tag)
326
320
self._update_timer_callback_tag = None
327
321
for match in self.match_objects:
330
324
if self.delete_hook is not None:
331
325
self.delete_hook(self)
332
326
return super(MandosClientWidget, self).delete(**kwargs)
334
328
def render(self, maxcolrow, focus=False):
335
329
"""Render differently if we have focus.
336
330
This overrides the method from urwid.FlowWidget"""
337
331
return self.current_widget(focus).render(maxcolrow,
340
334
def keypress(self, maxcolrow, key):
342
336
This overrides the method from urwid.FlowWidget"""
344
self.proxy.Enable(dbus_interface = client_interface,
338
self.proxy.Set(client_interface, "Enabled",
339
dbus.Boolean(True), ignore_reply=True,
340
dbus_interface=dbus.PROPERTIES_IFACE)
347
self.proxy.Disable(dbus_interface = client_interface,
342
self.proxy.Set(client_interface, "Enabled", False,
344
dbus_interface=dbus.PROPERTIES_IFACE)
350
346
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
351
dbus_interface = client_interface,
347
dbus_interface=client_interface,
352
348
ignore_reply=True)
354
350
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
355
dbus_interface = client_interface,
351
dbus_interface=client_interface,
356
352
ignore_reply=True)
357
353
elif key == "R" or key == "_" or key == "ctrl k":
358
354
self.server_proxy_object.RemoveClient(self.proxy
360
356
ignore_reply=True)
362
self.proxy.StartChecker(dbus_interface = client_interface,
358
self.proxy.Set(client_interface, "CheckerRunning",
359
dbus.Boolean(True), ignore_reply=True,
360
dbus_interface=dbus.PROPERTIES_IFACE)
365
self.proxy.StopChecker(dbus_interface = client_interface,
362
self.proxy.Set(client_interface, "CheckerRunning",
363
dbus.Boolean(False), ignore_reply=True,
364
dbus_interface=dbus.PROPERTIES_IFACE)
368
self.proxy.CheckedOK(dbus_interface = client_interface,
366
self.proxy.CheckedOK(dbus_interface=client_interface,
369
367
ignore_reply=True)
371
369
# elif key == "p" or key == "=":
380
def property_changed(self, property=None, **kwargs):
381
"""Call self.update() if old value is not new value.
378
def properties_changed(self, interface, properties, invalidated):
379
"""Call self.update() if any properties changed.
382
380
This overrides the method from MandosClientPropertyCache"""
383
property_name = str(property)
384
old_value = self.properties.get(property_name)
385
super(MandosClientWidget, self).property_changed(
386
property=property, **kwargs)
387
if self.properties.get(property_name) != old_value:
381
old_values = {key: self.properties.get(key)
382
for key in properties.keys()}
383
super(MandosClientWidget, self).properties_changed(
384
interface, properties, invalidated)
385
if any(old_values[key] != self.properties.get(key)
386
for key in old_values):
394
393
use them as an excuse to shift focus away from this widget.
396
395
def keypress(self, *args, **kwargs):
397
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
396
ret = (super(ConstrainedListBox, self)
397
.keypress(*args, **kwargs))
398
398
if ret in ("up", "down"):
407
407
def __init__(self, max_log_length=1000, log_level=1):
408
408
DBusGMainLoop(set_as_default=True)
410
410
self.screen = urwid.curses_display.Screen()
412
412
self.screen.register_palette((
414
414
"default", "default", None),
420
420
"standout", "default", "standout"),
421
421
("bold-underline-blink",
422
"bold,underline,blink", "default", "bold,underline,blink"),
422
"bold,underline,blink", "default",
423
"bold,underline,blink"),
423
424
("bold-standout",
424
425
"bold,standout", "default", "bold,standout"),
425
426
("underline-blink-standout",
429
430
"bold,underline,blink,standout", "default",
430
431
"bold,underline,blink,standout"),
433
434
if urwid.supports_unicode():
434
self.divider = "─" # \u2500
435
#self.divider = "━" # \u2501
435
self.divider = "─" # \u2500
437
#self.divider = "-" # \u002d
438
self.divider = "_" # \u005f
437
self.divider = "_" # \u005f
440
439
self.screen.start()
442
441
self.size = self.screen.get_cols_rows()
444
443
self.clients = urwid.SimpleListWalker([])
445
444
self.clients_dict = {}
447
446
# We will add Text widgets to this list
447
self.log = urwid.SimpleListWalker([])
449
448
self.max_log_length = max_log_length
451
450
self.log_level = log_level
453
452
# We keep a reference to the log widget so we can remove it
454
453
# from the ListWalker without it getting destroyed
455
454
self.logbox = ConstrainedListBox(self.log)
457
456
# This keeps track of whether self.uilist currently has
458
457
# self.logbox in it or not
459
458
self.log_visible = True
460
459
self.log_wrap = "any"
463
462
self.log_message_raw(("bold",
464
463
"Mandos Monitor version " + version))
465
464
self.log_message_raw(("bold",
466
465
"q: Quit ?: Help"))
468
467
self.busname = domain + '.Mandos'
469
self.main_loop = gobject.MainLoop()
468
self.main_loop = GLib.MainLoop()
471
470
def client_not_found(self, fingerprint, address):
472
471
self.log_message("Client with address {} and fingerprint {}"
473
472
" could not be found"
474
473
.format(address, fingerprint))
476
475
def rebuild(self):
477
476
"""This rebuilds the User Interface.
478
477
Call this when the widget layout needs to change"""
480
#self.uilist.append(urwid.ListBox(self.clients))
479
# self.uilist.append(urwid.ListBox(self.clients))
481
480
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
483
#header=urwid.Divider(),
482
# header=urwid.Divider(),
486
urwid.Divider(div_char=
484
footer=urwid.Divider(
485
div_char=self.divider)))
488
486
if self.log_visible:
489
487
self.uilist.append(self.logbox)
490
488
self.topwidget = urwid.Pile(self.uilist)
492
490
def log_message(self, message, level=1):
493
491
"""Log message formatted with timestamp"""
494
492
if level < self.log_level:
496
494
timestamp = datetime.datetime.now().isoformat()
497
495
self.log_message_raw("{}: {}".format(timestamp, message),
500
498
def log_message_raw(self, markup, level=1):
501
499
"""Add a log message to the log buffer."""
502
500
if level < self.log_level:
504
502
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
505
if (self.max_log_length
506
and len(self.log) > self.max_log_length):
507
del self.log[0:len(self.log)-self.max_log_length-1]
508
self.logbox.set_focus(len(self.logbox.body.contents),
503
if self.max_log_length:
504
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)-1,
509
507
coming_from="above")
512
510
def toggle_log_display(self):
513
511
"""Toggle visibility of the log buffer."""
514
512
self.log_visible = not self.log_visible
516
514
self.log_message("Log visibility changed to: {}"
517
515
.format(self.log_visible), level=0)
519
517
def change_log_display(self):
520
518
"""Change type of log display.
521
519
Currently, this toggles wrapping of text lines."""
527
525
textwidget.set_wrap_mode(self.log_wrap)
528
526
self.log_message("Wrap mode: {}".format(self.log_wrap),
531
def find_and_remove_client(self, path, name):
529
def find_and_remove_client(self, path, interfaces):
532
530
"""Find a client by its object path and remove it.
534
This is connected to the ClientRemoved signal from the
532
This is connected to the InterfacesRemoved signal from the
535
533
Mandos server object."""
534
if client_interface not in interfaces:
535
# Not a Mandos client object; ignore
537
538
client = self.clients_dict[path]
540
self.log_message("Unknown client {!r} ({!r}) removed"
541
self.log_message("Unknown client {!r} removed"
545
def add_new_client(self, path):
546
def add_new_client(self, path, ifs_and_props):
547
"""Find a client by its object path and remove it.
549
This is connected to the InterfacesAdded signal from the
550
Mandos server object.
552
if client_interface not in ifs_and_props:
553
# Not a Mandos client object; ignore
546
555
client_proxy_object = self.bus.get_object(self.busname, path)
547
self.add_client(MandosClientWidget(server_proxy_object
550
=client_proxy_object,
556
self.add_client(MandosClientWidget(
557
server_proxy_object=self.mandos_serv,
558
proxy_object=client_proxy_object,
559
update_hook=self.refresh,
560
delete_hook=self.remove_client,
561
logger=self.log_message,
562
properties=dict(ifs_and_props[client_interface])),
559
565
def add_client(self, client, path=None):
560
566
self.clients.append(client)
563
569
self.clients_dict[path] = client
564
570
self.clients.sort(key=lambda c: c.properties["Name"])
567
573
def remove_client(self, client, path=None):
568
574
self.clients.remove(client)
570
576
path = client.proxy.object_path
571
577
del self.clients_dict[path]
574
580
def refresh(self):
575
581
"""Redraw the screen"""
576
582
canvas = self.topwidget.render(self.size, focus=True)
577
583
self.screen.draw_screen(self.size, canvas)
580
586
"""Start the main loop and exit when it's done."""
581
587
self.bus = dbus.SystemBus()
582
588
mandos_dbus_objc = self.bus.get_object(
583
589
self.busname, "/", follow_name_owner_changes=True)
584
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
590
self.mandos_serv = dbus.Interface(
591
mandos_dbus_objc, dbus_interface=server_interface)
588
593
mandos_clients = (self.mandos_serv
589
594
.GetAllClientsWithProperties())
590
595
if not mandos_clients:
591
self.log_message_raw(("bold", "Note: Server has no clients."))
596
self.log_message_raw(("bold",
597
"Note: Server has no clients."))
592
598
except dbus.exceptions.DBusException:
593
self.log_message_raw(("bold", "Note: No Mandos server running."))
599
self.log_message_raw(("bold",
600
"Note: No Mandos server running."))
594
601
mandos_clients = dbus.Dictionary()
596
603
(self.mandos_serv
597
.connect_to_signal("ClientRemoved",
604
.connect_to_signal("InterfacesRemoved",
598
605
self.find_and_remove_client,
599
dbus_interface=server_interface,
606
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
600
607
byte_arrays=True))
601
608
(self.mandos_serv
602
.connect_to_signal("ClientAdded",
609
.connect_to_signal("InterfacesAdded",
603
610
self.add_new_client,
604
dbus_interface=server_interface,
611
dbus_interface=dbus.OBJECT_MANAGER_IFACE,
605
612
byte_arrays=True))
606
613
(self.mandos_serv
607
614
.connect_to_signal("ClientNotFound",
611
618
for path, client in mandos_clients.items():
612
619
client_proxy_object = self.bus.get_object(self.busname,
614
self.add_client(MandosClientWidget(server_proxy_object
617
=client_proxy_object,
621
self.add_client(MandosClientWidget(
622
server_proxy_object=self.mandos_serv,
623
proxy_object=client_proxy_object,
625
update_hook=self.refresh,
626
delete_hook=self.remove_client,
627
logger=self.log_message),
628
self._input_callback_tag = (gobject.io_add_watch
631
self._input_callback_tag = (
633
GLib.IOChannel.unix_new(sys.stdin.fileno()),
634
GLib.PRIORITY_DEFAULT, GLib.IO_IN,
632
636
self.main_loop.run()
633
637
# Main loop has finished, we should close everything now
634
gobject.source_remove(self._input_callback_tag)
638
GLib.source_remove(self._input_callback_tag)
635
639
self.screen.stop()
638
642
self.main_loop.quit()
640
644
def process_input(self, source, condition):
641
645
keys = self.screen.get_input()
642
translations = { "ctrl n": "down", # Emacs
643
"ctrl p": "up", # Emacs
644
"ctrl v": "page down", # Emacs
645
"meta v": "page up", # Emacs
646
" ": "page down", # less
647
"f": "page down", # less
648
"b": "page up", # less
646
translations = {"ctrl n": "down", # Emacs
647
"ctrl p": "up", # Emacs
648
"ctrl v": "page down", # Emacs
649
"meta v": "page up", # Emacs
650
" ": "page down", # less
651
"f": "page down", # less
652
"b": "page up", # less
654
658
key = translations[key]
655
659
except KeyError: # :-)
658
662
if key == "q" or key == "Q":
709
713
self.log_level = 0
710
714
self.log_message("Verbose mode: On")
711
#elif (key == "end" or key == "meta >" or key == "G"
713
# pass # xxx end-of-buffer
714
#elif (key == "home" or key == "meta <" or key == "g"
716
# pass # xxx beginning-of-buffer
717
#elif key == "ctrl e" or key == "$":
718
# pass # xxx move-end-of-line
719
#elif key == "ctrl a" or key == "^":
720
# pass # xxx move-beginning-of-line
721
#elif key == "ctrl b" or key == "meta (" or key == "h":
723
#elif key == "ctrl f" or key == "meta )" or key == "l":
726
# pass # scroll up log
728
# pass # scroll down log
715
# elif (key == "end" or key == "meta >" or key == "G"
717
# pass # xxx end-of-buffer
718
# elif (key == "home" or key == "meta <" or key == "g"
720
# pass # xxx beginning-of-buffer
721
# elif key == "ctrl e" or key == "$":
722
# pass # xxx move-end-of-line
723
# elif key == "ctrl a" or key == "^":
724
# pass # xxx move-beginning-of-line
725
# elif key == "ctrl b" or key == "meta (" or key == "h":
727
# elif key == "ctrl f" or key == "meta )" or key == "l":
730
# pass # scroll up log
732
# pass # scroll down log
729
733
elif self.topwidget.selectable():
730
734
self.topwidget.keypress(self.size, key)
734
739
ui = UserInterface()