/mandos/release : revision 237.7.438

1

#!/usr/bin/python

2

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

3

#

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

5

#

6

7

8

#

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)

39

import os

40

import collections

41

import doctest

42

import json

42

43

44

import dbus

44

45

64

65

"ApprovalDelay": "Approval Delay",

65

66

"ApprovalDuration": "Approval Duration",

66

67

"Checker": "Checker",

67

"ExtendedTimeout": "Extended Timeout"

68

"ExtendedTimeout": "Extended Timeout",

69

"Expires": "Expires",

70

"LastCheckerStatus": "Last Checker Status",

68

71

}

69

72

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

70

73

domain = "se.recompile"

72

75

server_path = "/"

73

76

server_interface = domain + ".Mandos"

74

77

client_interface = domain + ".Mandos.Client"

75

version = "1.7.7"

78

version = "1.7.13"

76

79

77

80

78

81

try:

80

83

except AttributeError:

81

84

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

82

85

86

83

87

def milliseconds_to_string(ms):

84

88

td = datetime.timedelta(0, 0, 0, ms)

85

return ("{days}{hours:02}:{minutes:02}:{seconds:02}".format(

86

days = "{}T".format(td.days) if td.days else "",

87

hours = td.seconds // 3600,

88

minutes = (td.seconds % 3600) // 60,

89

seconds = td.seconds % 60))

89

return ("{days}{hours:02}:{minutes:02}:{seconds:02}"

90

.format(days="{}T".format(td.days) if td.days else "",

91

hours=td.seconds // 3600,

92

minutes=(td.seconds % 3600) // 60,

93

seconds=td.seconds % 60))

90

94

91

95

92

96

def rfc3339_duration_to_delta(duration):

93

97

"""Parse an RFC 3339 "duration" and return a datetime.timedelta

94

98

95

99

>>> rfc3339_duration_to_delta("P7D")

96

100

datetime.timedelta(7)

97

101

>>> rfc3339_duration_to_delta("PT60S")

107

111

>>> rfc3339_duration_to_delta("P1DT3M20S")

108

112

datetime.timedelta(1, 200)

109

113

"""

110

114

111

115

# Parsing an RFC 3339 duration with regular expressions is not

112

116

# possible - there would have to be multiple places for the same

113

117

# values, like seconds. The current code, while more esoteric, is

114

118

# cleaner without depending on a parsing library. If Python had a

115

119

# built-in library for parsing we would use it, but we'd like to

116

120

# avoid excessive use of external libraries.

117

121

118

122

# New type for defining tokens, syntax, and semantics all-in-one

119

123

Token = collections.namedtuple("Token", (

120

124

"regexp", # To match token; if "value" is not None, must have

153

157

frozenset((token_year, token_month,

154

158

token_day, token_time,

155

159

token_week)))

156

# Define starting values

157

value = datetime.timedelta() # Value so far

160

# Define starting values:

161

# Value so far

162

value = datetime.timedelta()

158

163

found_token = None

159

followers = frozenset((token_duration, )) # Following valid tokens

160

s = duration # String left to parse

164

# Following valid tokens

165

followers = frozenset((token_duration, ))

166

# String left to parse

167

s = duration

161

168

# Loop until end token is found

162

169

while found_token is not token_end:

163

170

# Search for any currently valid tokens

187

194

188

195

def string_to_delta(interval):

189

196

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

190

197

191

198

>>> string_to_delta('7d')

192

199

datetime.timedelta(7)

193

200

>>> string_to_delta('60s')

201

208

>>> string_to_delta('5m 30s')

202

209

datetime.timedelta(0, 330)

203

210

"""

204

211

205

212

try:

206

213

return rfc3339_duration_to_delta(interval)

207

214

except ValueError:

208

215

pass

209

216

210

217

value = datetime.timedelta(0)

211

218

regexp = re.compile(r"(\d+)([dsmhw]?)")

212

219

213

220

for num, suffix in regexp.findall(interval):

214

221

if suffix == "d":

215

222

value += datetime.timedelta(int(num))

234

241

"ApprovalDuration", "ExtendedTimeout"):

235

242

return milliseconds_to_string(value)

236

243

return str(value)

237

244

238

245

# Create format string to print table rows

239

246

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

240

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

241

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

242

for client in clients)),

243

key = key)

247

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

248

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

249

for client in clients)),

250

key=key)

244

251

for key in keywords)

245

252

# Print header line

246

253

print(format_string.format(**tablewords))

247

254

for client in clients:

248

print(format_string.format(**{

249

key: valuetostring(client[key], key)

250

for key in keywords }))

255

print(format_string

256

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

257

for key in keywords}))

251

258

252

259

253

260

def has_actions(options):

274

281

def main():

275

282

parser = argparse.ArgumentParser()

276

283

parser.add_argument("--version", action="version",

277

version = "%(prog)s {}".format(version),

284

version="%(prog)s {}".format(version),

278

285

help="show version number and exit")

279

286

parser.add_argument("-a", "--all", action="store_true",

280

287

help="Select all clients")

281

288

parser.add_argument("-v", "--verbose", action="store_true",

282

289

help="Print all fields")

290

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

291

help="Dump client data in JSON format")

283

292

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

284

293

help="Enable client")

285

294

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

324

333

help="Run self-test")

325

334

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

326

335

options = parser.parse_args()

327

336

328

337

if has_actions(options) and not (options.client or options.all):

329

338

parser.error("Options require clients names or --all.")

330

339

if options.verbose and has_actions(options):

331

parser.error("--verbose can only be used alone or with"

332

" --all.")

340

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

341

if options.dump_json and (options.verbose

342

or has_actions(options)):

343

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

333

344

if options.all and not has_actions(options):

334

345

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

335

346

336

347

if options.check:

337

348

fail_count, test_count = doctest.testmod()

338

349

sys.exit(os.EX_OK if fail_count == 0 else 1)

339

350

340

351

try:

341

352

bus = dbus.SystemBus()

342

353

mandos_dbus_objc = bus.get_object(busname, server_path)

343

354

except dbus.exceptions.DBusException:

344

355

print("Could not connect to Mandos server", file=sys.stderr)

345

356

sys.exit(1)

346

357

347

358

mandos_serv = dbus.Interface(mandos_dbus_objc,

348

dbus_interface = server_interface)

359

dbus_interface=server_interface)

349

360

mandos_serv_object_manager = dbus.Interface(

350

mandos_dbus_objc, dbus_interface = dbus.OBJECT_MANAGER_IFACE)

351

352

#block stderr since dbus library prints to stderr

361

mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)

362

363

# block stderr since dbus library prints to stderr

353

364

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

354

365

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

355

366

os.dup2(null, sys.stderr.fileno())

356

367

os.close(null)

357

368

try:

358

369

try:

359

mandos_clients = { path: ifs_and_props[client_interface]

360

for path, ifs_and_props in

361

mandos_serv_object_manager

362

.GetManagedObjects().items()

363

if client_interface in ifs_and_props }

370

mandos_clients = {path: ifs_and_props[client_interface]

371

for path, ifs_and_props in

372

mandos_serv_object_manager

373

.GetManagedObjects().items()

374

if client_interface in ifs_and_props}

364

375

finally:

365

#restore stderr

376

# restore stderr

366

377

os.dup2(stderrcopy, sys.stderr.fileno())

367

378

os.close(stderrcopy)

368

379

except dbus.exceptions.DBusException as e:

369

print("Access denied: Accessing mandos server through D-Bus: {}"

370

.format(e), file=sys.stderr)

380

print("Access denied: "

381

"Accessing mandos server through D-Bus: {}".format(e),

382

file=sys.stderr)

371

383

sys.exit(1)

372

384

373

385

# Compile dict of (clients: properties) to process

374

clients={}

375

386

clients = {}

387

376

388

if options.all or not options.client:

377

clients = { bus.get_object(busname, path): properties

378

for path, properties in mandos_clients.items() }

389

clients = {bus.get_object(busname, path): properties

390

for path, properties in mandos_clients.items()}

379

391

else:

380

392

for name in options.client:

381

393

for path, client in mandos_clients.items():

387

399

print("Client not found on server: {!r}"

388

400

.format(name), file=sys.stderr)

389

401

sys.exit(1)

390

402

391

403

if not has_actions(options) and clients:

392

if options.verbose:

404

if options.verbose or options.dump_json:

393

405

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

394

406

"Created", "Interval", "Host", "Fingerprint",

395

407

"CheckerRunning", "LastEnabled",

396

408

"ApprovalPending", "ApprovedByDefault",

397

409

"LastApprovalRequest", "ApprovalDelay",

398

410

"ApprovalDuration", "Checker",

399

"ExtendedTimeout")

411

"ExtendedTimeout", "Expires",

412

"LastCheckerStatus")

400

413

else:

401

414

keywords = defaultkeywords

402

403

print_clients(clients.values(), keywords)

415

416

if options.dump_json:

417

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

418

bool(client[key])

419

if isinstance(client[key],

420

dbus.Boolean)

421

else client[key]

422

for key in keywords}

423

for client in clients.values()},

424

fp=sys.stdout, indent=4,

425

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

426

print()

427

else:

428

print_clients(clients.values(), keywords)

404

429

else:

405

430

# Process each client in the list by all selected options

406

431

for client in clients:

407

432

408

433

def set_client_prop(prop, value):

409

434

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

410

435

client.Set(client_interface, prop, value,

411

436

dbus_interface=dbus.PROPERTIES_IFACE)

412

437

413

438

def set_client_prop_ms(prop, value):

414

439

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

415

440

from a string to milliseconds."""

416

441

set_client_prop(prop,

417

442

string_to_delta(value).total_seconds()

418

443

* 1000)

419

444

420

445

if options.remove:

421

446

mandos_serv.RemoveClient(client.__dbus_object_path__)

422

447

if options.enable:

430

455

if options.stop_checker:

431

456

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

432

457

if options.is_enabled:

433

sys.exit(0 if client.Get(client_interface,

434

"Enabled",

435

dbus_interface=

436

dbus.PROPERTIES_IFACE)

437

else 1)

458

if client.Get(client_interface, "Enabled",

459

dbus_interface=dbus.PROPERTIES_IFACE):

460

sys.exit(0)

461

else:

462

sys.exit(1)

438

463

if options.checker is not None:

439

464

set_client_prop("Checker", options.checker)

440

465

if options.host is not None: