2
2
# -*- mode: python; coding: utf-8 -*-
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
11
# the Free Software Foundation, either version 3 of the License, or
12
# (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
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
# GNU General Public License for more details.
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/>.
23
# Contact the authors at <mandos@recompile.se>.
4
from __future__ import division, absolute_import, with_statement
26
from __future__ import (division, absolute_import, print_function,
29
from future_builtins import *
15
41
from dbus.mainloop.glib import DBusGMainLoop
45
from gi.repository import GObject as gobject
51
if sys.version_info[0] == 2:
54
locale.setlocale(locale.LC_ALL, '')
57
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
22
59
# Some useful constants
23
domain = 'se.bsnet.fukt'
60
domain = 'se.recompile'
24
61
server_interface = domain + '.Mandos'
25
62
client_interface = domain + '.Mandos.Client'
28
# Always run in monochrome mode
29
urwid.curses_display.curses.has_colors = lambda : False
31
# Urwid doesn't support blinking, but we want it. Since we have no
32
# use for underline on its own, we make underline also always blink.
33
urwid.curses_display.curses.A_UNDERLINE |= (
34
urwid.curses_display.curses.A_BLINK)
65
def isoformat_to_datetime(iso):
66
"Parse an ISO 8601 date string to a datetime.datetime()"
69
d, t = iso.split("T", 1)
70
year, month, day = d.split("-", 2)
71
hour, minute, second = t.split(":", 2)
72
second, fraction = divmod(float(second), 1)
73
return datetime.datetime(int(year),
78
int(second), # Whole seconds
79
int(fraction*1000000)) # Microseconds
36
81
class MandosClientPropertyCache(object):
37
82
"""This wraps a Mandos Client D-Bus proxy object, caches the
38
83
properties and calls a hook function when any of them are
41
def __init__(self, proxy_object=None, properties=None, *args,
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
43
87
self.proxy = proxy_object # Mandos Client proxy object
45
if properties is None:
46
self.properties = dict()
48
self.properties = properties
49
self.proxy.connect_to_signal(u"PropertyChanged",
50
self.property_changed,
54
if properties is None:
55
self.properties.update(self.proxy.GetAll(client_interface,
57
dbus.PROPERTIES_IFACE))
58
super(MandosClientPropertyCache, self).__init__(
59
proxy_object=proxy_object,
60
properties=properties, *args, **kwargs)
88
self.properties = dict() if properties is None else properties
89
self.property_changed_match = (
90
self.proxy.connect_to_signal("PropertyChanged",
91
self._property_changed,
95
if properties is None:
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
99
= dbus.PROPERTIES_IFACE))
101
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)
62
107
def property_changed(self, property=None, value=None):
63
108
"""This is called whenever we get a PropertyChanged signal
83
131
self.logger = logger
133
self._update_timer_callback_tag = None
85
135
# The widget shown normally
86
self._text_widget = urwid.Text(u"")
136
self._text_widget = urwid.Text("")
87
137
# The widget shown when we have focus
88
self._focus_text_widget = urwid.Text(u"")
89
super(MandosClientWidget, self).__init__(
90
update_hook=update_hook, delete_hook=delete_hook,
138
self._focus_text_widget = urwid.Text("")
139
super(MandosClientWidget, self).__init__(**kwargs)
93
141
self.opened = False
94
self.proxy.connect_to_signal(u"CheckerCompleted",
95
self.checker_completed,
98
self.proxy.connect_to_signal(u"CheckerStarted",
102
self.proxy.connect_to_signal(u"GotSecret",
106
self.proxy.connect_to_signal(u"Rejected",
143
self.match_objects = (
144
self.proxy.connect_to_signal("CheckerCompleted",
145
self.checker_completed,
148
self.proxy.connect_to_signal("CheckerStarted",
149
self.checker_started,
152
self.proxy.connect_to_signal("GotSecret",
156
self.proxy.connect_to_signal("NeedApproval",
160
self.proxy.connect_to_signal("Rejected",
164
self.logger('Created client {0}'
165
.format(self.properties["Name"]), level=0)
167
def using_timer(self, flag):
168
"""Call this method with True or False when timer should be
169
activated or deactivated.
171
if flag and self._update_timer_callback_tag is None:
172
# Will update the shown timer value every second
173
self._update_timer_callback_tag = (gobject.timeout_add
176
elif not (flag or self._update_timer_callback_tag is None):
177
gobject.source_remove(self._update_timer_callback_tag)
178
self._update_timer_callback_tag = None
111
180
def checker_completed(self, exitstatus, condition, command):
112
181
if exitstatus == 0:
113
self.logger(u'Checker for client %s (command "%s")'
115
% (self.properties[u"name"], command))
182
self.logger('Checker for client {0} (command "{1}")'
183
' succeeded'.format(self.properties["Name"],
117
188
if os.WIFEXITED(condition):
118
self.logger(u'Checker for client %s (command "%s")'
119
u' failed with exit code %s'
120
% (self.properties[u"name"], command,
121
os.WEXITSTATUS(condition)))
123
if os.WIFSIGNALED(condition):
124
self.logger(u'Checker for client %s (command "%s")'
125
u' was killed by signal %s'
126
% (self.properties[u"name"], command,
127
os.WTERMSIG(condition)))
129
if os.WCOREDUMP(condition):
130
self.logger(u'Checker for client %s (command "%s")'
132
% (self.properties[u"name"], command))
133
self.logger(u'Checker for client %s completed mysteriously')
189
self.logger('Checker for client {0} (command "{1}")'
190
' failed with exit code {2}'
191
.format(self.properties["Name"], command,
192
os.WEXITSTATUS(condition)))
193
elif os.WIFSIGNALED(condition):
194
self.logger('Checker for client {0} (command "{1}") was'
195
' killed by signal {2}'
196
.format(self.properties["Name"], command,
197
os.WTERMSIG(condition)))
198
elif os.WCOREDUMP(condition):
199
self.logger('Checker for client {0} (command "{1}")'
201
.format(self.properties["Name"], command))
203
self.logger('Checker for client {0} completed'
205
.format(self.properties["Name"]))
135
208
def checker_started(self, command):
136
self.logger(u'Client %s started checker "%s"'
137
% (self.properties[u"name"], unicode(command)))
209
"""Server signals that a checker started."""
210
self.logger('Client {0} started checker "{1}"'
211
.format(self.properties["Name"],
139
214
def got_secret(self):
140
self.logger(u'Client %s received its secret'
141
% self.properties[u"name"])
144
self.logger(u'Client %s was rejected'
145
% self.properties[u"name"])
215
self.logger('Client {0} received its secret'
216
.format(self.properties["Name"]))
218
def need_approval(self, timeout, default):
220
message = 'Client {0} needs approval within {1} seconds'
222
message = 'Client {0} will get its secret in {1} seconds'
223
self.logger(message.format(self.properties["Name"],
226
def rejected(self, reason):
227
self.logger('Client {0} was rejected; reason: {1}'
228
.format(self.properties["Name"], reason))
147
230
def selectable(self):
148
231
"""Make this a "selectable" widget.
149
232
This overrides the method from urwid.FlowWidget."""
152
def rows(self, (maxcol,), focus=False):
235
def rows(self, maxcolrow, focus=False):
153
236
"""How many rows this widget will occupy might depend on
154
237
whether we have focus or not.
155
238
This overrides the method from urwid.FlowWidget"""
156
return self.current_widget(focus).rows((maxcol,), focus=focus)
239
return self.current_widget(focus).rows(maxcolrow, focus=focus)
158
241
def current_widget(self, focus=False):
159
242
if focus or self.opened:
163
246
def update(self):
164
247
"Called when what is visible on the screen should be updated."
165
248
# How to add standout mode to a style
166
with_standout = { u"normal": u"standout",
167
u"bold": u"bold-standout",
169
u"underline-blink-standout",
170
u"bold-underline-blink":
171
u"bold-underline-blink-standout",
249
with_standout = { "normal": "standout",
250
"bold": "bold-standout",
252
"underline-blink-standout",
253
"bold-underline-blink":
254
"bold-underline-blink-standout",
174
257
# Rebuild focus and non-focus widgets using current properties
175
self._text = (u'%(name)s: %(enabled)s'
176
% { u"name": self.properties[u"name"],
179
if self.properties[u"enabled"]
259
# Base part of a client. Name!
260
base = '{name}: '.format(name=self.properties["Name"])
261
if not self.properties["Enabled"]:
263
self.using_timer(False)
264
elif self.properties["ApprovalPending"]:
265
timeout = datetime.timedelta(milliseconds
268
last_approval_request = isoformat_to_datetime(
269
self.properties["LastApprovalRequest"])
270
if last_approval_request is not None:
271
timer = max(timeout - (datetime.datetime.utcnow()
272
- last_approval_request),
273
datetime.timedelta())
275
timer = datetime.timedelta()
276
if self.properties["ApprovedByDefault"]:
277
message = "Approval in {0}. (d)eny?"
279
message = "Denial in {0}. (a)pprove?"
280
message = message.format(str(timer).rsplit(".", 1)[0])
281
self.using_timer(True)
282
elif self.properties["LastCheckerStatus"] != 0:
283
# When checker has failed, show timer until client expires
284
expires = self.properties["Expires"]
286
timer = datetime.timedelta(0)
288
expires = (datetime.datetime.strptime
289
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
290
timer = max(expires - datetime.datetime.utcnow(),
291
datetime.timedelta())
292
message = ('A checker has failed! Time until client'
293
' gets disabled: {0}'
294
.format(str(timer).rsplit(".", 1)[0]))
295
self.using_timer(True)
298
self.using_timer(False)
299
self._text = "{0}{1}".format(base, message)
181
301
if not urwid.supports_unicode():
182
302
self._text = self._text.encode("ascii", "replace")
183
textlist = [(u"normal", self._text)]
303
textlist = [("normal", self._text)]
184
304
self._text_widget.set_text(textlist)
185
305
self._focus_text_widget.set_text([(with_standout[text[0]],
194
314
if self.update_hook is not None:
195
315
self.update_hook()
317
def update_timer(self):
318
"""called by gobject. Will indefinitely loop until
319
gobject.source_remove() on tag is called"""
321
return True # Keep calling this
323
def delete(self, **kwargs):
324
if self._update_timer_callback_tag is not None:
325
gobject.source_remove(self._update_timer_callback_tag)
326
self._update_timer_callback_tag = None
327
for match in self.match_objects:
329
self.match_objects = ()
198
330
if self.delete_hook is not None:
199
331
self.delete_hook(self)
332
return super(MandosClientWidget, self).delete(**kwargs)
201
def render(self, (maxcol,), focus=False):
334
def render(self, maxcolrow, focus=False):
202
335
"""Render differently if we have focus.
203
336
This overrides the method from urwid.FlowWidget"""
204
return self.current_widget(focus).render((maxcol,),
337
return self.current_widget(focus).render(maxcolrow,
207
def keypress(self, (maxcol,), key):
340
def keypress(self, maxcolrow, key):
209
342
This overrides the method from urwid.FlowWidget"""
210
if key == u"e" or key == u"+":
212
elif key == u"d" or key == u"-":
214
elif key == u"r" or key == u"_" or key == u"ctrl k":
344
self.proxy.Enable(dbus_interface = client_interface,
347
self.proxy.Disable(dbus_interface = client_interface,
350
self.proxy.Approve(dbus.Boolean(True, variant_level=1),
351
dbus_interface = client_interface,
354
self.proxy.Approve(dbus.Boolean(False, variant_level=1),
355
dbus_interface = client_interface,
357
elif key == "R" or key == "_" or key == "ctrl k":
215
358
self.server_proxy_object.RemoveClient(self.proxy
218
self.proxy.StartChecker()
220
self.proxy.StopChecker()
222
self.proxy.CheckedOK()
362
self.proxy.StartChecker(dbus_interface = client_interface,
365
self.proxy.StopChecker(dbus_interface = client_interface,
368
self.proxy.CheckedOK(dbus_interface = client_interface,
224
# elif key == u"p" or key == "=":
371
# elif key == "p" or key == "=":
225
372
# self.proxy.pause()
226
# elif key == u"u" or key == ":":
373
# elif key == "u" or key == ":":
227
374
# self.proxy.unpause()
228
# elif key == u"RET":
233
def property_changed(self, property=None, value=None,
380
def property_changed(self, property=None, **kwargs):
235
381
"""Call self.update() if old value is not new value.
236
382
This overrides the method from MandosClientPropertyCache"""
237
property_name = unicode(property)
383
property_name = str(property)
238
384
old_value = self.properties.get(property_name)
239
385
super(MandosClientWidget, self).property_changed(
240
property=property, value=value, *args, **kwargs)
386
property=property, **kwargs)
241
387
if self.properties.get(property_name) != old_value:
258
404
"""This is the entire user interface - the whole screen
259
405
with boxes, lists of client widgets, etc.
261
def __init__(self, max_log_length=1000):
407
def __init__(self, max_log_length=1000, log_level=1):
262
408
DBusGMainLoop(set_as_default=True)
264
410
self.screen = urwid.curses_display.Screen()
266
412
self.screen.register_palette((
268
u"default", u"default", None),
270
u"default", u"default", u"bold"),
272
u"default", u"default", u"underline"),
274
u"default", u"default", u"standout"),
275
(u"bold-underline-blink",
276
u"default", u"default", (u"bold", u"underline")),
278
u"default", u"default", (u"bold", u"standout")),
279
(u"underline-blink-standout",
280
u"default", u"default", (u"underline", u"standout")),
281
(u"bold-underline-blink-standout",
282
u"default", u"default", (u"bold", u"underline",
414
"default", "default", None),
416
"bold", "default", "bold"),
418
"underline,blink", "default", "underline,blink"),
420
"standout", "default", "standout"),
421
("bold-underline-blink",
422
"bold,underline,blink", "default", "bold,underline,blink"),
424
"bold,standout", "default", "bold,standout"),
425
("underline-blink-standout",
426
"underline,blink,standout", "default",
427
"underline,blink,standout"),
428
("bold-underline-blink-standout",
429
"bold,underline,blink,standout", "default",
430
"bold,underline,blink,standout"),
286
433
if urwid.supports_unicode():
287
self.divider = u"─" # \u2500
288
#self.divider = u"━" # \u2501
434
self.divider = "─" # \u2500
435
#self.divider = "━" # \u2501
290
#self.divider = u"-" # \u002d
291
self.divider = u"_" # \u005f
437
#self.divider = "-" # \u002d
438
self.divider = "_" # \u005f
293
440
self.screen.start()
308
457
# This keeps track of whether self.uilist currently has
309
458
# self.logbox in it or not
310
459
self.log_visible = True
311
self.log_wrap = u"any"
460
self.log_wrap = "any"
314
self.log_message_raw((u"bold",
315
u"Mandos Monitor version " + version))
316
self.log_message_raw((u"bold",
463
self.log_message_raw(("bold",
464
"Mandos Monitor version " + version))
465
self.log_message_raw(("bold",
319
468
self.busname = domain + '.Mandos'
320
469
self.main_loop = gobject.MainLoop()
321
self.bus = dbus.SystemBus()
322
mandos_dbus_objc = self.bus.get_object(
323
self.busname, u"/", follow_name_owner_changes=True)
324
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
328
mandos_clients = (self.mandos_serv
329
.GetAllClientsWithProperties())
330
except dbus.exceptions.DBusException:
331
mandos_clients = dbus.Dictionary()
334
.connect_to_signal(u"ClientRemoved",
335
self.find_and_remove_client,
336
dbus_interface=server_interface,
339
.connect_to_signal(u"ClientAdded",
341
dbus_interface=server_interface,
344
.connect_to_signal(u"ClientNotFound",
345
self.client_not_found,
346
dbus_interface=server_interface,
348
for path, client in mandos_clients.iteritems():
349
client_proxy_object = self.bus.get_object(self.busname,
351
self.add_client(MandosClientWidget(server_proxy_object
354
=client_proxy_object,
364
471
def client_not_found(self, fingerprint, address):
365
self.log_message((u"Client with address %s and fingerprint %s"
366
u" could not be found" % (address,
472
self.log_message("Client with address {0} and fingerprint"
473
" {1} could not be found"
474
.format(address, fingerprint))
369
476
def rebuild(self):
370
477
"""This rebuilds the User Interface.
371
478
Call this when the widget layout needs to change"""
373
480
#self.uilist.append(urwid.ListBox(self.clients))
374
self.uilist.append(urwid.Frame(ConstrainedListBox(self.clients),
481
self.uilist.append(urwid.Frame(ConstrainedListBox(self.
375
483
#header=urwid.Divider(),
377
footer=urwid.Divider(div_char=self.divider)))
486
urwid.Divider(div_char=
378
488
if self.log_visible:
379
489
self.uilist.append(self.logbox)
381
490
self.topwidget = urwid.Pile(self.uilist)
383
def log_message(self, message):
492
def log_message(self, message, level=1):
493
"""Log message formatted with timestamp"""
494
if level < self.log_level:
384
496
timestamp = datetime.datetime.now().isoformat()
385
self.log_message_raw(timestamp + u": " + message)
497
self.log_message_raw("{0}: {1}".format(timestamp, message),
387
def log_message_raw(self, markup):
500
def log_message_raw(self, markup, level=1):
388
501
"""Add a log message to the log buffer."""
502
if level < self.log_level:
389
504
self.log.append(urwid.Text(markup, wrap=self.log_wrap))
390
505
if (self.max_log_length
391
506
and len(self.log) > self.max_log_length):
392
507
del self.log[0:len(self.log)-self.max_log_length-1]
393
508
self.logbox.set_focus(len(self.logbox.body.contents),
394
coming_from=u"above")
397
512
def toggle_log_display(self):
398
513
"""Toggle visibility of the log buffer."""
399
514
self.log_visible = not self.log_visible
401
self.log_message(u"Log visibility changed to: "
402
+ unicode(self.log_visible))
516
self.log_message("Log visibility changed to: {0}"
517
.format(self.log_visible), level=0)
404
519
def change_log_display(self):
405
520
"""Change type of log display.
406
521
Currently, this toggles wrapping of text lines."""
407
if self.log_wrap == u"clip":
408
self.log_wrap = u"any"
522
if self.log_wrap == "clip":
523
self.log_wrap = "any"
410
self.log_wrap = u"clip"
525
self.log_wrap = "clip"
411
526
for textwidget in self.log:
412
527
textwidget.set_wrap_mode(self.log_wrap)
413
self.log_message(u"Wrap mode: " + self.log_wrap)
528
self.log_message("Wrap mode: {0}".format(self.log_wrap),
415
531
def find_and_remove_client(self, path, name):
416
"""Find an client from its object path and remove it.
532
"""Find a client by its object path and remove it.
418
534
This is connected to the ClientRemoved signal from the
419
535
Mandos server object."""
466
580
"""Start the main loop and exit when it's done."""
581
self.bus = dbus.SystemBus()
582
mandos_dbus_objc = self.bus.get_object(
583
self.busname, "/", follow_name_owner_changes=True)
584
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
588
mandos_clients = (self.mandos_serv
589
.GetAllClientsWithProperties())
590
if not mandos_clients:
591
self.log_message_raw(("bold", "Note: Server has no clients."))
592
except dbus.exceptions.DBusException:
593
self.log_message_raw(("bold", "Note: No Mandos server running."))
594
mandos_clients = dbus.Dictionary()
597
.connect_to_signal("ClientRemoved",
598
self.find_and_remove_client,
599
dbus_interface=server_interface,
602
.connect_to_signal("ClientAdded",
604
dbus_interface=server_interface,
607
.connect_to_signal("ClientNotFound",
608
self.client_not_found,
609
dbus_interface=server_interface,
611
for path, client in mandos_clients.items():
612
client_proxy_object = self.bus.get_object(self.busname,
614
self.add_client(MandosClientWidget(server_proxy_object
617
=client_proxy_object,
468
628
self._input_callback_tag = (gobject.io_add_watch
469
629
(sys.stdin.fileno(),
495
655
except KeyError: # :-)
498
if key == u"q" or key == u"Q":
658
if key == "q" or key == "Q":
501
elif key == u"window resize":
661
elif key == "window resize":
502
662
self.size = self.screen.get_cols_rows()
504
elif key == u"\f": # Ctrl-L
664
elif key == "\f": # Ctrl-L
506
elif key == u"l" or key == u"D":
666
elif key == "l" or key == "D":
507
667
self.toggle_log_display()
509
elif key == u"w" or key == u"i":
669
elif key == "w" or key == "i":
510
670
self.change_log_display()
512
elif key == u"?" or key == u"f1" or key == u"esc":
672
elif key == "?" or key == "f1" or key == "esc":
513
673
if not self.log_visible:
514
674
self.log_visible = True
516
self.log_message_raw((u"bold",
520
u"l: Log window toggle",
521
u"TAB: Switch window",
523
self.log_message_raw((u"bold",
529
u"s: Start new checker",
676
self.log_message_raw(("bold",
680
"l: Log window toggle",
681
"TAB: Switch window",
682
"w: Wrap (log lines)",
683
"v: Toggle verbose log",
685
self.log_message_raw(("bold",
691
"s: Start new checker",
534
698
if self.topwidget.get_focus() is self.logbox:
535
699
self.topwidget.set_focus(0)
537
701
self.topwidget.set_focus(self.logbox)
539
#elif (key == u"end" or key == u"meta >" or key == u"G"
704
if self.log_level == 0:
706
self.log_message("Verbose mode: Off")
709
self.log_message("Verbose mode: On")
710
#elif (key == "end" or key == "meta >" or key == "G"
541
712
# pass # xxx end-of-buffer
542
#elif (key == u"home" or key == u"meta <" or key == u"g"
713
#elif (key == "home" or key == "meta <" or key == "g"
544
715
# pass # xxx beginning-of-buffer
545
#elif key == u"ctrl e" or key == u"$":
716
#elif key == "ctrl e" or key == "$":
546
717
# pass # xxx move-end-of-line
547
#elif key == u"ctrl a" or key == u"^":
718
#elif key == "ctrl a" or key == "^":
548
719
# pass # xxx move-beginning-of-line
549
#elif key == u"ctrl b" or key == u"meta (" or key == u"h":
720
#elif key == "ctrl b" or key == "meta (" or key == "h":
550
721
# pass # xxx left
551
#elif key == u"ctrl f" or key == u"meta )" or key == u"l":
722
#elif key == "ctrl f" or key == "meta )" or key == "l":
552
723
# pass # xxx right
554
725
# pass # scroll up log
556
727
# pass # scroll down log
557
728
elif self.topwidget.selectable():
558
729
self.topwidget.keypress(self.size, key)