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
- browse files at revision 494
- compare with another revision
- download diff
- download tarball
- view history from revision 494
- Committer: Teddy Hogeborn
- Date: 2011-08-17 22:27:13 UTC
- Revision ID: teddy@fukt.bsnet.se-20110817222713-xemqfzafjciuaqkz
* mandos-keygen: Loop until passwords match when run interactively.
- files removed:
- debian/mandos-client.examples
- network-hooks.d
- files modified:
- .bzrignore
added
removed
mandos-monitor
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
6
# Copyright © 2009-2014 Teddy Hogeborn
7
# Copyright © 2009-2014 Björn Påhlsson
6
# Copyright © 2009-2011 Teddy Hogeborn
7
# Copyright © 2009-2011 Björn Påhlsson
8
8
#
9
9
# This program is free software: you can redistribute it and/or modify
10
10
# it under the terms of the GNU General Public License as published by
17
17
# GNU General Public License for more details.
18
18
#
19
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/>.
20
# along with this program. If not, see <http://www.gnu.org/licenses/>.
22
21
#
23
# Contact the authors at <mandos@recompile.se>.
22
# Contact the authors at <mandos@fukt.bsnet.se>.
24
23
#
25
24
26
25
from __future__ import (division, absolute_import, print_function,
27
26
unicode_literals)
28
try:
29
from future_builtins import *
30
except ImportError:
31
pass
32
27
33
28
import sys
34
29
import os
30
import signal
35
31
36
32
import datetime
37
33
39
35
import urwid
40
36
41
37
from dbus.mainloop.glib import DBusGMainLoop
42
try:
43
import gobject
44
except ImportError:
45
from gi.repository import GObject as gobject
38
import gobject
46
39
47
40
import dbus
48
41
42
import UserList
43
49
44
import locale
50
45
51
if sys.version_info[0] == 2:
52
str = unicode
53
54
46
locale.setlocale(locale.LC_ALL, '')
55
47
56
48
import logging
57
49
logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)
58
50
59
51
# Some useful constants
60
domain = 'se.recompile'
52
domain = 'se.bsnet.fukt'
61
53
server_interface = domain + '.Mandos'
62
54
client_interface = domain + '.Mandos.Client'
63
version = "1.6.4"
55
version = "1.3.1"
56
57
# Always run in monochrome mode
58
urwid.curses_display.curses.has_colors = lambda : False
59
60
# Urwid doesn't support blinking, but we want it. Since we have no
61
# use for underline on its own, we make underline also always blink.
62
urwid.curses_display.curses.A_UNDERLINE |= (
63
urwid.curses_display.curses.A_BLINK)
64
64
65
65
def isoformat_to_datetime(iso):
66
66
"Parse an ISO 8601 date string to a datetime.datetime()"
83
83
properties and calls a hook function when any of them are
84
84
changed.
85
85
"""
86
def __init__(self, proxy_object=None, properties=None, **kwargs):
86
def __init__(self, proxy_object=None, *args, **kwargs):
87
87
self.proxy = proxy_object # Mandos Client proxy object
88
self.properties = dict() if properties is None else properties
88
89
self.properties = dict()
89
90
self.property_changed_match = (
90
91
self.proxy.connect_to_signal("PropertyChanged",
91
self._property_changed,
92
self.property_changed,
92
93
client_interface,
93
94
byte_arrays=True))
94
95
95
if properties is None:
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface
99
= dbus.PROPERTIES_IFACE))
100
101
super(MandosClientPropertyCache, self).__init__(**kwargs)
102
103
def _property_changed(self, property, value):
104
"""Helper which takes positional arguments"""
105
return self.property_changed(property=property, value=value)
96
self.properties.update(
97
self.proxy.GetAll(client_interface,
98
dbus_interface = dbus.PROPERTIES_IFACE))
99
100
#XXX This breaks good super behaviour
101
# super(MandosClientPropertyCache, self).__init__(
102
# *args, **kwargs)
106
103
107
104
def property_changed(self, property=None, value=None):
108
105
"""This is called whenever we get a PropertyChanged signal
111
108
# Update properties dict with new value
112
109
self.properties[property] = value
113
110
114
def delete(self):
111
def delete(self, *args, **kwargs):
115
112
self.property_changed_match.remove()
113
super(MandosClientPropertyCache, self).__init__(
114
*args, **kwargs)
116
115
117
116
118
117
class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):
120
119
"""
121
120
122
121
def __init__(self, server_proxy_object=None, update_hook=None,
123
delete_hook=None, logger=None, **kwargs):
122
delete_hook=None, logger=None, *args, **kwargs):
124
123
# Called on update
125
124
self.update_hook = update_hook
126
125
# Called on delete
131
130
self.logger = logger
132
131
133
132
self._update_timer_callback_tag = None
133
self._update_timer_callback_lock = 0
134
self.last_checker_failed = False
134
135
135
136
# The widget shown normally
136
137
self._text_widget = urwid.Text("")
137
138
# The widget shown when we have focus
138
139
self._focus_text_widget = urwid.Text("")
139
super(MandosClientWidget, self).__init__(**kwargs)
140
super(MandosClientWidget, self).__init__(
141
update_hook=update_hook, delete_hook=delete_hook,
142
*args, **kwargs)
140
143
self.update()
141
144
self.opened = False
142
145
146
last_checked_ok = isoformat_to_datetime(self.properties
147
["LastCheckedOK"])
148
if last_checked_ok is None:
149
self.last_checker_failed = True
150
else:
151
self.last_checker_failed = ((datetime.datetime.utcnow()
152
- last_checked_ok)
153
> datetime.timedelta
154
(milliseconds=
155
self.properties
156
["Interval"]))
157
158
if self.last_checker_failed:
159
self.using_timer(True)
160
161
if self.need_approval:
162
self.using_timer(True)
163
143
164
self.match_objects = (
144
165
self.proxy.connect_to_signal("CheckerCompleted",
145
166
self.checker_completed,
161
182
self.rejected,
162
183
client_interface,
163
184
byte_arrays=True))
164
#self.logger('Created client {0}'
165
# .format(self.properties["Name"]))
185
#self.logger('Created client %s' % (self.properties["Name"]))
166
186
187
def property_changed(self, property=None, value=None):
188
super(self, MandosClientWidget).property_changed(property,
189
value)
190
if property == "ApprovalPending":
191
using_timer(bool(value))
192
167
193
def using_timer(self, flag):
168
194
"""Call this method with True or False when timer should be
169
195
activated or deactivated.
170
196
"""
171
if flag and self._update_timer_callback_tag is None:
172
# Will update the shown timer value every second
197
old = self._update_timer_callback_lock
198
if flag:
199
self._update_timer_callback_lock += 1
200
else:
201
self._update_timer_callback_lock -= 1
202
if old == 0 and self._update_timer_callback_lock:
173
203
self._update_timer_callback_tag = (gobject.timeout_add
174
204
(1000,
175
205
self.update_timer))
176
elif not (flag or self._update_timer_callback_tag is None):
206
elif old and self._update_timer_callback_lock == 0:
177
207
gobject.source_remove(self._update_timer_callback_tag)
178
208
self._update_timer_callback_tag = None
179
209
180
210
def checker_completed(self, exitstatus, condition, command):
181
211
if exitstatus == 0:
212
if self.last_checker_failed:
213
self.last_checker_failed = False
214
self.using_timer(False)
215
#self.logger('Checker for client %s (command "%s")'
216
# ' was successful'
217
# % (self.properties["Name"], command))
182
218
self.update()
183
219
return
184
220
# Checker failed
221
if not self.last_checker_failed:
222
self.last_checker_failed = True
223
self.using_timer(True)
185
224
if os.WIFEXITED(condition):
186
self.logger('Checker for client {0} (command "{1}")'
187
' failed with exit code {2}'
188
.format(self.properties["Name"], command,
189
os.WEXITSTATUS(condition)))
225
self.logger('Checker for client %s (command "%s")'
226
' failed with exit code %s'
227
% (self.properties["Name"], command,
228
os.WEXITSTATUS(condition)))
190
229
elif os.WIFSIGNALED(condition):
191
self.logger('Checker for client {0} (command "{1}") was'
192
' killed by signal {2}'
193
.format(self.properties["Name"], command,
194
os.WTERMSIG(condition)))
230
self.logger('Checker for client %s (command "%s")'
231
' was killed by signal %s'
232
% (self.properties["Name"], command,
233
os.WTERMSIG(condition)))
195
234
elif os.WCOREDUMP(condition):
196
self.logger('Checker for client {0} (command "{1}")'
235
self.logger('Checker for client %s (command "%s")'
197
236
' dumped core'
198
.format(self.properties["Name"], command))
237
% (self.properties["Name"], command))
199
238
else:
200
self.logger('Checker for client {0} completed'
201
' mysteriously'
202
.format(self.properties["Name"]))
239
self.logger('Checker for client %s completed'
240
' mysteriously')
203
241
self.update()
204
242
205
243
def checker_started(self, command):
206
"""Server signals that a checker started. This could be useful
207
to log in the future. """
208
#self.logger('Client {0} started checker "{1}"'
209
# .format(self.properties["Name"],
210
# str(command)))
244
#self.logger('Client %s started checker "%s"'
245
# % (self.properties["Name"], unicode(command)))
211
246
pass
212
247
213
248
def got_secret(self):
214
self.logger('Client {0} received its secret'
215
.format(self.properties["Name"]))
249
self.last_checker_failed = False
250
self.logger('Client %s received its secret'
251
% self.properties["Name"])
216
252
217
253
def need_approval(self, timeout, default):
218
254
if not default:
219
message = 'Client {0} needs approval within {1} seconds'
255
message = 'Client %s needs approval within %s seconds'
220
256
else:
221
message = 'Client {0} will get its secret in {1} seconds'
222
self.logger(message.format(self.properties["Name"],
223
timeout/1000))
257
message = 'Client %s will get its secret in %s seconds'
258
self.logger(message
259
% (self.properties["Name"], timeout/1000))
260
self.using_timer(True)
224
261
225
262
def rejected(self, reason):
226
self.logger('Client {0} was rejected; reason: {1}'
227
.format(self.properties["Name"], reason))
263
self.logger('Client %s was rejected; reason: %s'
264
% (self.properties["Name"], reason))
228
265
229
266
def selectable(self):
230
267
"""Make this a "selectable" widget.
252
289
"bold-underline-blink":
253
290
"bold-underline-blink-standout",
254
291
}
255
292
256
293
# Rebuild focus and non-focus widgets using current properties
257
294
258
295
# Base part of a client. Name!
259
base = '{name}: '.format(name=self.properties["Name"])
296
base = ('%(name)s: '
297
% {"name": self.properties["Name"]})
260
298
if not self.properties["Enabled"]:
261
299
message = "DISABLED"
262
self.using_timer(False)
263
300
elif self.properties["ApprovalPending"]:
264
301
timeout = datetime.timedelta(milliseconds
265
302
= self.properties
267
304
last_approval_request = isoformat_to_datetime(
268
305
self.properties["LastApprovalRequest"])
269
306
if last_approval_request is not None:
270
timer = max(timeout - (datetime.datetime.utcnow()
271
- last_approval_request),
272
datetime.timedelta())
307
timer = timeout - (datetime.datetime.utcnow()
308
- last_approval_request)
273
309
else:
274
310
timer = datetime.timedelta()
275
311
if self.properties["ApprovedByDefault"]:
276
message = "Approval in {0}. (d)eny?"
277
else:
278
message = "Denial in {0}. (a)pprove?"
279
message = message.format(str(timer).rsplit(".", 1)[0])
280
self.using_timer(True)
281
elif self.properties["LastCheckerStatus"] != 0:
282
# When checker has failed, show timer until client expires
283
expires = self.properties["Expires"]
284
if expires == "":
285
timer = datetime.timedelta(0)
286
else:
287
expires = (datetime.datetime.strptime
288
(expires, '%Y-%m-%dT%H:%M:%S.%f'))
289
timer = max(expires - datetime.datetime.utcnow(),
290
datetime.timedelta())
312
message = "Approval in %s. (d)eny?"
313
else:
314
message = "Denial in %s. (a)pprove?"
315
message = message % unicode(timer).rsplit(".", 1)[0]
316
elif self.last_checker_failed:
317
timeout = datetime.timedelta(milliseconds
318
= self.properties
319
["Timeout"])
320
last_ok = isoformat_to_datetime(
321
max((self.properties["LastCheckedOK"]
322
or self.properties["Created"]),
323
self.properties["LastEnabled"]))
324
timer = timeout - (datetime.datetime.utcnow() - last_ok)
291
325
message = ('A checker has failed! Time until client'
292
' gets disabled: {0}'
293
.format(str(timer).rsplit(".", 1)[0]))
294
self.using_timer(True)
326
' gets disabled: %s'
327
% unicode(timer).rsplit(".", 1)[0])
295
328
else:
296
329
message = "enabled"
297
self.using_timer(False)
298
self._text = "{0}{1}".format(base, message)
299
330
self._text = "%s%s" % (base, message)
331
300
332
if not urwid.supports_unicode():
301
333
self._text = self._text.encode("ascii", "replace")
302
334
textlist = [("normal", self._text)]
314
346
self.update_hook()
315
347
316
348
def update_timer(self):
317
"""called by gobject. Will indefinitely loop until
318
gobject.source_remove() on tag is called"""
349
"called by gobject"
319
350
self.update()
320
351
return True # Keep calling this
321
352
322
def delete(self, **kwargs):
353
def delete(self, *args, **kwargs):
323
354
if self._update_timer_callback_tag is not None:
324
355
gobject.source_remove(self._update_timer_callback_tag)
325
356
self._update_timer_callback_tag = None
328
359
self.match_objects = ()
329
360
if self.delete_hook is not None:
330
361
self.delete_hook(self)
331
return super(MandosClientWidget, self).delete(**kwargs)
362
return super(MandosClientWidget, self).delete(*args, **kwargs)
332
363
333
364
def render(self, maxcolrow, focus=False):
334
365
"""Render differently if we have focus.
376
407
else:
377
408
return key
378
409
379
def property_changed(self, property=None, **kwargs):
410
def property_changed(self, property=None, value=None,
411
*args, **kwargs):
380
412
"""Call self.update() if old value is not new value.
381
413
This overrides the method from MandosClientPropertyCache"""
382
property_name = str(property)
414
property_name = unicode(property)
383
415
old_value = self.properties.get(property_name)
384
416
super(MandosClientWidget, self).property_changed(
385
property=property, **kwargs)
417
property=property, value=value, *args, **kwargs)
386
418
if self.properties.get(property_name) != old_value:
387
419
self.update()
388
420
392
424
"down" key presses, thus not allowing any containing widgets to
393
425
use them as an excuse to shift focus away from this widget.
394
426
"""
395
def keypress(self, *args, **kwargs):
396
ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)
427
def keypress(self, maxcolrow, key):
428
ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)
397
429
if ret in ("up", "down"):
398
430
return
399
431
return ret
412
444
("normal",
413
445
"default", "default", None),
414
446
("bold",
415
"bold", "default", "bold"),
447
"default", "default", "bold"),
416
448
("underline-blink",
417
"underline,blink", "default", "underline,blink"),
449
"default", "default", "underline"),
418
450
("standout",
419
"standout", "default", "standout"),
451
"default", "default", "standout"),
420
452
("bold-underline-blink",
421
"bold,underline,blink", "default", "bold,underline,blink"),
453
"default", "default", ("bold", "underline")),
422
454
("bold-standout",
423
"bold,standout", "default", "bold,standout"),
455
"default", "default", ("bold", "standout")),
424
456
("underline-blink-standout",
425
"underline,blink,standout", "default",
426
"underline,blink,standout"),
457
"default", "default", ("underline", "standout")),
427
458
("bold-underline-blink-standout",
428
"bold,underline,blink,standout", "default",
429
"bold,underline,blink,standout"),
459
"default", "default", ("bold", "underline",
460
"standout")),
430
461
))
431
462
432
463
if urwid.supports_unicode():
464
495
465
496
self.busname = domain + '.Mandos'
466
497
self.main_loop = gobject.MainLoop()
498
self.bus = dbus.SystemBus()
499
mandos_dbus_objc = self.bus.get_object(
500
self.busname, "/", follow_name_owner_changes=True)
501
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
502
dbus_interface
503
= server_interface)
504
try:
505
mandos_clients = (self.mandos_serv
506
.GetAllClientsWithProperties())
507
except dbus.exceptions.DBusException:
508
mandos_clients = dbus.Dictionary()
509
510
(self.mandos_serv
511
.connect_to_signal("ClientRemoved",
512
self.find_and_remove_client,
513
dbus_interface=server_interface,
514
byte_arrays=True))
515
(self.mandos_serv
516
.connect_to_signal("ClientAdded",
517
self.add_new_client,
518
dbus_interface=server_interface,
519
byte_arrays=True))
520
(self.mandos_serv
521
.connect_to_signal("ClientNotFound",
522
self.client_not_found,
523
dbus_interface=server_interface,
524
byte_arrays=True))
525
for path, client in mandos_clients.iteritems():
526
client_proxy_object = self.bus.get_object(self.busname,
527
path)
528
self.add_client(MandosClientWidget(server_proxy_object
529
=self.mandos_serv,
530
proxy_object
531
=client_proxy_object,
532
properties=client,
533
update_hook
534
=self.refresh,
535
delete_hook
536
=self.remove_client,
537
logger
538
=self.log_message),
539
path=path)
467
540
468
541
def client_not_found(self, fingerprint, address):
469
self.log_message("Client with address {0} and fingerprint"
470
" {1} could not be found"
471
.format(address, fingerprint))
542
self.log_message(("Client with address %s and fingerprint %s"
543
" could not be found" % (address,
544
fingerprint)))
472
545
473
546
def rebuild(self):
474
547
"""This rebuilds the User Interface.
484
557
self.divider)))
485
558
if self.log_visible:
486
559
self.uilist.append(self.logbox)
560
pass
487
561
self.topwidget = urwid.Pile(self.uilist)
488
562
489
563
def log_message(self, message):
490
"""Log message formatted with timestamp"""
491
564
timestamp = datetime.datetime.now().isoformat()
492
565
self.log_message_raw(timestamp + ": " + message)
493
566
506
579
self.log_visible = not self.log_visible
507
580
self.rebuild()
508
581
#self.log_message("Log visibility changed to: "
509
# + str(self.log_visible))
582
# + unicode(self.log_visible))
510
583
511
584
def change_log_display(self):
512
585
"""Change type of log display.
528
601
client = self.clients_dict[path]
529
602
except KeyError:
530
603
# not found?
531
self.log_message("Unknown client {0!r} ({1!r}) removed"
532
.format(name, path))
604
self.log_message("Unknown client %r (%r) removed", name,
605
path)
533
606
return
534
607
client.delete()
535
608
552
625
if path is None:
553
626
path = client.proxy.object_path
554
627
self.clients_dict[path] = client
555
self.clients.sort(key=lambda c: c.properties["Name"])
628
self.clients.sort(None, lambda c: c.properties["Name"])
556
629
self.refresh()
557
630
558
631
def remove_client(self, client, path=None):
560
633
if path is None:
561
634
path = client.proxy.object_path
562
635
del self.clients_dict[path]
636
if not self.clients_dict:
637
# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker
638
# is completely emptied, we need to recreate it.
639
self.clients = urwid.SimpleListWalker([])
640
self.rebuild()
563
641
self.refresh()
564
642
565
643
def refresh(self):
569
647
570
648
def run(self):
571
649
"""Start the main loop and exit when it's done."""
572
self.bus = dbus.SystemBus()
573
mandos_dbus_objc = self.bus.get_object(
574
self.busname, "/", follow_name_owner_changes=True)
575
self.mandos_serv = dbus.Interface(mandos_dbus_objc,
576
dbus_interface
577
= server_interface)
578
try:
579
mandos_clients = (self.mandos_serv
580
.GetAllClientsWithProperties())
581
if not mandos_clients:
582
self.log_message_raw(("bold", "Note: Server has no clients."))
583
except dbus.exceptions.DBusException:
584
self.log_message_raw(("bold", "Note: No Mandos server running."))
585
mandos_clients = dbus.Dictionary()
586
587
(self.mandos_serv
588
.connect_to_signal("ClientRemoved",
589
self.find_and_remove_client,
590
dbus_interface=server_interface,
591
byte_arrays=True))
592
(self.mandos_serv
593
.connect_to_signal("ClientAdded",
594
self.add_new_client,
595
dbus_interface=server_interface,
596
byte_arrays=True))
597
(self.mandos_serv
598
.connect_to_signal("ClientNotFound",
599
self.client_not_found,
600
dbus_interface=server_interface,
601
byte_arrays=True))
602
for path, client in mandos_clients.items():
603
client_proxy_object = self.bus.get_object(self.busname,
604
path)
605
self.add_client(MandosClientWidget(server_proxy_object
606
=self.mandos_serv,
607
proxy_object
608
=client_proxy_object,
609
properties=client,
610
update_hook
611
=self.refresh,
612
delete_hook
613
=self.remove_client,
614
logger
615
=self.log_message),
616
path=path)
617
618
650
self.refresh()
619
651
self._input_callback_tag = (gobject.io_add_watch
620
652
(sys.stdin.fileno(),
717
749
ui.run()
718
750
except KeyboardInterrupt:
719
751
ui.screen.stop()
720
except Exception as e:
721
ui.log_message(str(e))
752
except Exception, e:
753
ui.log_message(unicode(e))
722
754
ui.screen.stop()
723
755
raise
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0