/mandos/trunk : revision 1184

1

#!/usr/bin/python

1

#!/usr/bin/python3 -bb

2

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

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

33

34

import sys

35

import os

36

import warnings

37

import datetime

38

import locale

39

import logging

38

40

39

41

import urwid.curses_display

40

42

import urwid

44

46

45

47

import dbus

46

48

47

import locale

48

49

import logging

50

51

49

if sys.version_info.major == 2:

52

50

str = unicode

53

51

54

locale.setlocale(locale.LC_ALL, '')

55

56

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

52

log = logging.getLogger(os.path.basename(sys.argv[0]))

53

logging.basicConfig(level="NOTSET", # Show all messages

54

format="%(message)s") # Show basic log messages

55

56

logging.captureWarnings(True) # Show warnings via the logging system

57

58

locale.setlocale(locale.LC_ALL, "")

59

60

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

57

61

58

62

# Some useful constants

59

domain = 'se.recompile'

60

server_interface = domain + '.Mandos'

61

client_interface = domain + '.Mandos.Client'

62

version = "1.8.6"

63

domain = "se.recompile"

64

server_interface = domain + ".Mandos"

65

client_interface = domain + ".Mandos.Client"

66

version = "1.8.9"

63

67

64

68

try:

65

69

dbus.OBJECT_MANAGER_IFACE

122

126

"""

123

127

124

128

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

125

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

129

delete_hook=None, **kwargs):

126

130

# Called on update

127

131

self.update_hook = update_hook

128

132

# Called on delete

129

133

self.delete_hook = delete_hook

130

134

# Mandos Server proxy object

131

135

self.server_proxy_object = server_proxy_object

132

# Logger

133

self.logger = logger

134

136

135

137

self._update_timer_callback_tag = None

136

138

163

165

self.rejected,

164

166

client_interface,

165

167

byte_arrays=True))

166

self.logger('Created client {}'

167

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

168

log.debug("Created client %s", self.properties["Name"])

168

169

170

def using_timer(self, flag):

170

171

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

172

173

"""

173

174

if flag and self._update_timer_callback_tag is None:

174

175

# Will update the shown timer value every second

175

self._update_timer_callback_tag = (GLib.timeout_add

176

(1000,

177

self.update_timer))

176

self._update_timer_callback_tag = (

177

GLib.timeout_add(1000,

178

glib_safely(self.update_timer)))

178

179

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

179

180

GLib.source_remove(self._update_timer_callback_tag)

180

181

self._update_timer_callback_tag = None

181

182

183

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

183

184

if exitstatus == 0:

184

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

185

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

186

command), level=0)

185

log.debug('Checker for client %s (command "%s")'

186

" succeeded", self.properties["Name"], command)

187

self.update()

188

return

189

# Checker failed

190

if os.WIFEXITED(condition):

191

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

192

' with exit code {}'

193

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

194

os.WEXITSTATUS(condition)))

191

log.info('Checker for client %s (command "%s") failed'

192

" with exit code %d", self.properties["Name"],

193

command, os.WEXITSTATUS(condition))

195

194

elif os.WIFSIGNALED(condition):

196

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

197

' killed by signal {}'

198

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

199

os.WTERMSIG(condition)))

195

log.info('Checker for client %s (command "%s") was'

196

" killed by signal %d", self.properties["Name"],

197

command, os.WTERMSIG(condition))

200

198

self.update()

201

199

202

200

def checker_started(self, command):

203

201

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

204

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

205

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

206

command), level=0)

202

log.debug('Client %s started checker "%s"',

203

self.properties["Name"], command)

207

204

208

205

def got_secret(self):

209

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

210

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

206

log.info("Client %s received its secret",

207

self.properties["Name"])

211

208

212

209

def need_approval(self, timeout, default):

213

210

if not default:

214

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

211

message = "Client %s needs approval within %f seconds"

215

212

else:

216

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

217

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

218

timeout/1000))

213

message = "Client %s will get its secret in %f seconds"

214

log.info(message, self.properties["Name"], timeout/1000)

219

215

220

216

def rejected(self, reason):

221

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

222

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

217

log.info("Client %s was rejected; reason: %s",

218

self.properties["Name"], reason)

223

219

224

220

def selectable(self):

225

221

"""Make this a "selectable" widget.

251

247

# Rebuild focus and non-focus widgets using current properties

252

248

253

249

# Base part of a client. Name!

254

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

250

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

255

251

if not self.properties["Enabled"]:

256

252

message = "DISABLED"

257

253

self.using_timer(False)

279

275

timer = datetime.timedelta(0)

280

276

else:

281

277

expires = (datetime.datetime.strptime

282

(expires, '%Y-%m-%dT%H:%M:%S.%f'))

278

(expires, "%Y-%m-%dT%H:%M:%S.%f"))

283

279

timer = max(expires - datetime.datetime.utcnow(),

284

280

datetime.timedelta())

285

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

286

' gets disabled: {}'

281

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

282

" gets disabled: {}"

287

283

.format(str(timer).rsplit(".", 1)[0]))

288

284

self.using_timer(True)

289

285

else:

387

383

self.update()

388

384

389

385

386

def glib_safely(func, retval=True):

387

def safe_func(*args, **kwargs):

388

try:

389

return func(*args, **kwargs)

390

except Exception:

391

log.exception("")

392

return retval

393

return safe_func

394

395

390

396

class ConstrainedListBox(urwid.ListBox):

391

397

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

392

398

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

404

410

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

405

411

with boxes, lists of client widgets, etc.

406

412

"""

407

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

413

def __init__(self, max_log_length=1000):

408

414

DBusGMainLoop(set_as_default=True)

409

415

410

416

self.screen = urwid.curses_display.Screen()

447

453

self.log = urwid.SimpleListWalker([])

448

454

self.max_log_length = max_log_length

449

455

450

self.log_level = log_level

451

452

456

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

453

457

# from the ListWalker without it getting destroyed

454

458

self.logbox = ConstrainedListBox(self.log)

458

462

self.log_visible = True

459

463

self.log_wrap = "any"

460

464

465

self.loghandler = UILogHandler(self)

466

461

467

self.rebuild()

462

self.log_message_raw(("bold",

463

"Mandos Monitor version " + version))

464

self.log_message_raw(("bold",

465

"q: Quit ?: Help"))

468

self.add_log_line(("bold",

469

"Mandos Monitor version " + version))

470

self.add_log_line(("bold", "q: Quit ?: Help"))

466

471

467

self.busname = domain + '.Mandos'

472

self.busname = domain + ".Mandos"

468

473

self.main_loop = GLib.MainLoop()

469

474

470

def client_not_found(self, fingerprint, address):

471

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

472

" could not be found"

473

.format(address, fingerprint))

475

def client_not_found(self, key_id, address):

476

log.info("Client with address %s and key ID %s could"

477

" not be found", address, key_id)

474

478

475

479

def rebuild(self):

476

480

"""This rebuilds the User Interface.

487

491

self.uilist.append(self.logbox)

488

492

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

489

493

490

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

491

"""Log message formatted with timestamp"""

492

if level < self.log_level:

493

return

494

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

495

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

496

level=level)

497

498

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

499

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

500

if level < self.log_level:

501

return

494

def add_log_line(self, markup):

502

495

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

503

496

if self.max_log_length:

504

497

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

505

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

498

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

506

499

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

507

500

coming_from="above")

508

501

self.refresh()

511

504

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

512

505

self.log_visible = not self.log_visible

513

506

self.rebuild()

514

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

515

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

507

log.debug("Log visibility changed to: %s", self.log_visible)

516

508

517

509

def change_log_display(self):

518

510

"""Change type of log display.

523

515

self.log_wrap = "clip"

524

516

for textwidget in self.log:

525

517

textwidget.set_wrap_mode(self.log_wrap)

526

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

527

level=0)

518

log.debug("Wrap mode: %s", self.log_wrap)

528

519

529

520

def find_and_remove_client(self, path, interfaces):

530

521

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

538

529

client = self.clients_dict[path]

539

530

except KeyError:

540

531

# not found?

541

self.log_message("Unknown client {!r} removed"

542

.format(path))

532

log.warning("Unknown client %s removed", path)

543

533

return

544

534

client.delete()

545

535

558

548

proxy_object=client_proxy_object,

559

549

update_hook=self.refresh,

560

550

delete_hook=self.remove_client,

561

logger=self.log_message,

562

551

properties=dict(ifs_and_props[client_interface])),

563

552

path=path)

564

553

584

573

585

574

def run(self):

586

575

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

576

log.addHandler(self.loghandler)

577

self.orig_log_propagate = log.propagate

578

log.propagate = False

579

self.orig_log_level = log.level

580

log.setLevel("INFO")

587

581

self.bus = dbus.SystemBus()

588

582

mandos_dbus_objc = self.bus.get_object(

589

583

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

593

587

mandos_clients = (self.mandos_serv

594

588

.GetAllClientsWithProperties())

595

589

if not mandos_clients:

596

self.log_message_raw(("bold",

597

"Note: Server has no clients."))

590

log.warning("Note: Server has no clients.")

598

591

except dbus.exceptions.DBusException:

599

self.log_message_raw(("bold",

600

"Note: No Mandos server running."))

592

log.warning("Note: No Mandos server running.")

601

593

mandos_clients = dbus.Dictionary()

602

594

603

595

(self.mandos_serv

623

615

proxy_object=client_proxy_object,

624

616

properties=client,

625

617

update_hook=self.refresh,

626

delete_hook=self.remove_client,

627

logger=self.log_message),

618

delete_hook=self.remove_client),

628

619

path=path)

629

620

630

621

self.refresh()

631

self._input_callback_tag = (GLib.io_add_watch

632

(sys.stdin.fileno(),

633

GLib.IO_IN,

634

self.process_input))

622

self._input_callback_tag = (

623

GLib.io_add_watch(

624

GLib.IOChannel.unix_new(sys.stdin.fileno()),

625

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

626

glib_safely(self.process_input)))

635

627

self.main_loop.run()

636

628

# Main loop has finished, we should close everything now

637

629

GLib.source_remove(self._input_callback_tag)

638

self.screen.stop()

630

with warnings.catch_warnings():

631

warnings.simplefilter("ignore", BytesWarning)

632

self.screen.stop()

639

633

640

634

def stop(self):

641

635

self.main_loop.quit()

636

log.removeHandler(self.loghandler)

637

log.propagate = self.orig_log_propagate

642

638

643

639

def process_input(self, source, condition):

644

640

keys = self.screen.get_input()

677

673

if not self.log_visible:

678

674

self.log_visible = True

679

675

self.rebuild()

680

self.log_message_raw(("bold",

681

" ".

682

join(("q: Quit",

683

"?: Help",

684

"l: Log window toggle",

685

"TAB: Switch window",

686

"w: Wrap (log lines)",

687

"v: Toggle verbose log",

688

))))

689

self.log_message_raw(("bold",

690

" "

691

.join(("Clients:",

692

"+: Enable",

693

"-: Disable",

694

"R: Remove",

695

"s: Start new checker",

696

"S: Stop checker",

697

"C: Checker OK",

698

"a: Approve",

699

"d: Deny"))))

676

self.add_log_line(("bold",

677

" ".join(("q: Quit",

678

"?: Help",

679

"l: Log window toggle",

680

"TAB: Switch window",

681

"w: Wrap (log lines)",

682

"v: Toggle verbose log",

683

))))

684

self.add_log_line(("bold",

685

" ".join(("Clients:",

686

"+: Enable",

687

"-: Disable",

688

"R: Remove",

689

"s: Start new checker",

690

"S: Stop checker",

691

"C: Checker OK",

692

"a: Approve",

693

"d: Deny",

694

))))

700

695

self.refresh()

701

696

elif key == "tab":

702

697

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

705

700

self.topwidget.set_focus(self.logbox)

706

701

self.refresh()

707

702

elif key == "v":

708

if self.log_level == 0:

709

self.log_level = 1

710

self.log_message("Verbose mode: Off")

703

if log.level < logging.INFO:

704

log.setLevel(logging.INFO)

705

log.info("Verbose mode: Off")

711

706

else:

712

self.log_level = 0

713

self.log_message("Verbose mode: On")

707

log.setLevel(logging.NOTSET)

708

log.info("Verbose mode: On")

714

709

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

715

710

# or key == ">"):

716

711

# pass # xxx end-of-buffer

735

730

return True

736

731

737

732

733

class UILogHandler(logging.Handler):

734

def __init__(self, ui, *args, **kwargs):

735

self.ui = ui

736

super(UILogHandler, self).__init__(*args, **kwargs)

737

self.setFormatter(

738

logging.Formatter("%(asctime)s: %(message)s"))

739

def emit(self, record):

740

msg = self.format(record)

741

if record.levelno > logging.INFO:

742

msg = ("bold", msg)

743

self.ui.add_log_line(msg)

744

745

738

746

ui = UserInterface()

739

747

try:

740

748

ui.run()

741

749

except KeyboardInterrupt:

742

ui.screen.stop()

743

except Exception as e:

744

ui.log_message(str(e))

745

ui.screen.stop()

750

with warnings.catch_warnings():

751

warnings.filterwarnings("ignore", "", BytesWarning)

752

ui.screen.stop()

753

except Exception:

754

with warnings.catch_warnings():

755

warnings.filterwarnings("ignore", "", BytesWarning)

756

ui.screen.stop()

746

757

raise