/mandos/trunk : revision 993

To get this branch, use:

bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to mandos-ctl

Committer: Teddy Hogeborn
Date: 2019-03-02 00:26:04 UTC
Revision ID: teddy@recompile.se-20190302002604-r9kpfc7n8qllwg62

mandos-ctl (print_clients): Factor out making strings from printing

* mandos-ctl (table_rows_of_clients): New.

files modified:
mandos-ctl

Show diffs side-by-side

added added

removed removed

mandos-ctl

locale.setlocale(locale.LC_ALL, "")

tablewords = {

"Name": "Name",

"Enabled": "Enabled",

"Timeout": "Timeout",

"LastCheckedOK": "Last Successful Check",

"LastApprovalRequest": "Last Approval Request",

"Created": "Created",

"Interval": "Interval",

"Host": "Host",

"Fingerprint": "Fingerprint",

"KeyID": "Key ID",

"CheckerRunning": "Check Is Running",

"LastEnabled": "Last Enabled",

"ApprovalPending": "Approval Is Pending",

"ApprovedByDefault": "Approved By Default",

"ApprovalDelay": "Approval Delay",

"ApprovalDuration": "Approval Duration",

"Checker": "Checker",

"ExtendedTimeout": "Extended Timeout",

"Expires": "Expires",

"LastCheckerStatus": "Last Checker Status",

}

defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")

domain = "se.recompile"

busname = domain + ".Mandos"

server_path = "/"

215

238

216

239

217

240

def string_to_delta(interval):

218

"""Parse a string and return a datetime.timedelta"""

241

"""Parse a string and return a datetime.timedelta

242

"""

219

243

220

244

try:

221

245

return rfc3339_duration_to_delta(interval)

226

250

227

251

228

252

def parse_pre_1_6_1_interval(interval):

229

"""Parse an interval string as documented by Mandos before 1.6.1,

230

and return a datetime.timedelta

231

253

"""Parse an interval string as documented by Mandos before 1.6.1, and

254

return a datetime.timedelta

232

255

>>> parse_pre_1_6_1_interval('7d')

233

256

datetime.timedelta(7)

234

257

>>> parse_pre_1_6_1_interval('60s')

268

291

return value

269

292

270

293

271

class TableOfClients(object):

272

tablewords = {

273

"Name": "Name",

274

"Enabled": "Enabled",

275

"Timeout": "Timeout",

276

"LastCheckedOK": "Last Successful Check",

277

"LastApprovalRequest": "Last Approval Request",

278

"Created": "Created",

279

"Interval": "Interval",

280

"Host": "Host",

281

"Fingerprint": "Fingerprint",

282

"KeyID": "Key ID",

283

"CheckerRunning": "Check Is Running",

284

"LastEnabled": "Last Enabled",

285

"ApprovalPending": "Approval Is Pending",

286

"ApprovedByDefault": "Approved By Default",

287

"ApprovalDelay": "Approval Delay",

288

"ApprovalDuration": "Approval Duration",

289

"Checker": "Checker",

290

"ExtendedTimeout": "Extended Timeout",

291

"Expires": "Expires",

292

"LastCheckerStatus": "Last Checker Status",

293

}

294

295

def __init__(self, clients, keywords, tablewords=None):

296

self.clients = clients

297

self.keywords = keywords

298

if tablewords is not None:

299

self.tablewords = tablewords

300

301

def __str__(self):

302

return "\n".join(self.rows())

303

304

if sys.version_info.major == 2:

305

__unicode__ = __str__

306

def __str__(self):

307

return str(self).encode(locale.getpreferredencoding())

308

309

def rows(self):

310

format_string = self.row_formatting_string()

311

rows = [self.header_line(format_string)]

312

rows.extend(self.client_line(client, format_string)

313

for client in self.clients)

314

return rows

315

316

def row_formatting_string(self):

317

"Format string used to format table rows"

318

return " ".join("{{{key}:{width}}}".format(

319

width=max(len(self.tablewords[key]),

320

*(len(self.string_from_client(client, key))

321

for client in self.clients)),

322

key=key)

323

for key in self.keywords)

324

325

def string_from_client(self, client, key):

326

return self.valuetostring(client[key], key)

327

328

@staticmethod

294

def print_clients(clients, keywords):

295

print('\n'.join(table_rows_of_clients(clients, keywords)))

296

297

def table_rows_of_clients(clients, keywords):

329

298

def valuetostring(value, keyword):

330

299

if isinstance(value, dbus.Boolean):

331

300

return "Yes" if value else "No"

334

303

return milliseconds_to_string(value)

335

304

return str(value)

336

305

337

def header_line(self, format_string):

338

return format_string.format(**self.tablewords)

339

340

def client_line(self, client, format_string):

341

return format_string.format(

342

**{key: self.string_from_client(client, key)

343

for key in self.keywords})

344

345

346

## Classes for commands.

347

348

# Abstract classes first

349

class Command(object):

350

"""Abstract class for commands"""

351

def run(self, clients):

352

"""Normal commands should implement run_on_one_client(), but

353

commands which want to operate on all clients at the same time

354

can override this run() method instead."""

355

for client in clients:

356

self.run_on_one_client(client)

357

358

class PrintCmd(Command):

359

"""Abstract class for commands printing client details"""

360

all_keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",

361

"Created", "Interval", "Host", "KeyID",

362

"Fingerprint", "CheckerRunning", "LastEnabled",

363

"ApprovalPending", "ApprovedByDefault",

364

"LastApprovalRequest", "ApprovalDelay",

365

"ApprovalDuration", "Checker", "ExtendedTimeout",

366

"Expires", "LastCheckerStatus")

367

def run(self, clients):

368

print(self.output(clients))

369

370

class PropertyCmd(Command):

371

"""Abstract class for Actions for setting one client property"""

372

def run_on_one_client(self, client):

373

"""Set the Client's D-Bus property"""

374

client.Set(client_interface, self.property, self.value_to_set,

375

dbus_interface=dbus.PROPERTIES_IFACE)

376

377

class ValueArgumentMixIn(object):

378

"""Mixin class for commands taking a value as argument"""

379

def __init__(self, value):

380

self.value_to_set = value

381

382

class MillisecondsValueArgumentMixIn(ValueArgumentMixIn):

383

"""Mixin class for commands taking a value argument as

384

milliseconds."""

385

@property

386

def value_to_set(self):

387

return self._vts

388

@value_to_set.setter

389

def value_to_set(self, value):

390

"""When setting, convert value to a datetime.timedelta"""

391

self._vts = string_to_delta(value).total_seconds() * 1000

392

393

# Actual (non-abstract) command classes

394

395

class PrintTableCmd(PrintCmd):

396

def __init__(self, verbose=False):

397

self.verbose = verbose

398

def output(self, clients):

399

if self.verbose:

400

keywords = self.all_keywords

401

else:

402

keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")

403

return str(TableOfClients(clients.values(), keywords))

404

405

class DumpJSONCmd(PrintCmd):

406

def output(self, clients):

407

data = {client["Name"]:

408

{key: self.dbus_boolean_to_bool(client[key])

409

for key in self.all_keywords}

410

for client in clients.values()}

411

return json.dumps(data, indent=4, separators=(',', ': '))

412

@staticmethod

413

def dbus_boolean_to_bool(value):

414

if isinstance(value, dbus.Boolean):

415

value = bool(value)

416

return value

417

418

class IsEnabledCmd(Command):

419

def run_on_one_client(self, client):

420

if self.is_enabled(client):

421

sys.exit(0)

422

sys.exit(1)

423

def is_enabled(self, client):

424

return client.Get(client_interface, "Enabled",

425

dbus_interface=dbus.PROPERTIES_IFACE)

426

427

class RemoveCmd(Command):

428

def __init__(self, mandos):

429

self.mandos = mandos

430

def run_on_one_client(self, client):

431

self.mandos.RemoveClient(client.__dbus_object_path__)

432

433

class ApproveCmd(Command):

434

def run_on_one_client(self, client):

435

client.Approve(dbus.Boolean(True),

436

dbus_interface=client_interface)

437

438

class DenyCmd(Command):

439

def run_on_one_client(self, client):

440

client.Approve(dbus.Boolean(False),

441

dbus_interface=client_interface)

442

443

class EnableCmd(PropertyCmd):

444

property = "Enabled"

445

value_to_set = dbus.Boolean(True)

446

447

class DisableCmd(PropertyCmd):

448

property = "Enabled"

449

value_to_set = dbus.Boolean(False)

450

451

class BumpTimeoutCmd(PropertyCmd):

452

property = "LastCheckedOK"

453

value_to_set = ""

454

455

class StartCheckerCmd(PropertyCmd):

456

property = "CheckerRunning"

457

value_to_set = dbus.Boolean(True)

458

459

class StopCheckerCmd(PropertyCmd):

460

property = "CheckerRunning"

461

value_to_set = dbus.Boolean(False)

462

463

class ApproveByDefaultCmd(PropertyCmd):

464

property = "ApprovedByDefault"

465

value_to_set = dbus.Boolean(True)

466

467

class DenyByDefaultCmd(PropertyCmd):

468

property = "ApprovedByDefault"

469

value_to_set = dbus.Boolean(False)

470

471

class SetCheckerCmd(PropertyCmd, ValueArgumentMixIn):

472

property = "Checker"

473

474

class SetHostCmd(PropertyCmd, ValueArgumentMixIn):

475

property = "Host"

476

477

class SetSecretCmd(PropertyCmd, ValueArgumentMixIn):

478

property = "Secret"

479

480

class SetTimeoutCmd(PropertyCmd, MillisecondsValueArgumentMixIn):

481

property = "Timeout"

482

483

class SetExtendedTimeoutCmd(PropertyCmd,

484

MillisecondsValueArgumentMixIn):

485

property = "ExtendedTimeout"

486

487

class SetIntervalCmd(PropertyCmd, MillisecondsValueArgumentMixIn):

488

property = "Interval"

489

490

class SetApprovalDelayCmd(PropertyCmd,

491

MillisecondsValueArgumentMixIn):

492

property = "ApprovalDelay"

493

494

class SetApprovalDurationCmd(PropertyCmd,

495

MillisecondsValueArgumentMixIn):

496

property = "ApprovalDuration"

306

# Create format string to print table rows

307

format_string = " ".join("{{{key}:{width}}}".format(

308

width=max(len(tablewords[key]),

309

max(len(valuetostring(client[key], key))

310

for client in clients)),

311

key=key)

312

for key in keywords)

313

# Start with header line

314

rows = [format_string.format(**tablewords)]

315

for client in clients:

316

rows.append(format_string

317

.format(**{key: valuetostring(client[key], key)

318

for key in keywords}))

319

return rows

320

497

321

498

322

def has_actions(options):

499

323

return any((options.enable,

527

351

help="Print all fields")

528

352

parser.add_argument("-j", "--dump-json", action="store_true",

529

353

help="Dump client data in JSON format")

530

enable_disable = parser.add_mutually_exclusive_group()

531

enable_disable.add_argument("-e", "--enable", action="store_true",

532

help="Enable client")

533

enable_disable.add_argument("-d", "--disable",

534

action="store_true",

535

help="disable client")

354

parser.add_argument("-e", "--enable", action="store_true",

355

help="Enable client")

356

parser.add_argument("-d", "--disable", action="store_true",

357

help="disable client")

536

358

parser.add_argument("-b", "--bump-timeout", action="store_true",

537

359

help="Bump timeout for client")

538

start_stop_checker = parser.add_mutually_exclusive_group()

539

start_stop_checker.add_argument("--start-checker",

540

action="store_true",

541

help="Start checker for client")

542

start_stop_checker.add_argument("--stop-checker",

543

action="store_true",

544

help="Stop checker for client")

360

parser.add_argument("--start-checker", action="store_true",

361

help="Start checker for client")

362

parser.add_argument("--stop-checker", action="store_true",

363

help="Stop checker for client")

545

364

parser.add_argument("-V", "--is-enabled", action="store_true",

546

365

help="Check if client is enabled")

547

366

parser.add_argument("-r", "--remove", action="store_true",

554

373

help="Set extended timeout for client")

555

374

parser.add_argument("-i", "--interval",

556

375

help="Set checker interval for client")

557

approve_deny_default = parser.add_mutually_exclusive_group()

558

approve_deny_default.add_argument(

559

"--approve-by-default", action="store_true",

560

default=None, dest="approved_by_default",

561

help="Set client to be approved by default")

562

approve_deny_default.add_argument(

563

"--deny-by-default", action="store_false",

564

dest="approved_by_default",

565

help="Set client to be denied by default")

376

parser.add_argument("--approve-by-default", action="store_true",

377

default=None, dest="approved_by_default",

378

help="Set client to be approved by default")

379

parser.add_argument("--deny-by-default", action="store_false",

380

dest="approved_by_default",

381

help="Set client to be denied by default")

566

382

parser.add_argument("--approval-delay",

567

383

help="Set delay before client approve/deny")

568

384

parser.add_argument("--approval-duration",

571

387

parser.add_argument("-s", "--secret",

572

388

type=argparse.FileType(mode="rb"),

573

389

help="Set password blob (file) for client")

574

approve_deny = parser.add_mutually_exclusive_group()

575

approve_deny.add_argument(

576

"-A", "--approve", action="store_true",

577

help="Approve any current client request")

578

approve_deny.add_argument("-D", "--deny", action="store_true",

579

help="Deny any current client request")

390

parser.add_argument("-A", "--approve", action="store_true",

391

help="Approve any current client request")

392

parser.add_argument("-D", "--deny", action="store_true",

393

help="Deny any current client request")

580

394

parser.add_argument("--check", action="store_true",

581

395

help="Run self-test")

582

396

parser.add_argument("client", nargs="*", help="Client name")

591

405

parser.error("--dump-json can only be used alone.")

592

406

if options.all and not has_actions(options):

593

407

parser.error("--all requires an action.")

594

if options.is_enabled and len(options.client) > 1:

595

parser.error("--is-enabled requires exactly one client")

596

408

597

409

try:

598

410

bus = dbus.SystemBus()

606

418

mandos_serv_object_manager = dbus.Interface(

607

419

mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)

608

420

609

commands = []

610

611

if options.dump_json:

612

commands.append(DumpJSONCmd())

613

614

if options.enable:

615

commands.append(EnableCmd())

616

617

if options.disable:

618

commands.append(DisableCmd())

619

620

if options.bump_timeout:

621

commands.append(BumpTimeoutCmd(options.bump_timeout))

622

623

if options.start_checker:

624

commands.append(StartCheckerCmd())

625

626

if options.stop_checker:

627

commands.append(StopCheckerCmd())

628

629

if options.is_enabled:

630

commands.append(IsEnabledCmd())

631

632

if options.remove:

633

commands.append(RemoveCmd(mandos_serv))

634

635

if options.checker is not None:

636

commands.append(SetCheckerCmd())

637

638

if options.timeout is not None:

639

commands.append(SetTimeoutCmd(options.timeout))

640

641

if options.extended_timeout:

642

commands.append(

643

SetExtendedTimeoutCmd(options.extended_timeout))

644

645

if options.interval is not None:

646

command.append(SetIntervalCmd(options.interval))

647

648

if options.approved_by_default is not None:

649

if options.approved_by_default:

650

command.append(ApproveByDefaultCmd())

651

else:

652

command.append(DenyByDefaultCmd())

653

654

if options.approval_delay is not None:

655

command.append(SetApprovalDelayCmd(options.approval_delay))

656

657

if options.approval_duration is not None:

658

command.append(

659

SetApprovalDurationCmd(options.approval_duration))

660

661

if options.host is not None:

662

command.append(SetHostCmd(options.host))

663

664

if options.secret is not None:

665

command.append(SetSecretCmd(options.secret))

666

667

if options.approve:

668

commands.append(ApproveCmd())

669

670

if options.deny:

671

commands.append(DenyCmd())

672

673

# If no command option has been given, show table of clients,

674

# optionally verbosely

675

if not commands:

676

commands.append(PrintTableCmd(verbose=options.verbose))

677

678

421

# block stderr since dbus library prints to stderr

679

422

null = os.open(os.path.devnull, os.O_RDWR)

680

423

stderrcopy = os.dup(sys.stderr.fileno())

713

456

log.critical("Client not found on server: %r", name)

714

457

sys.exit(1)

715

458

716

# Run all commands on clients

717

for command in commands:

718

command.run(clients)

459

if not has_actions(options) and clients:

460

if options.verbose or options.dump_json:

461

keywords = ("Name", "Enabled", "Timeout", "LastCheckedOK",

462

"Created", "Interval", "Host", "KeyID",

463

"Fingerprint", "CheckerRunning",

464

"LastEnabled", "ApprovalPending",

465

"ApprovedByDefault", "LastApprovalRequest",

466

"ApprovalDelay", "ApprovalDuration",

467

"Checker", "ExtendedTimeout", "Expires",

468

"LastCheckerStatus")

469

else:

470

keywords = defaultkeywords

471

472

if options.dump_json:

473

json.dump({client["Name"]: {key:

474

bool(client[key])

475

if isinstance(client[key],

476

dbus.Boolean)

477

else client[key]

478

for key in keywords}

479

for client in clients.values()},

480

fp=sys.stdout, indent=4,

481

separators=(',', ': '))

482

print()

483

else:

484

print_clients(clients.values(), keywords)

485

else:

486

# Process each client in the list by all selected options

487

for client in clients:

488

489

def set_client_prop(prop, value):

490

"""Set a Client D-Bus property"""

491

client.Set(client_interface, prop, value,

492

dbus_interface=dbus.PROPERTIES_IFACE)

493

494

def set_client_prop_ms(prop, value):

495

"""Set a Client D-Bus property, converted

496

from a string to milliseconds."""

497

set_client_prop(prop,

498

string_to_delta(value).total_seconds()

499

* 1000)

500

501

if options.remove:

502

mandos_serv.RemoveClient(client.__dbus_object_path__)

503

if options.enable:

504

set_client_prop("Enabled", dbus.Boolean(True))

505

if options.disable:

506

set_client_prop("Enabled", dbus.Boolean(False))

507

if options.bump_timeout:

508

set_client_prop("LastCheckedOK", "")

509

if options.start_checker:

510

set_client_prop("CheckerRunning", dbus.Boolean(True))

511

if options.stop_checker:

512

set_client_prop("CheckerRunning", dbus.Boolean(False))

513

if options.is_enabled:

514

if client.Get(client_interface, "Enabled",

515

dbus_interface=dbus.PROPERTIES_IFACE):

516

sys.exit(0)

517

else:

518

sys.exit(1)

519

if options.checker is not None:

520

set_client_prop("Checker", options.checker)

521

if options.host is not None:

522

set_client_prop("Host", options.host)

523

if options.interval is not None:

524

set_client_prop_ms("Interval", options.interval)

525

if options.approval_delay is not None:

526

set_client_prop_ms("ApprovalDelay",

527

options.approval_delay)

528

if options.approval_duration is not None:

529

set_client_prop_ms("ApprovalDuration",

530

options.approval_duration)

531

if options.timeout is not None:

532

set_client_prop_ms("Timeout", options.timeout)

533

if options.extended_timeout is not None:

534

set_client_prop_ms("ExtendedTimeout",

535

options.extended_timeout)

536

if options.secret is not None:

537

set_client_prop("Secret",

538

dbus.ByteArray(options.secret.read()))

539

if options.approved_by_default is not None:

540

set_client_prop("ApprovedByDefault",

541

dbus.Boolean(options

542

.approved_by_default))

543

if options.approve:

544

client.Approve(dbus.Boolean(True),

545

dbus_interface=client_interface)

546

elif options.deny:

547

client.Approve(dbus.Boolean(False),

548

dbus_interface=client_interface)

719

549

720

550

721

551

class Test_milliseconds_to_string(unittest.TestCase):

744

574

value = string_to_delta("2h")

745

575

self.assertEqual(value, datetime.timedelta(0, 7200))

746

576

747

class Test_TableOfClients(unittest.TestCase):

748

def setUp(self):

749

self.tablewords = {

750

"Attr1": "X",

751

"AttrTwo": "Yy",

752

"AttrThree": "Zzz",

753

"Bool": "A D-BUS Boolean",

754

"NonDbusBoolean": "A Non-D-BUS Boolean",

755

"Integer": "An Integer",

756

"Timeout": "Timedelta 1",

757

"Interval": "Timedelta 2",

758

"ApprovalDelay": "Timedelta 3",

759

"ApprovalDuration": "Timedelta 4",

760

"ExtendedTimeout": "Timedelta 5",

761

"String": "A String",

762

}

763

self.keywords = ["Attr1", "AttrTwo"]

764

self.clients = [

765

{

766

"Attr1": "x1",

767

"AttrTwo": "y1",

768

"AttrThree": "z1",

769

"Bool": dbus.Boolean(False),

770

"NonDbusBoolean": False,

771

"Integer": 0,

772

"Timeout": 0,

773

"Interval": 1000,

774

"ApprovalDelay": 2000,

775

"ApprovalDuration": 3000,

776

"ExtendedTimeout": 4000,

777

"String": "",

778

779

{

780

"Attr1": "x2",

781

"AttrTwo": "y2",

782

"AttrThree": "z2",

783

"Bool": dbus.Boolean(True),

784

"NonDbusBoolean": True,

785

"Integer": 1,

786

"Timeout": 93785000,

787

"Interval": 93786000,

788

"ApprovalDelay": 93787000,

789

"ApprovalDuration": 93788000,

790

"ExtendedTimeout": 93789000,

791

"String": "A huge string which will not fit," * 10,

792

793

]

794

def test_short_header(self):

795

text = str(TableOfClients(self.clients, self.keywords,

796

self.tablewords))

797

expected_text = """

798

X Yy

799

x1 y1

800

x2 y2

801

"""[1:-1]

802

self.assertEqual(text, expected_text)

803

def test_booleans(self):

804

keywords = ["Bool", "NonDbusBoolean"]

805

text = str(TableOfClients(self.clients, keywords,

806

self.tablewords))

807

expected_text = """

808

A D-BUS Boolean A Non-D-BUS Boolean

809

No False

810

Yes True

811

"""[1:-1]

812

self.assertEqual(text, expected_text)

813

def test_milliseconds_detection(self):

814

keywords = ["Integer", "Timeout", "Interval", "ApprovalDelay",

815

"ApprovalDuration", "ExtendedTimeout"]

816

text = str(TableOfClients(self.clients, keywords,

817

self.tablewords))

818

expected_text = """

819

An Integer Timedelta 1 Timedelta 2 Timedelta 3 Timedelta 4 Timedelta 5

820

0 00:00:00 00:00:01 00:00:02 00:00:03 00:00:04

821

1 1T02:03:05 1T02:03:06 1T02:03:07 1T02:03:08 1T02:03:09

822

"""[1:-1]

823

self.assertEqual(text, expected_text)

824

def test_empty_and_long_string_values(self):

825

keywords = ["String"]

826

text = str(TableOfClients(self.clients, keywords,

827

self.tablewords))

828

expected_text = """

829

A String

830

831

A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,A huge string which will not fit,

832

"""[1:-1]

833

self.assertEqual(text, expected_text)

834

835

836

577

837

578

def should_only_run_tests():

838

579

parser = argparse.ArgumentParser(add_help=False)

Older »