/mandos/release : revision 237.7.722

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.9"

59

domain = 'se.recompile'

60

server_interface = domain + '.Mandos'

61

client_interface = domain + '.Mandos.Client'

62

version = "1.8.8"

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

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)

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

479

474

480

475

def rebuild(self):

481

476

"""This rebuilds the User Interface.

492

487

self.uilist.append(self.logbox)

493

488

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

494

489

495

def add_log_line(self, markup):

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

496

502

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

497

503

if self.max_log_length:

498

504

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

499

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

505

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

500

506

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

501

507

coming_from="above")

502

508

self.refresh()

505

511

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

506

512

self.log_visible = not self.log_visible

507

513

self.rebuild()

508

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

514

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

515

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

509

516

510

517

def change_log_display(self):

511

518

"""Change type of log display.

516

523

self.log_wrap = "clip"

517

524

for textwidget in self.log:

518

525

textwidget.set_wrap_mode(self.log_wrap)

519

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

526

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

527

level=0)

520

528

521

529

def find_and_remove_client(self, path, interfaces):

522

530

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

530

538

client = self.clients_dict[path]

531

539

except KeyError:

532

540

# not found?

533

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

541

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

542

.format(path))

534

543

return

535

544

client.delete()

536

545

549

558

proxy_object=client_proxy_object,

550

559

update_hook=self.refresh,

551

560

delete_hook=self.remove_client,

561

logger=self.log_message,

552

562

properties=dict(ifs_and_props[client_interface])),

553

563

path=path)

554

564

574

584

575

585

def run(self):

576

586

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

587

self.bus = dbus.SystemBus()

583

588

mandos_dbus_objc = self.bus.get_object(

584

589

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

588

593

mandos_clients = (self.mandos_serv

589

594

.GetAllClientsWithProperties())

590

595

if not mandos_clients:

591

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

596

self.log_message_raw(("bold",

597

"Note: Server has no clients."))

592

598

except dbus.exceptions.DBusException:

593

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

599

self.log_message_raw(("bold",

600

"Note: No Mandos server running."))

594

601

mandos_clients = dbus.Dictionary()

595

602

596

603

(self.mandos_serv

616

623

proxy_object=client_proxy_object,

617

624

properties=client,

618

625

update_hook=self.refresh,

619

delete_hook=self.remove_client),

626

delete_hook=self.remove_client,

627

logger=self.log_message),

620

628

path=path)

621

629

622

630

self.refresh()

624

632

GLib.io_add_watch(

625

633

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

626

634

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

627

glib_safely(self.process_input)))

635

self.process_input))

628

636

self.main_loop.run()

629

637

# Main loop has finished, we should close everything now

630

638

GLib.source_remove(self._input_callback_tag)

634

642

635

643

def stop(self):

636

644

self.main_loop.quit()

637

log.removeHandler(self.loghandler)

638

log.propagate = self.orig_log_propagate

639

645

640

646

def process_input(self, source, condition):

641

647

keys = self.screen.get_input()

674

680

if not self.log_visible:

675

681

self.log_visible = True

676

682

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

))))

683

self.log_message_raw(("bold",

684

" ".

685

join(("q: Quit",

686

"?: Help",

687

"l: Log window toggle",

688

"TAB: Switch window",

689

"w: Wrap (log lines)",

690

"v: Toggle verbose log",

691

))))

692

self.log_message_raw(("bold",

693

" "

694

.join(("Clients:",

695

"+: Enable",

696

"-: Disable",

697

"R: Remove",

698

"s: Start new checker",

699

"S: Stop checker",

700

"C: Checker OK",

701

"a: Approve",

702

"d: Deny"))))

696

703

self.refresh()

697

704

elif key == "tab":

698

705

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

701

708

self.topwidget.set_focus(self.logbox)

702

709

self.refresh()

703

710

elif key == "v":

704

if log.level < logging.INFO:

705

log.setLevel(logging.INFO)

706

log.info("Verbose mode: Off")

711

if self.log_level == 0:

712

self.log_level = 1

713

self.log_message("Verbose mode: Off")

707

714

else:

708

log.setLevel(logging.NOTSET)

709

log.info("Verbose mode: On")

715

self.log_level = 0

716

self.log_message("Verbose mode: On")

710

717

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

711

718

# or key == ">"):

712

719

# pass # xxx end-of-buffer

731

738

return True

732

739

733

740

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

741

ui = UserInterface()

748

742

try:

749

743

ui.run()

750

744

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

745

ui.screen.stop()

746

except Exception as e:

747

ui.log_message(str(e))

748

ui.screen.stop()

758

749

raise