/mandos/release : revision 237.7.452

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

48

50

if sys.version_info.major == 2:

49

51

str = unicode

50

52

51

53

locale.setlocale(locale.LC_ALL, '')

52

54

53

import logging

54

55

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

55

56

57

# Some useful constants

57

58

domain = 'se.recompile'

58

59

server_interface = domain + '.Mandos'

59

60

client_interface = domain + '.Mandos.Client'

60

version = "1.7.10"

61

version = "1.7.15"

61

62

63

try:

63

64

dbus.OBJECT_MANAGER_IFACE

64

65

except AttributeError:

65

66

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

66

67

68

67

69

def isoformat_to_datetime(iso):

68

70

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

69

71

if not iso:

77

79

int(day),

78

80

int(hour),

79

81

int(minute),

80

int(second), # Whole seconds

81

int(fraction*1000000)) # Microseconds

82

int(second), # Whole seconds

83

int(fraction*1000000)) # Microseconds

84

82

85

83

86

class MandosClientPropertyCache(object):

84

87

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

86

89

changed.

87

90

"""

88

91

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

89

self.proxy = proxy_object # Mandos Client proxy object

92

self.proxy = proxy_object # Mandos Client proxy object

90

93

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

91

94

self.property_changed_match = (

92

95

self.proxy.connect_to_signal("PropertiesChanged",

93

96

self.properties_changed,

94

97

dbus.PROPERTIES_IFACE,

95

98

byte_arrays=True))

96

99

97

100

if properties is None:

98

self.properties.update(

99

self.proxy.GetAll(client_interface,

100

dbus_interface

101

= dbus.PROPERTIES_IFACE))

102

101

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

102

client_interface,

103

dbus_interface=dbus.PROPERTIES_IFACE))

104

103

105

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

104

106

105

107

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

106

108

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

107

109

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

109

111

# Update properties dict with new value

110

112

if interface == client_interface:

111

113

self.properties.update(properties)

112

114

113

115

def delete(self):

114

116

self.property_changed_match.remove()

115

117

119

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

118

120

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

119

121

"""

120

122

121

123

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

122

124

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

123

125

# Called on update

128

130

self.server_proxy_object = server_proxy_object

129

131

# Logger

130

132

self.logger = logger

131

133

132

134

self._update_timer_callback_tag = None

133

135

134

136

# The widget shown normally

135

137

self._text_widget = urwid.Text("")

136

138

# The widget shown when we have focus

138

140

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

139

141

self.update()

140

142

self.opened = False

141

143

142

144

self.match_objects = (

143

145

self.proxy.connect_to_signal("CheckerCompleted",

144

146

self.checker_completed,

162

164

byte_arrays=True))

163

165

self.logger('Created client {}'

164

166

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

165

167

166

168

def using_timer(self, flag):

167

169

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

168

170

activated or deactivated.

175

177

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

176

178

GLib.source_remove(self._update_timer_callback_tag)

177

179

self._update_timer_callback_tag = None

178

180

179

181

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

180

182

if exitstatus == 0:

181

183

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

195

197

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

196

198

os.WTERMSIG(condition)))

197

199

self.update()

198

200

199

201

def checker_started(self, command):

200

202

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

201

203

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

202

204

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

203

205

command), level=0)

204

206

205

207

def got_secret(self):

206

208

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

207

209

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

208

210

209

211

def need_approval(self, timeout, default):

210

212

if not default:

211

213

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

213

215

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

214

216

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

215

217

timeout/1000))

216

218

217

219

def rejected(self, reason):

218

220

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

219

221

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

220

222

221

223

def selectable(self):

222

224

"""Make this a "selectable" widget.

223

225

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

224

226

return True

225

227

226

228

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

227

229

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

228

230

whether we have focus or not.

229

231

This overrides the method from urwid.FlowWidget"""

230

232

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

231

233

232

234

def current_widget(self, focus=False):

233

235

if focus or self.opened:

234

236

return self._focus_widget

235

237

return self._widget

236

238

237

239

def update(self):

238

240

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

239

241

# How to add standout mode to a style

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

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

248

250

# Rebuild focus and non-focus widgets using current properties

249

251

250

252

# Base part of a client. Name!

251

253

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

252

254

if not self.properties["Enabled"]:

253

255

message = "DISABLED"

254

256

self.using_timer(False)

255

257

elif self.properties["ApprovalPending"]:

256

timeout = datetime.timedelta(milliseconds

257

= self.properties

258

["ApprovalDelay"])

258

timeout = datetime.timedelta(

259

milliseconds=self.properties["ApprovalDelay"])

259

260

last_approval_request = isoformat_to_datetime(

260

261

self.properties["LastApprovalRequest"])

261

262

if last_approval_request is not None:

288

289

message = "enabled"

289

290

self.using_timer(False)

290

291

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

291

292

293

if not urwid.supports_unicode():

293

294

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

294

295

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

304

305

# Run update hook, if any

305

306

if self.update_hook is not None:

306

307

self.update_hook()

307

308

309

def update_timer(self):

309

310

"""called by GLib. Will indefinitely loop until

310

311

GLib.source_remove() on tag is called

311

312

"""

312

313

self.update()

313

314

return True # Keep calling this

314

315

316

def delete(self, **kwargs):

316

317

if self._update_timer_callback_tag is not None:

317

318

GLib.source_remove(self._update_timer_callback_tag)

322

323

if self.delete_hook is not None:

323

324

self.delete_hook(self)

324

325

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

325

326

327

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

327

328

"""Render differently if we have focus.

328

329

This overrides the method from urwid.FlowWidget"""

329

330

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

330

331

focus=focus)

331

332

333

def keypress(self, maxcolrow, key):

333

334

"""Handle keys.

334

335

This overrides the method from urwid.FlowWidget"""

335

336

if key == "+":

336

337

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

337

dbus.Boolean(True), ignore_reply = True,

338

dbus_interface = dbus.PROPERTIES_IFACE)

338

dbus.Boolean(True), ignore_reply=True,

339

dbus_interface=dbus.PROPERTIES_IFACE)

339

340

elif key == "-":

340

341

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

341

ignore_reply = True,

342

dbus_interface = dbus.PROPERTIES_IFACE)

342

ignore_reply=True,

343

dbus_interface=dbus.PROPERTIES_IFACE)

343

344

elif key == "a":

344

345

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

345

dbus_interface = client_interface,

346

dbus_interface=client_interface,

346

347

ignore_reply=True)

347

348

elif key == "d":

348

349

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

349

dbus_interface = client_interface,

350

dbus_interface=client_interface,

350

351

ignore_reply=True)

351

352

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

352

353

self.server_proxy_object.RemoveClient(self.proxy

354

355

ignore_reply=True)

355

356

elif key == "s":

356

357

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

357

dbus.Boolean(True), ignore_reply = True,

358

dbus_interface = dbus.PROPERTIES_IFACE)

358

dbus.Boolean(True), ignore_reply=True,

359

dbus_interface=dbus.PROPERTIES_IFACE)

359

360

elif key == "S":

360

361

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

361

dbus.Boolean(False), ignore_reply = True,

362

dbus_interface = dbus.PROPERTIES_IFACE)

362

dbus.Boolean(False), ignore_reply=True,

363

dbus_interface=dbus.PROPERTIES_IFACE)

363

364

elif key == "C":

364

self.proxy.CheckedOK(dbus_interface = client_interface,

365

self.proxy.CheckedOK(dbus_interface=client_interface,

365

366

ignore_reply=True)

366

367

# xxx

367

368

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

372

373

# self.open()

373

374

else:

374

375

return key

375

376

377

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

377

378

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

378

379

This overrides the method from MandosClientPropertyCache"""

379

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

380

for key in properties.keys() }

380

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

381

for key in properties.keys()}

381

382

super(MandosClientWidget, self).properties_changed(

382

383

interface, properties, invalidated)

383

384

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

391

392

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

392

393

"""

393

394

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

394

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

395

ret = (super(ConstrainedListBox, self)

396

.keypress(*args, **kwargs))

395

397

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

396

398

return

397

399

return ret

403

405

"""

404

406

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

405

407

DBusGMainLoop(set_as_default=True)

406

408

407

409

self.screen = urwid.curses_display.Screen()

408

410

409

411

self.screen.register_palette((

410

412

("normal",

411

413

"default", "default", None),

416

418

("standout",

417

419

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

418

420

("bold-underline-blink",

419

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

421

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

422

"bold,underline,blink"),

420

423

("bold-standout",

421

424

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

422

425

("underline-blink-standout",

426

429

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

427

430

"bold,underline,blink,standout"),

428

431

))

429

432

430

433

if urwid.supports_unicode():

431

self.divider = "─" # \u2500

432

#self.divider = "━" # \u2501

434

self.divider = "─" # \u2500

433

435

else:

434

#self.divider = "-" # \u002d

435

self.divider = "_" # \u005f

436

self.divider = "_" # \u005f

437

438

self.screen.start()

438

439

440

self.size = self.screen.get_cols_rows()

440

441

442

self.clients = urwid.SimpleListWalker([])

442

443

self.clients_dict = {}

443

444

445

# We will add Text widgets to this list

445

446

self.log = []

446

447

self.max_log_length = max_log_length

447

448

449

self.log_level = log_level

449

450

451

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

451

452

# from the ListWalker without it getting destroyed

452

453

self.logbox = ConstrainedListBox(self.log)

453

454

455

# This keeps track of whether self.uilist currently has

455

456

# self.logbox in it or not

456

457

self.log_visible = True

457

458

self.log_wrap = "any"

458

459

460

self.rebuild()

460

461

self.log_message_raw(("bold",

461

462

"Mandos Monitor version " + version))

462

463

self.log_message_raw(("bold",

463

464

"q: Quit ?: Help"))

464

465

466

self.busname = domain + '.Mandos'

466

467

self.main_loop = GLib.MainLoop()

467

468

469

def client_not_found(self, fingerprint, address):

469

470

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

470

471

" could not be found"

471

472

.format(address, fingerprint))

472

473

474

def rebuild(self):

474

475

"""This rebuilds the User Interface.

475

476

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

476

477

self.uilist = []

477

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

478

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

478

479

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

479

480

clients),

480

#header=urwid.Divider(),

481

# header=urwid.Divider(),

481

482

header=None,

482

footer=

483

urwid.Divider(div_char=

484

self.divider)))

483

footer=urwid.Divider(

484

div_char=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

and 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

if 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(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])),

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

568

562

path=path)

569

563

570

564

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

571

565

self.clients.append(client)

572

566

if path is None:

574

568

self.clients_dict[path] = client

575

569

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

576

570

self.refresh()

577

571

578

572

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

579

573

self.clients.remove(client)

580

574

if path is None:

581

575

path = client.proxy.object_path

582

576

del self.clients_dict[path]

583

577

self.refresh()

584

578

585

579

def refresh(self):

586

580

"""Redraw the screen"""

587

581

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

588

582

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

589

583

590

584

def run(self):

591

585

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

592

586

self.bus = dbus.SystemBus()

593

587

mandos_dbus_objc = self.bus.get_object(

594

588

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

595

self.mandos_serv = dbus.Interface(mandos_dbus_objc,

596

dbus_interface

597

= server_interface)

589

self.mandos_serv = dbus.Interface(

590

mandos_dbus_objc, dbus_interface=server_interface)

598

591

try:

599

592

mandos_clients = (self.mandos_serv

600

593

.GetAllClientsWithProperties())

601

594

if not mandos_clients:

602

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

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

603

597

except dbus.exceptions.DBusException:

604

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

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

605

600

mandos_clients = dbus.Dictionary()

606

601

607

602

(self.mandos_serv

608

603

.connect_to_signal("InterfacesRemoved",

609

604

self.find_and_remove_client,

610

dbus_interface

611

= dbus.OBJECT_MANAGER_IFACE,

605

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

612

606

byte_arrays=True))

613

607

(self.mandos_serv

614

608

.connect_to_signal("InterfacesAdded",

615

609

self.add_new_client,

616

dbus_interface

617

= dbus.OBJECT_MANAGER_IFACE,

610

dbus_interface=dbus.OBJECT_MANAGER_IFACE,

618

611

byte_arrays=True))

619

612

(self.mandos_serv

620

613

.connect_to_signal("ClientNotFound",

624

617

for path, client in mandos_clients.items():

625

618

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

626

619

path)

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

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

638

627

path=path)

639

628

640

629

self.refresh()

641

630

self._input_callback_tag = (GLib.io_add_watch

642

631

(sys.stdin.fileno(),

646

635

# Main loop has finished, we should close everything now

647

636

GLib.source_remove(self._input_callback_tag)

648

637

self.screen.stop()

649

638

650

639

def stop(self):

651

640

self.main_loop.quit()

652

641

653

642

def process_input(self, source, condition):

654

643

keys = self.screen.get_input()

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

}

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

}

665

654

for key in keys:

666

655

try:

667

656

key = translations[key]

668

657

except KeyError: # :-)

669

658

pass

670

659

671

660

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

672

661

self.stop()

673

662

break

721

710

else:

722

711

self.log_level = 0

723

712

self.log_message("Verbose mode: On")

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

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

742

731

elif self.topwidget.selectable():

743

732

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

744

733

self.refresh()

745

734

return True

746

735

736

747

737

ui = UserInterface()

748

738

try:

749

739

ui.run()