/mandos/trunk : revision 376

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, print_function,

26

unicode_literals)

27

28

import sys

29

import os

30

import signal

31

32

import datetime

33

34

import urwid.curses_display

35

import urwid

36

37

from dbus.mainloop.glib import DBusGMainLoop

38

import gobject

39

40

import dbus

41

42

import UserList

43

44

import locale

45

46

locale.setlocale(locale.LC_ALL, '')

47

48

import logging

49

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

50

51

# Some useful constants

52

domain = 'se.bsnet.fukt'

53

server_interface = domain + '.Mandos'

54

client_interface = domain + '.Mandos.Client'

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

65

def isoformat_to_datetime(iso):

66

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

67

if not iso:

68

return None

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),

74

int(month),

75

int(day),

76

int(hour),

77

int(minute),

78

int(second), # Whole seconds

79

int(fraction*1000000)) # Microseconds

80

81

class MandosClientPropertyCache(object):

82

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

83

properties and calls a hook function when any of them are

84

changed.

85

"""

86

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

87

self.proxy = proxy_object # Mandos Client proxy object

88

89

self.properties = dict()

90

self.property_changed_match = (

91

self.proxy.connect_to_signal("PropertyChanged",

92

self.property_changed,

93

client_interface,

94

byte_arrays=True))

95

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)

103

104

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

105

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

106

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

107

"""

108

# Update properties dict with new value

109

self.properties[property] = value

110

111

def delete(self, *args, **kwargs):

112

self.property_changed_match.remove()

113

super(MandosClientPropertyCache, self).__init__(

114

*args, **kwargs)

115

116

117

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

118

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

119

"""

120

121

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

122

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

123

# Called on update

124

self.update_hook = update_hook

125

# Called on delete

126

self.delete_hook = delete_hook

127

# Mandos Server proxy object

128

self.server_proxy_object = server_proxy_object

129

# Logger

130

self.logger = logger

131

132

self._update_timer_callback_tag = None

133

self._update_timer_callback_lock = 0

134

self.last_checker_failed = False

135

136

# The widget shown normally

137

self._text_widget = urwid.Text("")

138

# The widget shown when we have focus

139

self._focus_text_widget = urwid.Text("")

140

super(MandosClientWidget, self).__init__(

141

update_hook=update_hook, delete_hook=delete_hook,

142

*args, **kwargs)

143

self.update()

144

self.opened = False

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

164

self.match_objects = (

165

self.proxy.connect_to_signal("CheckerCompleted",

166

self.checker_completed,

167

client_interface,

168

byte_arrays=True),

169

self.proxy.connect_to_signal("CheckerStarted",

170

self.checker_started,

171

client_interface,

172

byte_arrays=True),

173

self.proxy.connect_to_signal("GotSecret",

174

self.got_secret,

175

client_interface,

176

byte_arrays=True),

177

self.proxy.connect_to_signal("NeedApproval",

178

self.need_approval,

179

client_interface,

180

byte_arrays=True),

181

self.proxy.connect_to_signal("Rejected",

182

self.rejected,

183

client_interface,

184

byte_arrays=True))

185

#self.logger('Created client %s' % (self.properties["Name"]))

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

193

def using_timer(self, flag):

194

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

195

activated or deactivated.

196

"""

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:

203

self._update_timer_callback_tag = (gobject.timeout_add

204

(1000,

205

self.update_timer))

206

elif old and self._update_timer_callback_lock == 0:

207

gobject.source_remove(self._update_timer_callback_tag)

208

self._update_timer_callback_tag = None

209

210

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

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))

218

self.update()

219

return

220

# Checker failed

221

if not self.last_checker_failed:

222

self.last_checker_failed = True

223

self.using_timer(True)

224

if os.WIFEXITED(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)))

229

elif os.WIFSIGNALED(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)))

234

elif os.WCOREDUMP(condition):

235

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

236

' dumped core'

237

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

238

else:

239

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

240

' mysteriously')

241

self.update()

242

243

def checker_started(self, command):

244

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

245

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

246

pass

247

248

def got_secret(self):

249

self.last_checker_failed = False

250

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

251

% self.properties["Name"])

252

253

def need_approval(self, timeout, default):

254

if not default:

255

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

256

else:

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)

261

262

def rejected(self, reason):

263

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

264

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

265

266

def selectable(self):

267

"""Make this a "selectable" widget.

268

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

269

return True

270

271

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

272

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

273

whether we have focus or not.

274

This overrides the method from urwid.FlowWidget"""

275

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

276

277

def current_widget(self, focus=False):

278

if focus or self.opened:

279

return self._focus_widget

280

return self._widget

281

282

def update(self):

283

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

284

# How to add standout mode to a style

285

with_standout = { "normal": "standout",

286

"bold": "bold-standout",

287

"underline-blink":

288

"underline-blink-standout",

289

"bold-underline-blink":

290

"bold-underline-blink-standout",

291

}

292

293

# Rebuild focus and non-focus widgets using current properties

294

295

# Base part of a client. Name!

296

base = ('%(name)s: '

297

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

298

if not self.properties["Enabled"]:

299

message = "DISABLED"

300

elif self.properties["ApprovalPending"]:

301

timeout = datetime.timedelta(milliseconds

302

= self.properties

303

["ApprovalDelay"])

304

last_approval_request = isoformat_to_datetime(

305

self.properties["LastApprovalRequest"])

306

if last_approval_request is not None:

307

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

308

- last_approval_request)

309

else:

310

timer = datetime.timedelta()

311

if self.properties["ApprovedByDefault"]:

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)

325

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

326

' gets disabled: %s'

327

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

328

else:

329

message = "enabled"

330

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

331

332

if not urwid.supports_unicode():

333

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

334

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

335

self._text_widget.set_text(textlist)

336

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

337

text[1])

338

if isinstance(text, tuple)

339

else text

340

for text in textlist])

341

self._widget = self._text_widget

342

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

343

"standout")

344

# Run update hook, if any

345

if self.update_hook is not None:

346

self.update_hook()

347

348

def update_timer(self):

349

"called by gobject"

350

self.update()

351

return True # Keep calling this

352

353

def delete(self, *args, **kwargs):

354

if self._update_timer_callback_tag is not None:

355

gobject.source_remove(self._update_timer_callback_tag)

356

self._update_timer_callback_tag = None

357

for match in self.match_objects:

358

match.remove()

359

self.match_objects = ()

360

if self.delete_hook is not None:

361

self.delete_hook(self)

362

return super(MandosClientWidget, self).delete(*args, **kwargs)

363

364

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

365

"""Render differently if we have focus.

366

This overrides the method from urwid.FlowWidget"""

367

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

368

focus=focus)

369

370

def keypress(self, maxcolrow, key):

371

"""Handle keys.

372

This overrides the method from urwid.FlowWidget"""

373

if key == "+":

374

self.proxy.Enable(dbus_interface = client_interface,

375

ignore_reply=True)

376

elif key == "-":

377

self.proxy.Disable(dbus_interface = client_interface,

378

ignore_reply=True)

379

elif key == "a":

380

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

381

dbus_interface = client_interface,

382

ignore_reply=True)

383

elif key == "d":

384

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

385

dbus_interface = client_interface,

386

ignore_reply=True)

387

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

388

self.server_proxy_object.RemoveClient(self.proxy

389

.object_path,

390

ignore_reply=True)

391

elif key == "s":

392

self.proxy.StartChecker(dbus_interface = client_interface,

393

ignore_reply=True)

394

elif key == "S":

395

self.proxy.StopChecker(dbus_interface = client_interface,

396

ignore_reply=True)

397

elif key == "C":

398

self.proxy.CheckedOK(dbus_interface = client_interface,

399

ignore_reply=True)

400

# xxx

401

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

402

# self.proxy.pause()

403

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

404

# self.proxy.unpause()

405

# elif key == "RET":

406

# self.open()

407

else:

408

return key

409

410

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

411

*args, **kwargs):

412

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

413

This overrides the method from MandosClientPropertyCache"""

414

property_name = unicode(property)

415

old_value = self.properties.get(property_name)

416

super(MandosClientWidget, self).property_changed(

417

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

418

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

419

self.update()

420

421

422

class ConstrainedListBox(urwid.ListBox):

423

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

424

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

425

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

426

"""

427

def keypress(self, maxcolrow, key):

428

ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)

429

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

430

return

431

return ret

432

433

434

class UserInterface(object):

435

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

436

with boxes, lists of client widgets, etc.

437

"""

438

def __init__(self, max_log_length=1000):

439

DBusGMainLoop(set_as_default=True)

440

441

self.screen = urwid.curses_display.Screen()

442

443

self.screen.register_palette((

444

("normal",

445

"default", "default", None),

446

("bold",

447

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

448

("underline-blink",

449

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

450

("standout",

451

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

452

("bold-underline-blink",

453

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

454

("bold-standout",

455

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

456

("underline-blink-standout",

457

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

458

("bold-underline-blink-standout",

459

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

460

"standout")),

461

))

462

463

if urwid.supports_unicode():

464

self.divider = "─" # \u2500

465

#self.divider = "━" # \u2501

466

else:

467

#self.divider = "-" # \u002d

468

self.divider = "_" # \u005f

469

470

self.screen.start()

471

472

self.size = self.screen.get_cols_rows()

473

474

self.clients = urwid.SimpleListWalker([])

475

self.clients_dict = {}

476

477

# We will add Text widgets to this list

478

self.log = []

479

self.max_log_length = max_log_length

480

481

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

482

# from the ListWalker without it getting destroyed

483

self.logbox = ConstrainedListBox(self.log)

484

485

# This keeps track of whether self.uilist currently has

486

# self.logbox in it or not

487

self.log_visible = True

488

self.log_wrap = "any"

489

490

self.rebuild()

491

self.log_message_raw(("bold",

492

"Mandos Monitor version " + version))

493

self.log_message_raw(("bold",

494

"q: Quit ?: Help"))

495

496

self.busname = domain + '.Mandos'

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)

540

541

def client_not_found(self, fingerprint, address):

542

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

543

" could not be found" % (address,

544

fingerprint)))

545

546

def rebuild(self):

547

"""This rebuilds the User Interface.

548

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

549

self.uilist = []

550

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

551

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

552

clients),

553

#header=urwid.Divider(),

554

header=None,

555

footer=

556

urwid.Divider(div_char=

557

self.divider)))

558

if self.log_visible:

559

self.uilist.append(self.logbox)

560

pass

561

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

562

563

def log_message(self, message):

564

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

565

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

566

567

def log_message_raw(self, markup):

568

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

569

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

570

if (self.max_log_length

571

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

572

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

573

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

574

coming_from="above")

575

self.refresh()

576

577

def toggle_log_display(self):

578

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

579

self.log_visible = not self.log_visible

580

self.rebuild()

581

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

582

# + unicode(self.log_visible))

583

584

def change_log_display(self):

585

"""Change type of log display.

586

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

587

if self.log_wrap == "clip":

588

self.log_wrap = "any"

589

else:

590

self.log_wrap = "clip"

591

for textwidget in self.log:

592

textwidget.set_wrap_mode(self.log_wrap)

593

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

594

595

def find_and_remove_client(self, path, name):

596

"""Find a client by its object path and remove it.

597

598

This is connected to the ClientRemoved signal from the

599

Mandos server object."""

600

try:

601

client = self.clients_dict[path]

602

except KeyError:

603

# not found?

604

self.log_message("Unknown client %r (%r) removed", name,

605

path)

606

return

607

client.delete()

608

609

def add_new_client(self, path):

610

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

611

self.add_client(MandosClientWidget(server_proxy_object

612

=self.mandos_serv,

613

proxy_object

614

=client_proxy_object,

615

update_hook

616

=self.refresh,

617

delete_hook

618

=self.remove_client,

619

logger

620

=self.log_message),

621

path=path)

622

623

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

624

self.clients.append(client)

625

if path is None:

626

path = client.proxy.object_path

627

self.clients_dict[path] = client

628

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

629

self.refresh()

630

631

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

632

self.clients.remove(client)

633

if path is None:

634

path = client.proxy.object_path

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()

641

self.refresh()

642

643

def refresh(self):

644

"""Redraw the screen"""

645

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

646

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

647

648

def run(self):

649

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

650

self.refresh()

651

self._input_callback_tag = (gobject.io_add_watch

652

(sys.stdin.fileno(),

653

gobject.IO_IN,

654

self.process_input))

655

self.main_loop.run()

656

# Main loop has finished, we should close everything now

657

gobject.source_remove(self._input_callback_tag)

658

self.screen.stop()

659

660

def stop(self):

661

self.main_loop.quit()

662

663

def process_input(self, source, condition):

664

keys = self.screen.get_input()

665

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

666

"ctrl p": "up", # Emacs

667

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

668

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

669

" ": "page down", # less

670

"f": "page down", # less

671

"b": "page up", # less

672

"j": "down", # vi

673

"k": "up", # vi

674

}

675

for key in keys:

676

try:

677

key = translations[key]

678

except KeyError: # :-)

679

pass

680

681

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

682

self.stop()

683

break

684

elif key == "window resize":

685

self.size = self.screen.get_cols_rows()

686

self.refresh()

687

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

688

self.refresh()

689

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

690

self.toggle_log_display()

691

self.refresh()

692

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

693

self.change_log_display()

694

self.refresh()

695

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

696

if not self.log_visible:

697

self.log_visible = True

698

self.rebuild()

699

self.log_message_raw(("bold",

700

" ".

701

join(("q: Quit",

702

"?: Help",

703

"l: Log window toggle",

704

"TAB: Switch window",

705

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

706

self.log_message_raw(("bold",

707

" "

708

.join(("Clients:",

709

"+: Enable",

710

"-: Disable",

711

"R: Remove",

712

"s: Start new checker",

713

"S: Stop checker",

714

"C: Checker OK",

715

"a: Approve",

716

"d: Deny"))))

717

self.refresh()

718

elif key == "tab":

719

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

720

self.topwidget.set_focus(0)

721

else:

722

self.topwidget.set_focus(self.logbox)

723

self.refresh()

724

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

725

# or key == ">"):

726

# pass # xxx end-of-buffer

727

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

728

# or key == "<"):

729

# pass # xxx beginning-of-buffer

730

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

731

# pass # xxx move-end-of-line

732

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

733

# pass # xxx move-beginning-of-line

734

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

735

# pass # xxx left

736

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

737

# pass # xxx right

738

#elif key == "a":

739

# pass # scroll up log

740

#elif key == "z":

741

# pass # scroll down log

742

elif self.topwidget.selectable():

743

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

744

self.refresh()

745

return True

746

747

ui = UserInterface()

748

try:

749

ui.run()

750

except KeyboardInterrupt:

751

ui.screen.stop()

752

except Exception, e:

753

ui.log_message(unicode(e))

754

ui.screen.stop()

755

raise