/mandos/trunk : revision 838

1

#!/usr/bin/python

2

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

3

#

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

6

7

8

#

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

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

#

18

#

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/>.

22

#

22

#

23

# Contact the authors at <mandos@recompile.se>.

24

#

24

#

25

26

from __future__ import (division, absolute_import, print_function,

27

unicode_literals)

45

46

import locale

47

48

import logging

49

50

48

if sys.version_info.major == 2:

51

49

str = unicode

52

50

53

51

locale.setlocale(locale.LC_ALL, '')

54

52

53

import logging

55

54

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

56

55

57

56

# Some useful constants

58

57

domain = 'se.recompile'

59

58

server_interface = domain + '.Mandos'

60

59

client_interface = domain + '.Mandos.Client'

61

version = "1.7.15"

60

version = "1.7.6"

62

61

63

62

try:

64

63

dbus.OBJECT_MANAGER_IFACE

65

64

except AttributeError:

66

65

dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"

67

66

68

69

67

def isoformat_to_datetime(iso):

70

68

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

71

69

if not iso:

79

77

int(day),

80

78

int(hour),

81

79

int(minute),

82

int(second), # Whole seconds

83

int(fraction*1000000)) # Microseconds

84

80

int(second), # Whole seconds

81

int(fraction*1000000)) # Microseconds

85

82

86

83

class MandosClientPropertyCache(object):

87

84

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

89

86

changed.

90

87

"""

91

88

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

92

self.proxy = proxy_object # Mandos Client proxy object

89

self.proxy = proxy_object # Mandos Client proxy object

93

90

self.properties = dict() if properties is None else properties

94

91

self.property_changed_match = (

95

92

self.proxy.connect_to_signal("PropertiesChanged",

96

93

self.properties_changed,

97

94

dbus.PROPERTIES_IFACE,

98

95

byte_arrays=True))

99

96

100

97

if properties is None:

101

self.properties.update(self.proxy.GetAll(

102

client_interface,

103

dbus_interface=dbus.PROPERTIES_IFACE))

104

98

self.properties.update(

99

self.proxy.GetAll(client_interface,

100

dbus_interface

101

= dbus.PROPERTIES_IFACE))

102

105

103

super(MandosClientPropertyCache, self).__init__(**kwargs)

106

104

107

105

def properties_changed(self, interface, properties, invalidated):

108

106

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

109

107

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

111

109

# Update properties dict with new value

112

110

if interface == client_interface:

113

111

self.properties.update(properties)

114

112

115

113

def delete(self):

116

114

self.property_changed_match.remove()

117

115

119

117

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

120

118

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

121

119

"""

122

120

123

121

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

124

122

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

125

123

# Called on update

130

128

self.server_proxy_object = server_proxy_object

131

129

# Logger

132

130

self.logger = logger

133

131

134

132

self._update_timer_callback_tag = None

135

133

136

134

# The widget shown normally

137

135

self._text_widget = urwid.Text("")

138

136

# The widget shown when we have focus

140

138

super(MandosClientWidget, self).__init__(**kwargs)

141

139

self.update()

142

140

self.opened = False

143

141

144

142

self.match_objects = (

145

143

self.proxy.connect_to_signal("CheckerCompleted",

146

144

self.checker_completed,

164

162

byte_arrays=True))

165

163

self.logger('Created client {}'

166

164

.format(self.properties["Name"]), level=0)

167

165

168

166

def using_timer(self, flag):

169

167

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

170

168

activated or deactivated.

177

175

elif not (flag or self._update_timer_callback_tag is None):

178

176

GLib.source_remove(self._update_timer_callback_tag)

179

177

self._update_timer_callback_tag = None

180

178

181

179

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

182

180

if exitstatus == 0:

183

181

self.logger('Checker for client {} (command "{}")'

197

195

.format(self.properties["Name"], command,

198

196

os.WTERMSIG(condition)))

199

197

self.update()

200

198

201

199

def checker_started(self, command):

202

200

"""Server signals that a checker started."""

203

201

self.logger('Client {} started checker "{}"'

204

202

.format(self.properties["Name"],

205

203

command), level=0)

206

204

207

205

def got_secret(self):

208

206

self.logger('Client {} received its secret'

209

207

.format(self.properties["Name"]))

210

208

211

209

def need_approval(self, timeout, default):

212

210

if not default:

213

211

message = 'Client {} needs approval within {} seconds'

215

213

message = 'Client {} will get its secret in {} seconds'

216

214

self.logger(message.format(self.properties["Name"],

217

215

timeout/1000))

218

216

219

217

def rejected(self, reason):

220

218

self.logger('Client {} was rejected; reason: {}'

221

219

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

222

220

223

221

def selectable(self):

224

222

"""Make this a "selectable" widget.

225

223

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

226

224

return True

227

225

228

226

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

229

227

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

230

228

whether we have focus or not.

231

229

This overrides the method from urwid.FlowWidget"""

232

230

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

233

231

234

232

def current_widget(self, focus=False):

235

233

if focus or self.opened:

236

234

return self._focus_widget

237

235

return self._widget

238

236

239

237

def update(self):

240

238

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

241

239

# How to add standout mode to a style

242

with_standout = {"normal": "standout",

243

"bold": "bold-standout",

244

"underline-blink":

245

"underline-blink-standout",

246

"bold-underline-blink":

247

"bold-underline-blink-standout",

248

}

249

240

with_standout = { "normal": "standout",

241

"bold": "bold-standout",

242

"underline-blink":

243

"underline-blink-standout",

244

"bold-underline-blink":

245

"bold-underline-blink-standout",

246

}

247

250

248

# Rebuild focus and non-focus widgets using current properties

251

249

252

250

# Base part of a client. Name!

253

251

base = '{name}: '.format(name=self.properties["Name"])

254

252

if not self.properties["Enabled"]:

255

253

message = "DISABLED"

256

254

self.using_timer(False)

257

255

elif self.properties["ApprovalPending"]:

258

timeout = datetime.timedelta(

259

milliseconds=self.properties["ApprovalDelay"])

256

timeout = datetime.timedelta(milliseconds

257

= self.properties

258

["ApprovalDelay"])

260

259

last_approval_request = isoformat_to_datetime(

261

260

self.properties["LastApprovalRequest"])

262

261

if last_approval_request is not None:

289

288

message = "enabled"

290

289

self.using_timer(False)

291

290

self._text = "{}{}".format(base, message)

292

291

293

292

if not urwid.supports_unicode():

294

293

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

295

294

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

305

304

# Run update hook, if any

306

305

if self.update_hook is not None:

307

306

self.update_hook()

308

307

309

308

def update_timer(self):

310

309

"""called by GLib. Will indefinitely loop until

311

310

GLib.source_remove() on tag is called

312

311

"""

313

312

self.update()

314

313

return True # Keep calling this

315

314

316

315

def delete(self, **kwargs):

317

316

if self._update_timer_callback_tag is not None:

318

317

GLib.source_remove(self._update_timer_callback_tag)

323

322

if self.delete_hook is not None:

324

323

self.delete_hook(self)

325

324

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

326

325

327

326

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

328

327

"""Render differently if we have focus.

329

328

This overrides the method from urwid.FlowWidget"""

330

329

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

331

330

focus=focus)

332

331

333

332

def keypress(self, maxcolrow, key):

334

333

"""Handle keys.

335

334

This overrides the method from urwid.FlowWidget"""

336

335

if key == "+":

337

336

self.proxy.Set(client_interface, "Enabled",

338

dbus.Boolean(True), ignore_reply=True,

339

dbus_interface=dbus.PROPERTIES_IFACE)

337

dbus.Boolean(True), ignore_reply = True,

338

dbus_interface = dbus.PROPERTIES_IFACE)

340

339

elif key == "-":

341

340

self.proxy.Set(client_interface, "Enabled", False,

342

ignore_reply=True,

343

dbus_interface=dbus.PROPERTIES_IFACE)

341

ignore_reply = True,

342

dbus_interface = dbus.PROPERTIES_IFACE)

344

343

elif key == "a":

345

344

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

346

dbus_interface=client_interface,

345

dbus_interface = client_interface,

347

346

ignore_reply=True)

348

347

elif key == "d":

349

348

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

350

dbus_interface=client_interface,

349

dbus_interface = client_interface,

351

350

ignore_reply=True)

352

351

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

353

352

self.server_proxy_object.RemoveClient(self.proxy

355

354

ignore_reply=True)

356

355

elif key == "s":

357

356

self.proxy.Set(client_interface, "CheckerRunning",

358

dbus.Boolean(True), ignore_reply=True,

359

dbus_interface=dbus.PROPERTIES_IFACE)

357

dbus.Boolean(True), ignore_reply = True,

358

dbus_interface = dbus.PROPERTIES_IFACE)

360

359

elif key == "S":

361

360

self.proxy.Set(client_interface, "CheckerRunning",

362

dbus.Boolean(False), ignore_reply=True,

363

dbus_interface=dbus.PROPERTIES_IFACE)

361

dbus.Boolean(False), ignore_reply = True,

362

dbus_interface = dbus.PROPERTIES_IFACE)

364

363

elif key == "C":

365

self.proxy.CheckedOK(dbus_interface=client_interface,

364

self.proxy.CheckedOK(dbus_interface = client_interface,

366

365

ignore_reply=True)

367

366

# xxx

368

367

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

373

372

# self.open()

374

373

else:

375

374

return key

376

375

377

376

def properties_changed(self, interface, properties, invalidated):

378

377

"""Call self.update() if any properties changed.

379

378

This overrides the method from MandosClientPropertyCache"""

380

old_values = {key: self.properties.get(key)

381

for key in properties.keys()}

379

old_values = { key: self.properties.get(key)

380

for key in properties.keys() }

382

381

super(MandosClientWidget, self).properties_changed(

383

382

interface, properties, invalidated)

384

383

if any(old_values[key] != self.properties.get(key)

392

391

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

393

392

"""

394

393

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

395

ret = (super(ConstrainedListBox, self)

396

.keypress(*args, **kwargs))

394

ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)

397

395

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

398

396

return

399

397

return ret

405

403

"""

406

404

def __init__(self, max_log_length=1000, log_level=1):

407

405

DBusGMainLoop(set_as_default=True)

408

406

409

407

self.screen = urwid.curses_display.Screen()

410

408

411

409

self.screen.register_palette((

412

410

("normal",

413

411

"default", "default", None),

418

416

("standout",

419

417

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

420

418

("bold-underline-blink",

421

"bold,underline,blink", "default",

422

"bold,underline,blink"),

419

"bold,underline,blink", "default", "bold,underline,blink"),

423

420

("bold-standout",

424

421

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

425

422

("underline-blink-standout",

429

426

"bold,underline,blink,standout", "default",

430

427

"bold,underline,blink,standout"),

431

428

))

432

429

433

430

if urwid.supports_unicode():

434

self.divider = "─" # \u2500

431

self.divider = "─" # \u2500

432

#self.divider = "━" # \u2501

435

433

else:

436

self.divider = "_" # \u005f

437

434

#self.divider = "-" # \u002d

435

self.divider = "_" # \u005f

436

438

437

self.screen.start()

439

438

440

439

self.size = self.screen.get_cols_rows()

441

440

442

441

self.clients = urwid.SimpleListWalker([])

443

442

self.clients_dict = {}

444

443

445

444

# We will add Text widgets to this list

446

445

self.log = []

447

446

self.max_log_length = max_log_length

448

447

449

448

self.log_level = log_level

450

449

451

450

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

452

451

# from the ListWalker without it getting destroyed

453

452

self.logbox = ConstrainedListBox(self.log)

454

453

455

454

# This keeps track of whether self.uilist currently has

456

455

# self.logbox in it or not

457

456

self.log_visible = True

458

457

self.log_wrap = "any"

459

458

460

459

self.rebuild()

461

460

self.log_message_raw(("bold",

462

461

"Mandos Monitor version " + version))

463

462

self.log_message_raw(("bold",

464

463

"q: Quit ?: Help"))

465

464

466

465

self.busname = domain + '.Mandos'

467

466

self.main_loop = GLib.MainLoop()

468

467

469

468

def client_not_found(self, fingerprint, address):

470

469

self.log_message("Client with address {} and fingerprint {}"

471

470

" could not be found"

472

471

.format(address, fingerprint))

473

472

474

473

def rebuild(self):

475

474

"""This rebuilds the User Interface.

476

475

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

477

476

self.uilist = []

478

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

477

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

479

478

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

480

479

clients),

481

# header=urwid.Divider(),

480

#header=urwid.Divider(),

482

481

header=None,

483

footer=urwid.Divider(

484

div_char=self.divider)))

482

footer=

483

urwid.Divider(div_char=

484

self.divider)))

485

if self.log_visible:

486

self.uilist.append(self.logbox)

487

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

488

489

def log_message(self, message, level=1):

490

"""Log message formatted with timestamp"""

491

if level < self.log_level:

493

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

494

self.log_message_raw("{}: {}".format(timestamp, message),

495

level=level)

496

497

def log_message_raw(self, markup, level=1):

498

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

499

if level < self.log_level:

500

return

501

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

502

if self.max_log_length:

503

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

504

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

502

if (self.max_log_length

503

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

504

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

505

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

506

coming_from="above")

507

self.refresh()

508

509

def toggle_log_display(self):

510

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

511

self.log_visible = not self.log_visible

512

self.rebuild()

513

self.log_message("Log visibility changed to: {}"

514

.format(self.log_visible), level=0)

515

516

def change_log_display(self):

517

"""Change type of log display.

518

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

524

textwidget.set_wrap_mode(self.log_wrap)

525

self.log_message("Wrap mode: {}".format(self.log_wrap),

526

level=0)

527

528

def find_and_remove_client(self, path, interfaces):

529

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

530

531

This is connected to the InterfacesRemoved signal from the

532

Mandos server object."""

533

if client_interface not in interfaces:

541

.format(path))

542

return

543

client.delete()

544

545

def add_new_client(self, path, ifs_and_props):

546

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

547

548

This is connected to the InterfacesAdded signal from the

549

Mandos server object.

550

"""

552

# Not a Mandos client object; ignore

553

return

554

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

555

self.add_client(MandosClientWidget(

556

server_proxy_object=self.mandos_serv,

557

proxy_object=client_proxy_object,

558

update_hook=self.refresh,

559

delete_hook=self.remove_client,

560

logger=self.log_message,

561

properties=dict(ifs_and_props[client_interface])),

555

self.add_client(MandosClientWidget(server_proxy_object

556

=self.mandos_serv,

557

proxy_object

558

=client_proxy_object,

559

update_hook

560

=self.refresh,

561

delete_hook

562

=self.remove_client,

563

logger

564

=self.log_message,

565

properties

566

= dict(ifs_and_props[

567

client_interface])),

562

568

path=path)

563

569

564

570

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

565

571

self.clients.append(client)

566

572

if path is None:

568

574

self.clients_dict[path] = client

569

575

self.clients.sort(key=lambda c: c.properties["Name"])

570

576

self.refresh()

571

577

572

578

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

573

579

self.clients.remove(client)

574

580

if path is None:

575

581

path = client.proxy.object_path

576

582

del self.clients_dict[path]

577

583

self.refresh()

578

584

579

585

def refresh(self):

580

586

"""Redraw the screen"""

581

587

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

582

588

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

583

589

584

590

def run(self):

585

591

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

586

592

self.bus = dbus.SystemBus()

587

593

mandos_dbus_objc = self.bus.get_object(

588

594

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

589

self.mandos_serv = dbus.Interface(

590

mandos_dbus_objc, dbus_interface=server_interface)

595

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

596

dbus_interface

597

= server_interface)

591

598

try:

592

599

mandos_clients = (self.mandos_serv

593

600

.GetAllClientsWithProperties())

594

601

if not mandos_clients:

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

602

self.log_message_raw(("bold", "Note: Server has no clients."))

597

603

except dbus.exceptions.DBusException:

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

604

self.log_message_raw(("bold", "Note: No Mandos server running."))

600

605

mandos_clients = dbus.Dictionary()

601

606

602

607

(self.mandos_serv

603

608

.connect_to_signal("InterfacesRemoved",

604

609

self.find_and_remove_client,

605

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

610

dbus_interface

611

= dbus.OBJECT_MANAGER_IFACE,

606

612

byte_arrays=True))

607

613

(self.mandos_serv

608

614

.connect_to_signal("InterfacesAdded",

609

615

self.add_new_client,

610

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

616

dbus_interface

617

= dbus.OBJECT_MANAGER_IFACE,

611

618

byte_arrays=True))

612

619

(self.mandos_serv

613

620

.connect_to_signal("ClientNotFound",

617

624

for path, client in mandos_clients.items():

618

625

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

619

626

path)

620

self.add_client(MandosClientWidget(

621

server_proxy_object=self.mandos_serv,

622

proxy_object=client_proxy_object,

623

properties=client,

624

update_hook=self.refresh,

625

delete_hook=self.remove_client,

626

logger=self.log_message),

627

self.add_client(MandosClientWidget(server_proxy_object

628

=self.mandos_serv,

629

proxy_object

630

=client_proxy_object,

631

properties=client,

632

update_hook

633

=self.refresh,

634

delete_hook

635

=self.remove_client,

636

logger

637

=self.log_message),

627

638

path=path)

628

639

629

640

self.refresh()

630

641

self._input_callback_tag = (GLib.io_add_watch

631

642

(sys.stdin.fileno(),

635

646

# Main loop has finished, we should close everything now

636

647

GLib.source_remove(self._input_callback_tag)

637

648

self.screen.stop()

638

649

639

650

def stop(self):

640

651

self.main_loop.quit()

641

652

642

653

def process_input(self, source, condition):

643

654

keys = self.screen.get_input()

644

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

645

"ctrl p": "up", # Emacs

646

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

647

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

648

" ": "page down", # less

649

"f": "page down", # less

650

"b": "page up", # less

651

"j": "down", # vi

652

"k": "up", # vi

653

}

655

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

656

"ctrl p": "up", # Emacs

657

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

658

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

659

" ": "page down", # less

660

"f": "page down", # less

661

"b": "page up", # less

662

"j": "down", # vi

663

"k": "up", # vi

664

}

654

665

for key in keys:

655

666

try:

656

667

key = translations[key]

657

668

except KeyError: # :-)

658

669

pass

659

670

660

671

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

661

672

self.stop()

662

673

break

710

721

else:

711

722

self.log_level = 0

712

723

self.log_message("Verbose mode: On")

713

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

714

# or key == ">"):

715

# pass # xxx end-of-buffer

716

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

717

# or key == "<"):

718

# pass # xxx beginning-of-buffer

719

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

720

# pass # xxx move-end-of-line

721

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

722

# pass # xxx move-beginning-of-line

723

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

724

# pass # xxx left

725

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

726

# pass # xxx right

727

# elif key == "a":

728

# pass # scroll up log

729

# elif key == "z":

730

# pass # scroll down log

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

731

742

elif self.topwidget.selectable():

732

743

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

733

744

self.refresh()

734

745

return True

735

746

736

737

747

ui = UserInterface()

738

748

try:

739

749

ui.run()