/mandos/trunk : revision 237.4.124

1

#!/usr/bin/python3 -bbI

1

#!/usr/bin/python3 -bb

2

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

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

35

import os

36

import warnings

37

import datetime

38

import locale

39

import logging

40

38

41

39

import urwid.curses_display

42

40

import urwid

46

44

47

45

import dbus

48

46

47

import locale

48

49

import logging

50

49

51

if sys.version_info.major == 2:

50

__metaclass__ = type

51

52

str = unicode

52

53

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

54

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

55

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

56

57

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

58

59

locale.setlocale(locale.LC_ALL, "")

60

61

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

54

locale.setlocale(locale.LC_ALL, '')

55

56

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

62

57

63

58

# Some useful constants

64

domain = "se.recompile"

65

server_interface = domain + ".Mandos"

66

client_interface = domain + ".Mandos.Client"

67

version = "1.8.10"

59

domain = 'se.recompile'

60

server_interface = domain + '.Mandos'

61

client_interface = domain + '.Mandos.Client'

62

version = "1.8.9"

68

63

69

64

try:

70

65

dbus.OBJECT_MANAGER_IFACE

89

84

int(fraction*1000000)) # Microseconds

90

85

91

86

92

class MandosClientPropertyCache:

87

class MandosClientPropertyCache(object):

93

88

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

94

89

properties and calls a hook function when any of them are

95

90

changed.

127

122

"""

128

123

129

124

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

130

delete_hook=None, **kwargs):

125

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

131

126

# Called on update

132

127

self.update_hook = update_hook

133

128

# Called on delete

134

129

self.delete_hook = delete_hook

135

130

# Mandos Server proxy object

136

131

self.server_proxy_object = server_proxy_object

132

# Logger

133

self.logger = logger

137

134

138

135

self._update_timer_callback_tag = None

139

136

166

163

self.rejected,

167

164

client_interface,

168

165

byte_arrays=True))

169

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

166

self.logger('Created client {}'

167

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

170

168

171

169

def using_timer(self, flag):

172

170

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

174

172

"""

175

173

if flag and self._update_timer_callback_tag is None:

176

174

# Will update the shown timer value every second

177

self._update_timer_callback_tag = (

178

GLib.timeout_add(1000,

179

glib_safely(self.update_timer)))

175

self._update_timer_callback_tag = (GLib.timeout_add

176

(1000,

177

self.update_timer))

180

178

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

181

179

GLib.source_remove(self._update_timer_callback_tag)

182

180

self._update_timer_callback_tag = None

183

181

184

182

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

185

183

if exitstatus == 0:

186

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

187

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

184

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

185

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

186

command), level=0)

188

187

self.update()

189

188

return

190

189

# Checker failed

191

190

if os.WIFEXITED(condition):

192

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

193

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

194

command, os.WEXITSTATUS(condition))

191

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

192

' with exit code {}'

193

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

194

os.WEXITSTATUS(condition)))

195

elif os.WIFSIGNALED(condition):

196

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

197

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

198

command, os.WTERMSIG(condition))

196

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

197

' killed by signal {}'

198

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

199

os.WTERMSIG(condition)))

199

200

self.update()

200

201

202

def checker_started(self, command):

202

203

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

203

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

204

self.properties["Name"], command)

204

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

205

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

206

command), level=0)

205

207

206

208

def got_secret(self):

207

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

208

self.properties["Name"])

209

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

210

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

209

211

210

212

def need_approval(self, timeout, default):

211

213

if not default:

212

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

214

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

213

215

else:

214

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

215

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

216

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

217

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

218

timeout/1000))

216

219

217

220

def rejected(self, reason):

218

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

219

self.properties["Name"], reason)

221

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

222

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

220

223

221

224

def selectable(self):

222

225

"""Make this a "selectable" widget.

248

251

# Rebuild focus and non-focus widgets using current properties

249

252

250

253

# Base part of a client. Name!

251

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

254

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

252

255

if not self.properties["Enabled"]:

253

256

message = "DISABLED"

254

257

self.using_timer(False)

276

279

timer = datetime.timedelta(0)

277

280

else:

278

281

expires = (datetime.datetime.strptime

279

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

282

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

280

283

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

281

284

datetime.timedelta())

282

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

283

" gets disabled: {}"

285

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

286

' gets disabled: {}'

284

287

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

285

288

self.using_timer(True)

286

289

else:

384

387

self.update()

385

388

386

389

387

def glib_safely(func, retval=True):

388

def safe_func(*args, **kwargs):

389

try:

390

return func(*args, **kwargs)

391

except Exception:

392

log.exception("")

393

return retval

394

return safe_func

395

396

397

390

class ConstrainedListBox(urwid.ListBox):

398

391

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

399

392

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

407

400

return ret

408

401

409

402

410

class UserInterface:

403

class UserInterface(object):

411

404

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

412

405

with boxes, lists of client widgets, etc.

413

406

"""

414

def __init__(self, max_log_length=1000):

407

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

415

408

DBusGMainLoop(set_as_default=True)

416

409

417

410

self.screen = urwid.curses_display.Screen()

454

447

self.log = urwid.SimpleListWalker([])

455

448

self.max_log_length = max_log_length

456

449

450

self.log_level = log_level

451

457

452

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

458

453

# from the ListWalker without it getting destroyed

459

454

self.logbox = ConstrainedListBox(self.log)

463

458

self.log_visible = True

464

459

self.log_wrap = "any"

465

460

466

self.loghandler = UILogHandler(self)

467

468

461

self.rebuild()

469

self.add_log_line(("bold",

470

"Mandos Monitor version " + version))

471

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

462

self.log_message_raw(("bold",

463

"Mandos Monitor version " + version))

464

self.log_message_raw(("bold",

465

"q: Quit ?: Help"))

472

466

473

self.busname = domain + ".Mandos"

467

self.busname = domain + '.Mandos'

474

468

self.main_loop = GLib.MainLoop()

475

469

476

470

def client_not_found(self, key_id, address):

477

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

478

" not be found", address, key_id)

471

self.log_message("Client with address {} and key ID {} could"

472

" not be found".format(address, key_id))

479

473

480

474

def rebuild(self):

481

475

"""This rebuilds the User Interface.

492

486

self.uilist.append(self.logbox)

493

487

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

494

488

495

def add_log_line(self, markup):

489

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

490

"""Log message formatted with timestamp"""

491

if level < self.log_level:

492

return

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

496

501

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

497

502

if self.max_log_length:

498

503

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

499

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

504

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

500

505

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

501

506

coming_from="above")

502

507

self.refresh()

505

510

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

506

511

self.log_visible = not self.log_visible

507

512

self.rebuild()

508

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

513

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

514

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

509

515

510

516

def change_log_display(self):

511

517

"""Change type of log display.

516

522

self.log_wrap = "clip"

517

523

for textwidget in self.log:

518

524

textwidget.set_wrap_mode(self.log_wrap)

519

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

525

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

526

level=0)

520

527

521

528

def find_and_remove_client(self, path, interfaces):

522

529

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

530

537

client = self.clients_dict[path]

531

538

except KeyError:

532

539

# not found?

533

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

540

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

541

.format(path))

534

542

return

535

543

client.delete()

536

544

549

557

proxy_object=client_proxy_object,

550

558

update_hook=self.refresh,

551

559

delete_hook=self.remove_client,

560

logger=self.log_message,

552

561

properties=dict(ifs_and_props[client_interface])),

553

562

path=path)

554

563

574

583

575

584

def run(self):

576

585

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

577

log.addHandler(self.loghandler)

578

self.orig_log_propagate = log.propagate

579

log.propagate = False

580

self.orig_log_level = log.level

581

log.setLevel("INFO")

582

586

self.bus = dbus.SystemBus()

583

587

mandos_dbus_objc = self.bus.get_object(

584

588

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

588

592

mandos_clients = (self.mandos_serv

589

593

.GetAllClientsWithProperties())

590

594

if not mandos_clients:

591

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

595

self.log_message_raw(("bold",

596

"Note: Server has no clients."))

592

597

except dbus.exceptions.DBusException:

593

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

598

self.log_message_raw(("bold",

599

"Note: No Mandos server running."))

594

600

mandos_clients = dbus.Dictionary()

595

601

596

602

(self.mandos_serv

616

622

proxy_object=client_proxy_object,

617

623

properties=client,

618

624

update_hook=self.refresh,

619

delete_hook=self.remove_client),

625

delete_hook=self.remove_client,

626

logger=self.log_message),

620

627

path=path)

621

628

622

629

self.refresh()

624

631

GLib.io_add_watch(

625

632

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

626

633

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

627

glib_safely(self.process_input)))

634

self.process_input))

628

635

self.main_loop.run()

629

636

# Main loop has finished, we should close everything now

630

637

GLib.source_remove(self._input_callback_tag)

634

641

635

642

def stop(self):

636

643

self.main_loop.quit()

637

log.removeHandler(self.loghandler)

638

log.propagate = self.orig_log_propagate

639

644

640

645

def process_input(self, source, condition):

641

646

keys = self.screen.get_input()

674

679

if not self.log_visible:

675

680

self.log_visible = True

676

681

self.rebuild()

677

self.add_log_line(("bold",

678

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

679

"?: Help",

680

"l: Log window toggle",

681

"TAB: Switch window",

682

"w: Wrap (log lines)",

683

"v: Toggle verbose log",

684

))))

685

self.add_log_line(("bold",

686

" ".join(("Clients:",

687

"+: Enable",

688

"-: Disable",

689

"R: Remove",

690

"s: Start new checker",

691

"S: Stop checker",

692

"C: Checker OK",

693

"a: Approve",

694

"d: Deny",

695

))))

682

self.log_message_raw(("bold",

683

" ".

684

join(("q: Quit",

685

"?: Help",

686

"l: Log window toggle",

687

"TAB: Switch window",

688

"w: Wrap (log lines)",

689

"v: Toggle verbose log",

690

))))

691

self.log_message_raw(("bold",

692

" "

693

.join(("Clients:",

694

"+: Enable",

695

"-: Disable",

696

"R: Remove",

697

"s: Start new checker",

698

"S: Stop checker",

699

"C: Checker OK",

700

"a: Approve",

701

"d: Deny"))))

696

702

self.refresh()

697

703

elif key == "tab":

698

704

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

701

707

self.topwidget.set_focus(self.logbox)

702

708

self.refresh()

703

709

elif key == "v":

704

if log.level < logging.INFO:

705

log.setLevel(logging.INFO)

706

log.info("Verbose mode: Off")

710

if self.log_level == 0:

711

self.log_level = 1

712

self.log_message("Verbose mode: Off")

707

713

else:

708

log.setLevel(logging.NOTSET)

709

log.info("Verbose mode: On")

714

self.log_level = 0

715

self.log_message("Verbose mode: On")

710

716

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

711

717

# or key == ">"):

712

718

# pass # xxx end-of-buffer

731

737

return True

732

738

733

739

734

class UILogHandler(logging.Handler):

735

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

736

self.ui = ui

737

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

738

self.setFormatter(

739

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

740

def emit(self, record):

741

msg = self.format(record)

742

if record.levelno > logging.INFO:

743

msg = ("bold", msg)

744

self.ui.add_log_line(msg)

745

746

747

740

ui = UserInterface()

748

741

try:

749

742

ui.run()

750

743

except KeyboardInterrupt:

751

with warnings.catch_warnings():

752

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

753

ui.screen.stop()

754

except Exception:

755

with warnings.catch_warnings():

756

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

757

ui.screen.stop()

744

ui.screen.stop()

745

except Exception as e:

746

ui.log_message(str(e))

747

ui.screen.stop()

758

748

raise