/mandos/trunk : revision 237.4.1

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

6

7

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

11

# the Free Software Foundation, either version 3 of the License, or

12

# (at your option) any later version.

13

#

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.

18

#

19

# You should have received a copy of the GNU General Public License

20

# along with this program. If not, see <http://www.gnu.org/licenses/>.

21

#

22

# Contact the authors at <mandos@fukt.bsnet.se>.

23

#

24

25

from __future__ import division, absolute_import, with_statement

26

27

import sys

28

import os

29

import signal

30

31

import datetime

32

33

import urwid.curses_display

34

import urwid

35

36

from dbus.mainloop.glib import DBusGMainLoop

37

import gobject

38

39

import dbus

40

41

import UserList

42

43

import locale

44

45

locale.setlocale(locale.LC_ALL, u'')

46

47

import logging

48

logging.getLogger('dbus.proxies').setLevel(logging.CRITICAL)

49

50

# Some useful constants

51

domain = 'se.bsnet.fukt'

52

server_interface = domain + '.Mandos'

53

client_interface = domain + '.Mandos.Client'

54

version = "1.0.15"

55

56

# Always run in monochrome mode

57

urwid.curses_display.curses.has_colors = lambda : False

58

59

# Urwid doesn't support blinking, but we want it. Since we have no

60

# use for underline on its own, we make underline also always blink.

61

urwid.curses_display.curses.A_UNDERLINE |= (

62

urwid.curses_display.curses.A_BLINK)

63

64

def isoformat_to_datetime(iso):

65

"Parse an ISO 8601 date string to a datetime.datetime()"

66

if not iso:

67

return None

68

d, t = iso.split(u"T", 1)

69

year, month, day = d.split(u"-", 2)

70

hour, minute, second = t.split(u":", 2)

71

second, fraction = divmod(float(second), 1)

72

return datetime.datetime(int(year),

73

int(month),

74

int(day),

75

int(hour),

76

int(minute),

77

int(second), # Whole seconds

78

int(fraction*1000000)) # Microseconds

79

80

class MandosClientPropertyCache(object):

81

"""This wraps a Mandos Client D-Bus proxy object, caches the

82

properties and calls a hook function when any of them are

83

changed.

84

"""

85

def __init__(self, proxy_object=None, *args, **kwargs):

86

self.proxy = proxy_object # Mandos Client proxy object

87

88

self.properties = dict()

89

self.proxy.connect_to_signal(u"PropertyChanged",

90

self.property_changed,

91

client_interface,

92

byte_arrays=True)

93

94

self.properties.update(

95

self.proxy.GetAll(client_interface,

96

dbus_interface = dbus.PROPERTIES_IFACE))

97

98

#XXX This break good super behaviour!

99

# super(MandosClientPropertyCache, self).__init__(

100

# *args, **kwargs)

101

102

def property_changed(self, property=None, value=None):

103

"""This is called whenever we get a PropertyChanged signal

104

It updates the changed property in the "properties" dict.

105

"""

106

# Update properties dict with new value

107

self.properties[property] = value

108

109

110

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

111

"""A Mandos Client which is visible on the screen.

112

"""

113

114

def __init__(self, server_proxy_object=None, update_hook=None,

115

delete_hook=None, logger=None, *args, **kwargs):

116

# Called on update

117

self.update_hook = update_hook

118

# Called on delete

119

self.delete_hook = delete_hook

120

# Mandos Server proxy object

121

self.server_proxy_object = server_proxy_object

122

# Logger

123

self.logger = logger

124

125

self._update_timer_callback_tag = None

126

self._update_timer_callback_lock = 0

127

self.last_checker_failed = False

128

129

# The widget shown normally

130

self._text_widget = urwid.Text(u"")

131

# The widget shown when we have focus

132

self._focus_text_widget = urwid.Text(u"")

133

super(MandosClientWidget, self).__init__(

134

update_hook=update_hook, delete_hook=delete_hook,

135

*args, **kwargs)

136

self.update()

137

self.opened = False

138

139

last_checked_ok = isoformat_to_datetime(self.properties

140

[u"LastCheckedOK"])

141

if last_checked_ok is None:

142

self.last_checker_failed = True

143

else:

144

self.last_checker_failed = ((datetime.datetime.utcnow()

145

- last_checked_ok)

146

> datetime.timedelta

147

(milliseconds=

148

self.properties

149

[u"Interval"]))

150

151

if self.last_checker_failed:

152

self.using_timer(True)

153

154

if self.need_approval:

155

self.using_timer(True)

156

157

self.proxy.connect_to_signal(u"CheckerCompleted",

158

self.checker_completed,

159

client_interface,

160

byte_arrays=True)

161

self.proxy.connect_to_signal(u"CheckerStarted",

162

self.checker_started,

163

client_interface,

164

byte_arrays=True)

165

self.proxy.connect_to_signal(u"GotSecret",

166

self.got_secret,

167

client_interface,

168

byte_arrays=True)

169

self.proxy.connect_to_signal(u"NeedApproval",

170

self.need_approval,

171

client_interface,

172

byte_arrays=True)

173

self.proxy.connect_to_signal(u"Rejected",

174

self.rejected,

175

client_interface,

176

byte_arrays=True)

177

178

def property_changed(self, property=None, value=None):

179

super(self, MandosClientWidget).property_changed(property,

180

value)

181

if property == u"ApprovalPending":

182

using_timer(bool(value))

183

184

def using_timer(self, flag):

185

"""Call this method with True or False when timer should be

186

activated or deactivated.

187

"""

188

old = self._update_timer_callback_lock

189

if flag:

190

self._update_timer_callback_lock += 1

191

else:

192

self._update_timer_callback_lock -= 1

193

if old == 0 and self._update_timer_callback_lock:

194

self._update_timer_callback_tag = (gobject.timeout_add

195

(1000,

196

self.update_timer))

197

elif old and self._update_timer_callback_lock == 0:

198

gobject.source_remove(self._update_timer_callback_tag)

199

self._update_timer_callback_tag = None

200

201

def checker_completed(self, exitstatus, condition, command):

202

if exitstatus == 0:

203

if self.last_checker_failed:

204

self.last_checker_failed = False

205

self.using_timer(False)

206

#self.logger(u'Checker for client %s (command "%s")'

207

# u' was successful'

208

# % (self.properties[u"Name"], command))

209

self.update()

210

return

211

# Checker failed

212

if not self.last_checker_failed:

213

self.last_checker_failed = True

214

self.using_timer(True)

215

if os.WIFEXITED(condition):

216

self.logger(u'Checker for client %s (command "%s")'

217

u' failed with exit code %s'

218

% (self.properties[u"Name"], command,

219

os.WEXITSTATUS(condition)))

220

elif os.WIFSIGNALED(condition):

221

self.logger(u'Checker for client %s (command "%s")'

222

u' was killed by signal %s'

223

% (self.properties[u"Name"], command,

224

os.WTERMSIG(condition)))

225

elif os.WCOREDUMP(condition):

226

self.logger(u'Checker for client %s (command "%s")'

227

u' dumped core'

228

% (self.properties[u"Name"], command))

229

else:

230

self.logger(u'Checker for client %s completed'

231

u' mysteriously')

232

self.update()

233

234

def checker_started(self, command):

235

#self.logger(u'Client %s started checker "%s"'

236

# % (self.properties[u"Name"], unicode(command)))

237

pass

238

239

def got_secret(self):

240

self.last_checker_failed = False

241

self.logger(u'Client %s received its secret'

242

% self.properties[u"Name"])

243

244

def need_approval(self, timeout, default):

245

if not default:

246

message = u'Client %s needs approval within %s seconds'

247

else:

248

message = u'Client %s will get its secret in %s seconds'

249

self.logger(message

250

% (self.properties[u"Name"], timeout/1000))

251

self.using_timer(True)

252

253

def rejected(self, reason):

254

self.logger(u'Client %s was rejected; reason: %s'

255

% (self.properties[u"Name"], reason))

256

257

def selectable(self):

258

"""Make this a "selectable" widget.

259

This overrides the method from urwid.FlowWidget."""

260

return True

261

262

def rows(self, (maxcol,), focus=False):

263

"""How many rows this widget will occupy might depend on

264

whether we have focus or not.

265

This overrides the method from urwid.FlowWidget"""

266

return self.current_widget(focus).rows((maxcol,), focus=focus)

267

268

def current_widget(self, focus=False):

269

if focus or self.opened:

270

return self._focus_widget

271

return self._widget

272

273

def update(self):

274

"Called when what is visible on the screen should be updated."

275

# How to add standout mode to a style

276

with_standout = { u"normal": u"standout",

277

u"bold": u"bold-standout",

278

u"underline-blink":

279

u"underline-blink-standout",

280

u"bold-underline-blink":

281

u"bold-underline-blink-standout",

282

}

283

284

# Rebuild focus and non-focus widgets using current properties

285

286

# Base part of a client. Name!

287

base = (u'%(name)s: '

288

% {u"name": self.properties[u"Name"]})

289

if not self.properties[u"Enabled"]:

290

message = u"DISABLED"

291

elif self.properties[u"ApprovalPending"]:

292

timeout = datetime.timedelta(milliseconds

293

= self.properties

294

[u"ApprovalDelay"])

295

last_approval_request = isoformat_to_datetime(

296

self.properties[u"LastApprovalRequest"])

297

if last_approval_request is not None:

298

timer = timeout - (datetime.datetime.utcnow()

299

- last_approval_request)

300

else:

301

timer = datetime.timedelta()

302

if self.properties[u"ApprovedByDefault"]:

303

message = u"Approval in %s. (d)eny?"

304

else:

305

message = u"Denial in %s. (a)pprove?"

306

message = message % unicode(timer).rsplit(".", 1)[0]

307

elif self.last_checker_failed:

308

timeout = datetime.timedelta(milliseconds

309

= self.properties

310

[u"Timeout"])

311

last_ok = isoformat_to_datetime(

312

max((self.properties[u"LastCheckedOK"]

313

or self.properties[u"Created"]),

314

self.properties[u"LastEnabled"]))

315

timer = timeout - (datetime.datetime.utcnow() - last_ok)

316

message = (u'A checker has failed! Time until client'

317

u' gets disabled: %s'

318

% unicode(timer).rsplit(".", 1)[0])

319

else:

320

message = u"enabled"

321

self._text = "%s%s" % (base, message)

322

323

if not urwid.supports_unicode():

324

self._text = self._text.encode("ascii", "replace")

325

textlist = [(u"normal", self._text)]

326

self._text_widget.set_text(textlist)

327

self._focus_text_widget.set_text([(with_standout[text[0]],

328

text[1])

329

if isinstance(text, tuple)

330

else text

331

for text in textlist])

332

self._widget = self._text_widget

333

self._focus_widget = urwid.AttrWrap(self._focus_text_widget,

334

"standout")

335

# Run update hook, if any

336

if self.update_hook is not None:

337

self.update_hook()

338

339

def update_timer(self):

340

"called by gobject"

341

self.update()

342

return True # Keep calling this

343

344

def delete(self):

345

if self._update_timer_callback_tag is not None:

346

gobject.source_remove(self._update_timer_callback_tag)

347

self._update_timer_callback_tag = None

348

if self.delete_hook is not None:

349

self.delete_hook(self)

350

351

def render(self, (maxcol,), focus=False):

352

"""Render differently if we have focus.

353

This overrides the method from urwid.FlowWidget"""

354

return self.current_widget(focus).render((maxcol,),

355

focus=focus)

356

357

def keypress(self, (maxcol,), key):

358

"""Handle keys.

359

This overrides the method from urwid.FlowWidget"""

360

if key == u"+":

361

self.proxy.Enable(dbus_interface = client_interface)

362

elif key == u"-":

363

self.proxy.Disable(dbus_interface = client_interface)

364

elif key == u"a":

365

self.proxy.Approve(dbus.Boolean(True, variant_level=1),

366

dbus_interface = client_interface)

367

elif key == u"d":

368

self.proxy.Approve(dbus.Boolean(False, variant_level=1),

369

dbus_interface = client_interface)

370

elif key == u"R" or key == u"_" or key == u"ctrl k":

371

self.server_proxy_object.RemoveClient(self.proxy

372

.object_path)

373

elif key == u"s":

374

self.proxy.StartChecker(dbus_interface = client_interface)

375

elif key == u"S":

376

self.proxy.StopChecker(dbus_interface = client_interface)

377

elif key == u"C":

378

self.proxy.CheckedOK(dbus_interface = client_interface)

379

# xxx

380

# elif key == u"p" or key == "=":

381

# self.proxy.pause()

382

# elif key == u"u" or key == ":":

383

# self.proxy.unpause()

384

# elif key == u"RET":

385

# self.open()

386

else:

387

return key

388

389

def property_changed(self, property=None, value=None,

390

*args, **kwargs):

391

"""Call self.update() if old value is not new value.

392

This overrides the method from MandosClientPropertyCache"""

393

property_name = unicode(property)

394

old_value = self.properties.get(property_name)

395

super(MandosClientWidget, self).property_changed(

396

property=property, value=value, *args, **kwargs)

397

if self.properties.get(property_name) != old_value:

398

self.update()

399

400

401

class ConstrainedListBox(urwid.ListBox):

402

"""Like a normal urwid.ListBox, but will consume all "up" or

403

"down" key presses, thus not allowing any containing widgets to

404

use them as an excuse to shift focus away from this widget.

405

"""

406

def keypress(self, (maxcol, maxrow), key):

407

ret = super(ConstrainedListBox, self).keypress((maxcol,

408

maxrow), key)

409

if ret in (u"up", u"down"):

410

return

411

return ret

412

413

414

class UserInterface(object):

415

"""This is the entire user interface - the whole screen

416

with boxes, lists of client widgets, etc.

417

"""

418

def __init__(self, max_log_length=1000):

419

DBusGMainLoop(set_as_default=True)

420

421

self.screen = urwid.curses_display.Screen()

422

423

self.screen.register_palette((

424

(u"normal",

425

u"default", u"default", None),

426

(u"bold",

427

u"default", u"default", u"bold"),

428

(u"underline-blink",

429

u"default", u"default", u"underline"),

430

(u"standout",

431

u"default", u"default", u"standout"),

432

(u"bold-underline-blink",

433

u"default", u"default", (u"bold", u"underline")),

434

(u"bold-standout",

435

u"default", u"default", (u"bold", u"standout")),

436

(u"underline-blink-standout",

437

u"default", u"default", (u"underline", u"standout")),

438

(u"bold-underline-blink-standout",

439

u"default", u"default", (u"bold", u"underline",

440

u"standout")),

441

))

442

443

if urwid.supports_unicode():

444

self.divider = u"─" # \u2500

445

#self.divider = u"━" # \u2501

446

else:

447

#self.divider = u"-" # \u002d

448

self.divider = u"_" # \u005f

449

450

self.screen.start()

451

452

self.size = self.screen.get_cols_rows()

453

454

self.clients = urwid.SimpleListWalker([])

455

self.clients_dict = {}

456

457

# We will add Text widgets to this list

458

self.log = []

459

self.max_log_length = max_log_length

460

461

# We keep a reference to the log widget so we can remove it

462

# from the ListWalker without it getting destroyed

463

self.logbox = ConstrainedListBox(self.log)

464

465

# This keeps track of whether self.uilist currently has

466

# self.logbox in it or not

467

self.log_visible = True

468

self.log_wrap = u"any"

469

470

self.rebuild()

471

self.log_message_raw((u"bold",

472

u"Mandos Monitor version " + version))

473

self.log_message_raw((u"bold",

474

u"q: Quit ?: Help"))

475

476

self.busname = domain + '.Mandos'

477

self.main_loop = gobject.MainLoop()

478

self.bus = dbus.SystemBus()

479

mandos_dbus_objc = self.bus.get_object(

480

self.busname, u"/", follow_name_owner_changes=True)

481

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

482

dbus_interface

483

= server_interface)

484

try:

485

mandos_clients = (self.mandos_serv

486

.GetAllClientsWithProperties())

487

except dbus.exceptions.DBusException:

488

mandos_clients = dbus.Dictionary()

489

490

(self.mandos_serv

491

.connect_to_signal(u"ClientRemoved",

492

self.find_and_remove_client,

493

dbus_interface=server_interface,

494

byte_arrays=True))

495

(self.mandos_serv

496

.connect_to_signal(u"ClientAdded",

497

self.add_new_client,

498

dbus_interface=server_interface,

499

byte_arrays=True))

500

(self.mandos_serv

501

.connect_to_signal(u"ClientNotFound",

502

self.client_not_found,

503

dbus_interface=server_interface,

504

byte_arrays=True))

505

for path, client in mandos_clients.iteritems():

506

client_proxy_object = self.bus.get_object(self.busname,

507

path)

508

self.add_client(MandosClientWidget(server_proxy_object

509

=self.mandos_serv,

510

proxy_object

511

=client_proxy_object,

512

properties=client,

513

update_hook

514

=self.refresh,

515

delete_hook

516

=self.remove_client,

517

logger

518

=self.log_message),

519

path=path)

520

521

def client_not_found(self, fingerprint, address):

522

self.log_message((u"Client with address %s and fingerprint %s"

523

u" could not be found" % (address,

524

fingerprint)))

525

526

def rebuild(self):

527

"""This rebuilds the User Interface.

528

Call this when the widget layout needs to change"""

529

self.uilist = []

530

#self.uilist.append(urwid.ListBox(self.clients))

531

self.uilist.append(urwid.Frame(ConstrainedListBox(self.

532

clients),

533

#header=urwid.Divider(),

534

header=None,

535

footer=

536

urwid.Divider(div_char=

537

self.divider)))

538

if self.log_visible:

539

self.uilist.append(self.logbox)

540

pass

541

self.topwidget = urwid.Pile(self.uilist)

542

543

def log_message(self, message):

544

timestamp = datetime.datetime.now().isoformat()

545

self.log_message_raw(timestamp + u": " + message)

546

547

def log_message_raw(self, markup):

548

"""Add a log message to the log buffer."""

549

self.log.append(urwid.Text(markup, wrap=self.log_wrap))

550

if (self.max_log_length

551

and len(self.log) > self.max_log_length):

552

del self.log[0:len(self.log)-self.max_log_length-1]

553

self.logbox.set_focus(len(self.logbox.body.contents),

554

coming_from=u"above")

555

self.refresh()

556

557

def toggle_log_display(self):

558

"""Toggle visibility of the log buffer."""

559

self.log_visible = not self.log_visible

560

self.rebuild()

561

#self.log_message(u"Log visibility changed to: "

562

# + unicode(self.log_visible))

563

564

def change_log_display(self):

565

"""Change type of log display.

566

Currently, this toggles wrapping of text lines."""

567

if self.log_wrap == u"clip":

568

self.log_wrap = u"any"

569

else:

570

self.log_wrap = u"clip"

571

for textwidget in self.log:

572

textwidget.set_wrap_mode(self.log_wrap)

573

#self.log_message(u"Wrap mode: " + self.log_wrap)

574

575

def find_and_remove_client(self, path, name):

576

"""Find an client from its object path and remove it.

577

578

This is connected to the ClientRemoved signal from the

579

Mandos server object."""

580

try:

581

client = self.clients_dict[path]

582

except KeyError:

583

# not found?

584

return

585

self.remove_client(client, path)

586

587

def add_new_client(self, path):

588

client_proxy_object = self.bus.get_object(self.busname, path)

589

self.add_client(MandosClientWidget(server_proxy_object

590

=self.mandos_serv,

591

proxy_object

592

=client_proxy_object,

593

update_hook

594

=self.refresh,

595

delete_hook

596

=self.remove_client,

597

logger

598

=self.log_message),

599

path=path)

600

601

def add_client(self, client, path=None):

602

self.clients.append(client)

603

if path is None:

604

path = client.proxy.object_path

605

self.clients_dict[path] = client

606

self.clients.sort(None, lambda c: c.properties[u"Name"])

607

self.refresh()

608

609

def remove_client(self, client, path=None):

610

self.clients.remove(client)

611

if path is None:

612

path = client.proxy.object_path

613

del self.clients_dict[path]

614

if not self.clients_dict:

615

# Work around bug in Urwid 0.9.8.3 - if a SimpleListWalker

616

# is completely emptied, we need to recreate it.

617

self.clients = urwid.SimpleListWalker([])

618

self.rebuild()

619

self.refresh()

620

621

def refresh(self):

622

"""Redraw the screen"""

623

canvas = self.topwidget.render(self.size, focus=True)

624

self.screen.draw_screen(self.size, canvas)

625

626

def run(self):

627

"""Start the main loop and exit when it's done."""

628

self.refresh()

629

self._input_callback_tag = (gobject.io_add_watch

630

(sys.stdin.fileno(),

631

gobject.IO_IN,

632

self.process_input))

633

self.main_loop.run()

634

# Main loop has finished, we should close everything now

635

gobject.source_remove(self._input_callback_tag)

636

self.screen.stop()

637

638

def stop(self):

639

self.main_loop.quit()

640

641

def process_input(self, source, condition):

642

keys = self.screen.get_input()

643

translations = { u"ctrl n": u"down", # Emacs

644

u"ctrl p": u"up", # Emacs

645

u"ctrl v": u"page down", # Emacs

646

u"meta v": u"page up", # Emacs

647

u" ": u"page down", # less

648

u"f": u"page down", # less

649

u"b": u"page up", # less

650

u"j": u"down", # vi

651

u"k": u"up", # vi

652

}

653

for key in keys:

654

try:

655

key = translations[key]

656

except KeyError: # :-)

657

pass

658

659

if key == u"q" or key == u"Q":

660

self.stop()

661

break

662

elif key == u"window resize":

663

self.size = self.screen.get_cols_rows()

664

self.refresh()

665

elif key == u"\f": # Ctrl-L

666

self.refresh()

667

elif key == u"l" or key == u"D":

668

self.toggle_log_display()

669

self.refresh()

670

elif key == u"w" or key == u"i":

671

self.change_log_display()

672

self.refresh()

673

elif key == u"?" or key == u"f1" or key == u"esc":

674

if not self.log_visible:

675

self.log_visible = True

676

self.rebuild()

677

self.log_message_raw((u"bold",

678

u" ".

679

join((u"q: Quit",

680

u"?: Help",

681

u"l: Log window toggle",

682

u"TAB: Switch window",

683

u"w: Wrap (log)"))))

684

self.log_message_raw((u"bold",

685

u" "

686

.join((u"Clients:",

687

u"+: Enable",

688

u"-: Disable",

689

u"R: Remove",

690

u"s: Start new checker",

691

u"S: Stop checker",

692

u"C: Checker OK",

693

u"a: Approve",

694

u"d: Deny"))))

695

self.refresh()

696

elif key == u"tab":

697

if self.topwidget.get_focus() is self.logbox:

698

self.topwidget.set_focus(0)

699

else:

700

self.topwidget.set_focus(self.logbox)

701

self.refresh()

702

#elif (key == u"end" or key == u"meta >" or key == u"G"

703

# or key == u">"):

704

# pass # xxx end-of-buffer

705

#elif (key == u"home" or key == u"meta <" or key == u"g"

706

# or key == u"<"):

707

# pass # xxx beginning-of-buffer

708

#elif key == u"ctrl e" or key == u"$":

709

# pass # xxx move-end-of-line

710

#elif key == u"ctrl a" or key == u"^":

711

# pass # xxx move-beginning-of-line

712

#elif key == u"ctrl b" or key == u"meta (" or key == u"h":

713

# pass # xxx left

714

#elif key == u"ctrl f" or key == u"meta )" or key == u"l":

715

# pass # xxx right

716

#elif key == u"a":

717

# pass # scroll up log

718

#elif key == u"z":

719

# pass # scroll down log

720

elif self.topwidget.selectable():

721

self.topwidget.keypress(self.size, key)

722

self.refresh()

723

return True

724

725

ui = UserInterface()

726

try:

727

ui.run()

728

except KeyboardInterrupt:

729

ui.screen.stop()

730

except Exception, e:

731

ui.log_message(unicode(e))

732

ui.screen.stop()

733

raise