/mandos/trunk : revision 1062

1

#!/usr/bin/python

2

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

3

#

2

# -*- mode: python; coding: utf-8; after-save-hook: (lambda () (let ((command (if (and (boundp 'tramp-file-name-structure) (string-match (car tramp-file-name-structure) (buffer-file-name))) (tramp-file-name-localname (tramp-dissect-file-name (buffer-file-name))) (buffer-file-name)))) (if (= (shell-command (format "%s --check" (shell-quote-argument command)) "*Test*") 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w)) (kill-buffer "*Test*")) (display-buffer "*Test*")))); -*-

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

6

7

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

5

#

6

7

8

#

9

# This file is part of Mandos.

10

#

11

# Mandos is free software: you can redistribute it and/or modify it

12

# under the terms of the GNU General Public License as published by

11

13

# the Free Software Foundation, either version 3 of the License, or

12

14

# (at your option) any later version.

13

15

#

14

# This program is distributed in the hope that it will be useful,

15

# but WITHOUT ANY WARRANTY; without even the implied warranty of

16

# Mandos is distributed in the hope that it will be useful, but

17

# WITHOUT ANY WARRANTY; without even the implied warranty of

16

18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17

19

# GNU General Public License for more details.

18

#

20

#

19

21

# You should have received a copy of the GNU General Public License

20

# along with this program. If not, see <http://www.gnu.org/licenses/>.

21

#

22

# along with Mandos. If not, see <http://www.gnu.org/licenses/>.

23

#

22

24

# Contact the authors at <mandos@recompile.se>.

23

#

25

#

24

26

25

27

from __future__ import (division, absolute_import, print_function,

26

28

unicode_literals)

27

29

30

try:

31

from future_builtins import *

32

except ImportError:

33

pass

34

28

35

import sys

29

import dbus

30

36

import argparse

31

37

import locale

32

38

import datetime

33

39

import re

34

40

import os

41

import collections

42

import json

43

import unittest

44

import logging

45

import io

46

import tempfile

47

import contextlib

48

49

import dbus

50

51

# Show warnings by default

52

if not sys.warnoptions:

53

import warnings

54

warnings.simplefilter("default")

55

56

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

57

logging.basicConfig(level="INFO", # Show info level messages

58

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

59

60

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

61

62

if sys.version_info.major == 2:

63

str = unicode

35

64

36

65

locale.setlocale(locale.LC_ALL, "")

37

66

38

tablewords = {

39

"Name": "Name",

40

"Enabled": "Enabled",

41

"Timeout": "Timeout",

42

"LastCheckedOK": "Last Successful Check",

43

"LastApprovalRequest": "Last Approval Request",

44

"Created": "Created",

45

"Interval": "Interval",

46

"Host": "Host",

47

"Fingerprint": "Fingerprint",

48

"CheckerRunning": "Check Is Running",

49

"LastEnabled": "Last Enabled",

50

"ApprovalPending": "Approval Is Pending",

51

"ApprovedByDefault": "Approved By Default",

52

"ApprovalDelay": "Approval Delay",

53

"ApprovalDuration": "Approval Duration",

54

"Checker": "Checker",

55

"ExtendedTimeout" : "Extended Timeout"

56

}

57

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

58

domain = "se.recompile"

59

busname = domain + ".Mandos"

60

server_path = "/"

61

server_interface = domain + ".Mandos"

62

client_interface = domain + ".Mandos.Client"

63

version = "1.4.1"

64

65

def timedelta_to_milliseconds(td):

66

"""Convert a datetime.timedelta object to milliseconds"""

67

return ((td.days * 24 * 60 * 60 * 1000)

68

+ (td.seconds * 1000)

69

+ (td.microseconds // 1000))

70

71

def milliseconds_to_string(ms):

72

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

73

return ("%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"

74

% { "days": "%dT" % td.days if td.days else "",

75

"hours": td.seconds // 3600,

76

"minutes": (td.seconds % 3600) // 60,

77

"seconds": td.seconds % 60,

78

})

79

80

def string_to_delta(interval):

81

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

82

83

>>> string_to_delta("7d")

84

datetime.timedelta(7)

85

>>> string_to_delta("60s")

86

datetime.timedelta(0, 60)

87

>>> string_to_delta("60m")

88

datetime.timedelta(0, 3600)

89

>>> string_to_delta("24h")

90

datetime.timedelta(1)

91

>>> string_to_delta("1w")

92

datetime.timedelta(7)

93

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

94

datetime.timedelta(0, 330)

95

"""

96

timevalue = datetime.timedelta(0)

97

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

98

99

for s in regexp.findall(interval):

100

try:

101

suffix = unicode(s[-1])

102

value = int(s[:-1])

103

if suffix == "d":

104

delta = datetime.timedelta(value)

105

elif suffix == "s":

106

delta = datetime.timedelta(0, value)

107

elif suffix == "m":

108

delta = datetime.timedelta(0, 0, 0, 0, value)

109

elif suffix == "h":

110

delta = datetime.timedelta(0, 0, 0, 0, 0, value)

111

elif suffix == "w":

112

delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

113

else:

114

raise ValueError

115

except (ValueError, IndexError):

116

raise ValueError

117

timevalue += delta

118

return timevalue

119

120

def print_clients(clients, keywords):

121

def valuetostring(value, keyword):

122

if type(value) is dbus.Boolean:

123

return "Yes" if value else "No"

124

if keyword in ("Timeout", "Interval", "ApprovalDelay",

125

"ApprovalDuration"):

126

return milliseconds_to_string(value)

127

return unicode(value)

128

129

# Create format string to print table rows

130

format_string = " ".join("%%-%ds" %

131

max(len(tablewords[key]),

132

max(len(valuetostring(client[key],

133

key))

134

for client in

135

clients))

136

for key in keywords)

137

# Print header line

138

print(format_string % tuple(tablewords[key] for key in keywords))

139

for client in clients:

140

print(format_string % tuple(valuetostring(client[key], key)

141

for key in keywords))

142

143

def has_actions(options):

144

return any((options.enable,

145

options.disable,

146

options.bump_timeout,

147

options.start_checker,

148

options.stop_checker,

149

options.is_enabled,

150

options.remove,

151

options.checker is not None,

152

options.timeout is not None,

153

options.extended_timeout is not None,

154

options.interval is not None,

155

options.approved_by_default is not None,

156

options.approval_delay is not None,

157

options.approval_duration is not None,

158

options.host is not None,

159

options.secret is not None,

160

options.approve,

161

options.deny))

67

dbus_busname_domain = "se.recompile"

68

dbus_busname = dbus_busname_domain + ".Mandos"

69

server_dbus_path = "/"

70

server_dbus_interface = dbus_busname_domain + ".Mandos"

71

client_dbus_interface = dbus_busname_domain + ".Mandos.Client"

72

del dbus_busname_domain

73

version = "1.8.3"

74

75

76

try:

77

dbus.OBJECT_MANAGER_IFACE

78

except AttributeError:

79

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

80

162

81

163

82

def main():

164

83

parser = argparse.ArgumentParser()

84

85

add_command_line_options(parser)

86

87

options = parser.parse_args()

88

89

check_option_syntax(parser, options)

90

91

clientnames = options.client

92

93

if options.debug:

94

log.setLevel(logging.DEBUG)

95

96

try:

97

bus = dbus.SystemBus()

98

log.debug("D-Bus: Connect to: (busname=%r, path=%r)",

99

dbus_busname, server_dbus_path)

100

mandos_dbus_objc = bus.get_object(dbus_busname,

101

server_dbus_path)

102

except dbus.exceptions.DBusException:

103

log.critical("Could not connect to Mandos server")

104

sys.exit(1)

105

106

mandos_serv = dbus.Interface(mandos_dbus_objc,

107

dbus_interface=server_dbus_interface)

108

mandos_serv_object_manager = dbus.Interface(

109

mandos_dbus_objc, dbus_interface=dbus.OBJECT_MANAGER_IFACE)

110

111

# Filter out log message from dbus module

112

dbus_logger = logging.getLogger("dbus.proxies")

113

class NullFilter(logging.Filter):

114

def filter(self, record):

115

return False

116

dbus_filter = NullFilter()

117

try:

118

dbus_logger.addFilter(dbus_filter)

119

log.debug("D-Bus: %s:%s:%s.GetManagedObjects()", dbus_busname,

120

server_dbus_path, dbus.OBJECT_MANAGER_IFACE)

121

mandos_clients = {path: ifs_and_props[client_dbus_interface]

122

for path, ifs_and_props in

123

mandos_serv_object_manager

124

.GetManagedObjects().items()

125

if client_dbus_interface in ifs_and_props}

126

except dbus.exceptions.DBusException as e:

127

log.critical("Failed to access Mandos server through D-Bus:"

128

"\n%s", e)

129

sys.exit(1)

130

finally:

131

# restore dbus logger

132

dbus_logger.removeFilter(dbus_filter)

133

134

# Compile dict of (clients: properties) to process

135

clients = {}

136

137

if not clientnames:

138

clients = {objpath: properties

139

for objpath, properties in mandos_clients.items()}

140

else:

141

for name in clientnames:

142

for objpath, properties in mandos_clients.items():

143

if properties["Name"] == name:

144

clients[objpath] = properties

145

break

146

else:

147

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

148

sys.exit(1)

149

150

# Run all commands on clients

151

commands = commands_from_options(options)

152

for command in commands:

153

command.run(clients, bus, mandos_serv)

154

155

156

def add_command_line_options(parser):

165

157

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

166

version = "%%prog %s" % version,

158

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

167

159

help="show version number and exit")

168

160

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

169

161

help="Select all clients")

170

162

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

171

163

help="Print all fields")

172

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

173

help="Enable client")

174

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

175

help="disable client")

164

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

165

help="Dump client data in JSON format")

166

enable_disable = parser.add_mutually_exclusive_group()

167

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

168

help="Enable client")

169

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

170

action="store_true",

171

help="disable client")

176

172

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

177

173

help="Bump timeout for client")

178

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

179

help="Start checker for client")

180

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

181

help="Stop checker for client")

174

start_stop_checker = parser.add_mutually_exclusive_group()

175

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

176

action="store_true",

177

help="Start checker for client")

178

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

179

action="store_true",

180

help="Stop checker for client")

182

181

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

183

182

help="Check if client is enabled")

184

183

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

185

184

help="Remove client")

186

185

parser.add_argument("-c", "--checker",

187

186

help="Set checker command for client")

188

parser.add_argument("-t", "--timeout",

187

parser.add_argument("-t", "--timeout", type=string_to_delta,

189

188

help="Set timeout for client")

190

parser.add_argument("--extended-timeout",

189

parser.add_argument("--extended-timeout", type=string_to_delta,

191

190

help="Set extended timeout for client")

192

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

191

parser.add_argument("-i", "--interval", type=string_to_delta,

193

192

help="Set checker interval for client")

194

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

195

default=None, dest="approved_by_default",

196

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

197

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

198

dest="approved_by_default",

199

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

200

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

193

approve_deny_default = parser.add_mutually_exclusive_group()

194

approve_deny_default.add_argument(

195

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

196

default=None, dest="approved_by_default",

197

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

198

approve_deny_default.add_argument(

199

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

200

dest="approved_by_default",

201

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

202

parser.add_argument("--approval-delay", type=string_to_delta,

201

203

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

202

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

204

parser.add_argument("--approval-duration", type=string_to_delta,

203

205

help="Set duration of one client approval")

204

206

parser.add_argument("-H", "--host", help="Set host for client")

205

parser.add_argument("-s", "--secret", type=file,

207

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

208

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

206

209

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

207

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

208

help="Approve any current client request")

209

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

210

help="Deny any current client request")

210

approve_deny = parser.add_mutually_exclusive_group()

211

approve_deny.add_argument(

212

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

213

help="Approve any current client request")

214

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

215

help="Deny any current client request")

216

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

217

help="Debug mode (show D-Bus commands)")

218

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

219

help="Run self-test")

211

220

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

212

options = parser.parse_args()

213

214

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

221

222

223

def string_to_delta(interval):

224

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

225

226

try:

227

return rfc3339_duration_to_delta(interval)

228

except ValueError as e:

229

log.warning("%s - Parsing as pre-1.6.1 interval instead",

230

' '.join(e.args))

231

return parse_pre_1_6_1_interval(interval)

232

233

234

def rfc3339_duration_to_delta(duration):

235

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

236

237

>>> rfc3339_duration_to_delta("P7D")

238

datetime.timedelta(7)

239

>>> rfc3339_duration_to_delta("PT60S")

240

datetime.timedelta(0, 60)

241

>>> rfc3339_duration_to_delta("PT60M")

242

datetime.timedelta(0, 3600)

243

>>> rfc3339_duration_to_delta("P60M")

244

datetime.timedelta(1680)

245

>>> rfc3339_duration_to_delta("PT24H")

246

datetime.timedelta(1)

247

>>> rfc3339_duration_to_delta("P1W")

248

datetime.timedelta(7)

249

>>> rfc3339_duration_to_delta("PT5M30S")

250

datetime.timedelta(0, 330)

251

>>> rfc3339_duration_to_delta("P1DT3M20S")

252

datetime.timedelta(1, 200)

253

>>> # Can not be empty:

254

>>> rfc3339_duration_to_delta("")

255

Traceback (most recent call last):

256

...

257

ValueError: Invalid RFC 3339 duration: u''

258

>>> # Must start with "P":

259

>>> rfc3339_duration_to_delta("1D")

260

Traceback (most recent call last):

261

...

262

ValueError: Invalid RFC 3339 duration: u'1D'

263

>>> # Must use correct order

264

>>> rfc3339_duration_to_delta("PT1S2M")

265

Traceback (most recent call last):

266

...

267

ValueError: Invalid RFC 3339 duration: u'PT1S2M'

268

>>> # Time needs time marker

269

>>> rfc3339_duration_to_delta("P1H2S")

270

Traceback (most recent call last):

271

...

272

ValueError: Invalid RFC 3339 duration: u'P1H2S'

273

>>> # Weeks can not be combined with anything else

274

>>> rfc3339_duration_to_delta("P1D2W")

275

Traceback (most recent call last):

276

...

277

ValueError: Invalid RFC 3339 duration: u'P1D2W'

278

>>> rfc3339_duration_to_delta("P2W2H")

279

Traceback (most recent call last):

280

...

281

ValueError: Invalid RFC 3339 duration: u'P2W2H'

282

"""

283

284

# Parsing an RFC 3339 duration with regular expressions is not

285

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

286

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

287

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

288

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

289

# avoid excessive use of external libraries.

290

291

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

292

Token = collections.namedtuple("Token", (

293

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

294

# a "group" containing digits

295

"value", # datetime.timedelta or None

296

"followers")) # Tokens valid after this token

297

# RFC 3339 "duration" tokens, syntax, and semantics; taken from

298

# the "duration" ABNF definition in RFC 3339, Appendix A.

299

token_end = Token(re.compile(r"$"), None, frozenset())

300

token_second = Token(re.compile(r"(\d+)S"),

301

datetime.timedelta(seconds=1),

302

frozenset((token_end, )))

303

token_minute = Token(re.compile(r"(\d+)M"),

304

datetime.timedelta(minutes=1),

305

frozenset((token_second, token_end)))

306

token_hour = Token(re.compile(r"(\d+)H"),

307

datetime.timedelta(hours=1),

308

frozenset((token_minute, token_end)))

309

token_time = Token(re.compile(r"T"),

310

None,

311

frozenset((token_hour, token_minute,

312

token_second)))

313

token_day = Token(re.compile(r"(\d+)D"),

314

datetime.timedelta(days=1),

315

frozenset((token_time, token_end)))

316

token_month = Token(re.compile(r"(\d+)M"),

317

datetime.timedelta(weeks=4),

318

frozenset((token_day, token_end)))

319

token_year = Token(re.compile(r"(\d+)Y"),

320

datetime.timedelta(weeks=52),

321

frozenset((token_month, token_end)))

322

token_week = Token(re.compile(r"(\d+)W"),

323

datetime.timedelta(weeks=1),

324

frozenset((token_end, )))

325

token_duration = Token(re.compile(r"P"), None,

326

frozenset((token_year, token_month,

327

token_day, token_time,

328

token_week)))

329

# Define starting values:

330

# Value so far

331

value = datetime.timedelta()

332

found_token = None

333

# Following valid tokens

334

followers = frozenset((token_duration, ))

335

# String left to parse

336

s = duration

337

# Loop until end token is found

338

while found_token is not token_end:

339

# Search for any currently valid tokens

340

for token in followers:

341

match = token.regexp.match(s)

342

if match is not None:

343

# Token found

344

if token.value is not None:

345

# Value found, parse digits

346

factor = int(match.group(1), 10)

347

# Add to value so far

348

value += factor * token.value

349

# Strip token from string

350

s = token.regexp.sub("", s, 1)

351

# Go to found token

352

found_token = token

353

# Set valid next tokens

354

followers = found_token.followers

355

break

356

else:

357

# No currently valid tokens were found

358

raise ValueError("Invalid RFC 3339 duration: {!r}"

359

.format(duration))

360

# End token found

361

return value

362

363

364

def parse_pre_1_6_1_interval(interval):

365

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

366

and return a datetime.timedelta

367

368

>>> parse_pre_1_6_1_interval('7d')

369

datetime.timedelta(7)

370

>>> parse_pre_1_6_1_interval('60s')

371

datetime.timedelta(0, 60)

372

>>> parse_pre_1_6_1_interval('60m')

373

datetime.timedelta(0, 3600)

374

>>> parse_pre_1_6_1_interval('24h')

375

datetime.timedelta(1)

376

>>> parse_pre_1_6_1_interval('1w')

377

datetime.timedelta(7)

378

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

379

datetime.timedelta(0, 330)

380

>>> parse_pre_1_6_1_interval('')

381

datetime.timedelta(0)

382

>>> # Ignore unknown characters, allow any order and repetitions

383

>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')

384

datetime.timedelta(2, 480, 18000)

385

386

"""

387

388

value = datetime.timedelta(0)

389

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

390

391

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

392

if suffix == "d":

393

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

394

elif suffix == "s":

395

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

396

elif suffix == "m":

397

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

398

elif suffix == "h":

399

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

400

elif suffix == "w":

401

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

402

elif suffix == "":

403

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

404

return value

405

406

407

def check_option_syntax(parser, options):

408

"""Apply additional restrictions on options, not expressible in

409

argparse"""

410

411

def has_actions(options):

412

return any((options.enable,

413

options.disable,

414

options.bump_timeout,

415

options.start_checker,

416

options.stop_checker,

417

options.is_enabled,

418

options.remove,

419

options.checker is not None,

420

options.timeout is not None,

421

options.extended_timeout is not None,

422

options.interval is not None,

423

options.approved_by_default is not None,

424

options.approval_delay is not None,

425

options.approval_duration is not None,

426

options.host is not None,

427

options.secret is not None,

428

options.approve,

429

options.deny))

430

431

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

215

432

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

216

433

if options.verbose and has_actions(options):

217

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

218

" --all.")

434

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

435

if options.dump_json and (options.verbose

436

or has_actions(options)):

437

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

219

438

if options.all and not has_actions(options):

220

439

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

221

222

try:

223

bus = dbus.SystemBus()

224

mandos_dbus_objc = bus.get_object(busname, server_path)

225

except dbus.exceptions.DBusException:

226

print("Could not connect to Mandos server",

227

file=sys.stderr)

440

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

441

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

442

if options.remove:

443

options.remove = False

444

if has_actions(options) and not options.deny:

445

parser.error("--remove can only be combined with --deny")

446

options.remove = True

447

448

449

def commands_from_options(options):

450

451

commands = []

452

453

if options.is_enabled:

454

commands.append(IsEnabledCmd())

455

456

if options.approve:

457

commands.append(ApproveCmd())

458

459

if options.deny:

460

commands.append(DenyCmd())

461

462

if options.remove:

463

commands.append(RemoveCmd())

464

465

if options.dump_json:

466

commands.append(DumpJSONCmd())

467

468

if options.enable:

469

commands.append(EnableCmd())

470

471

if options.disable:

472

commands.append(DisableCmd())

473

474

if options.bump_timeout:

475

commands.append(BumpTimeoutCmd())

476

477

if options.start_checker:

478

commands.append(StartCheckerCmd())

479

480

if options.stop_checker:

481

commands.append(StopCheckerCmd())

482

483

if options.approved_by_default is not None:

484

if options.approved_by_default:

485

commands.append(ApproveByDefaultCmd())

486

else:

487

commands.append(DenyByDefaultCmd())

488

489

if options.checker is not None:

490

commands.append(SetCheckerCmd(options.checker))

491

492

if options.host is not None:

493

commands.append(SetHostCmd(options.host))

494

495

if options.secret is not None:

496

commands.append(SetSecretCmd(options.secret))

497

498

if options.timeout is not None:

499

commands.append(SetTimeoutCmd(options.timeout))

500

501

if options.extended_timeout:

502

commands.append(

503

SetExtendedTimeoutCmd(options.extended_timeout))

504

505

if options.interval is not None:

506

commands.append(SetIntervalCmd(options.interval))

507

508

if options.approval_delay is not None:

509

commands.append(SetApprovalDelayCmd(options.approval_delay))

510

511

if options.approval_duration is not None:

512

commands.append(

513

SetApprovalDurationCmd(options.approval_duration))

514

515

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

516

# optionally verbosely

517

if not commands:

518

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

519

520

return commands

521

522

523

class Command(object):

524

"""Abstract class for commands"""

525

def run(self, clients, bus=None, mandos=None):

526

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

527

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

528

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

529

self.mandos = mandos

530

for clientpath, properties in clients.items():

531

log.debug("D-Bus: Connect to: (busname=%r, path=%r)",

532

dbus_busname, str(clientpath))

533

client = bus.get_object(dbus_busname, clientpath)

534

self.run_on_one_client(client, properties)

535

536

537

class IsEnabledCmd(Command):

538

def run(self, clients, bus=None, mandos=None):

539

client, properties = next(iter(clients.items()))

540

if self.is_enabled(client, properties):

541

sys.exit(0)

228

542

sys.exit(1)

229

230

mandos_serv = dbus.Interface(mandos_dbus_objc,

231

dbus_interface = server_interface)

232

233

#block stderr since dbus library prints to stderr

234

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

235

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

236

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

237

os.close(null)

238

try:

543

def is_enabled(self, client, properties):

544

return properties["Enabled"]

545

546

547

class ApproveCmd(Command):

548

def run_on_one_client(self, client, properties):

549

log.debug("D-Bus: %s:%s:%s.Approve(True)", dbus_busname,

550

client.__dbus_object_path__, client_dbus_interface)

551

client.Approve(dbus.Boolean(True),

552

dbus_interface=client_dbus_interface)

553

554

555

class DenyCmd(Command):

556

def run_on_one_client(self, client, properties):

557

log.debug("D-Bus: %s:%s:%s.Approve(False)", dbus_busname,

558

client.__dbus_object_path__, client_dbus_interface)

559

client.Approve(dbus.Boolean(False),

560

dbus_interface=client_dbus_interface)

561

562

563

class RemoveCmd(Command):

564

def run_on_one_client(self, client, properties):

565

log.debug("D-Bus: %s:%s:%s.RemoveClient(%r)", dbus_busname,

566

server_dbus_path, server_dbus_interface,

567

str(client.__dbus_object_path__))

568

self.mandos.RemoveClient(client.__dbus_object_path__)

569

570

571

class OutputCmd(Command):

572

"""Abstract class for commands outputting client details"""

573

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

574

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

575

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

576

"ApprovalPending", "ApprovedByDefault",

577

"LastApprovalRequest", "ApprovalDelay",

578

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

579

"Expires", "LastCheckerStatus")

580

581

def run(self, clients, bus=None, mandos=None):

582

print(self.output(clients.values()))

583

584

def output(self, clients):

585

raise NotImplementedError()

586

587

588

class DumpJSONCmd(OutputCmd):

589

def output(self, clients):

590

data = {client["Name"]:

591

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

592

for key in self.all_keywords}

593

for client in clients.values()}

594

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

595

596

@staticmethod

597

def dbus_boolean_to_bool(value):

598

if isinstance(value, dbus.Boolean):

599

value = bool(value)

600

return value

601

602

603

class PrintTableCmd(OutputCmd):

604

def __init__(self, verbose=False):

605

self.verbose = verbose

606

607

def output(self, clients):

608

default_keywords = ("Name", "Enabled", "Timeout",

609

"LastCheckedOK")

610

keywords = default_keywords

611

if self.verbose:

612

keywords = self.all_keywords

613

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

614

615

class TableOfClients(object):

616

tableheaders = {

617

"Name": "Name",

618

"Enabled": "Enabled",

619

"Timeout": "Timeout",

620

"LastCheckedOK": "Last Successful Check",

621

"LastApprovalRequest": "Last Approval Request",

622

"Created": "Created",

623

"Interval": "Interval",

624

"Host": "Host",

625

"Fingerprint": "Fingerprint",

626

"KeyID": "Key ID",

627

"CheckerRunning": "Check Is Running",

628

"LastEnabled": "Last Enabled",

629

"ApprovalPending": "Approval Is Pending",

630

"ApprovedByDefault": "Approved By Default",

631

"ApprovalDelay": "Approval Delay",

632

"ApprovalDuration": "Approval Duration",

633

"Checker": "Checker",

634

"ExtendedTimeout": "Extended Timeout",

635

"Expires": "Expires",

636

"LastCheckerStatus": "Last Checker Status",

637

}

638

639

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

640

self.clients = clients

641

self.keywords = keywords

642

if tableheaders is not None:

643

self.tableheaders = tableheaders

644

645

def __str__(self):

646

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

647

648

if sys.version_info.major == 2:

649

__unicode__ = __str__

650

def __str__(self):

651

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

652

653

def rows(self):

654

format_string = self.row_formatting_string()

655

rows = [self.header_line(format_string)]

656

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

657

for client in self.clients)

658

return rows

659

660

def row_formatting_string(self):

661

"Format string used to format table rows"

662

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

663

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

664

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

665

for client in self.clients)),

666

key=key)

667

for key in self.keywords)

668

669

def string_from_client(self, client, key):

670

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

671

672

@classmethod

673

def valuetostring(cls, value, keyword):

674

if isinstance(value, dbus.Boolean):

675

return "Yes" if value else "No"

676

if keyword in ("Timeout", "Interval", "ApprovalDelay",

677

"ApprovalDuration", "ExtendedTimeout"):

678

return cls.milliseconds_to_string(value)

679

return str(value)

680

681

def header_line(self, format_string):

682

return format_string.format(**self.tableheaders)

683

684

def client_line(self, client, format_string):

685

return format_string.format(

686

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

687

for key in self.keywords})

688

689

@staticmethod

690

def milliseconds_to_string(ms):

691

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

692

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

693

.format(days="{}T".format(td.days)

694

if td.days else "",

695

hours=td.seconds // 3600,

696

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

697

seconds=td.seconds % 60))

698

699

700

class PropertyCmd(Command):

701

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

702

703

def run_on_one_client(self, client, properties):

704

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

705

log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", dbus_busname,

706

client.__dbus_object_path__,

707

dbus.PROPERTIES_IFACE, client_dbus_interface,

708

self.propname, self.value_to_set

709

if not isinstance(self.value_to_set, dbus.Boolean)

710

else bool(self.value_to_set))

711

client.Set(client_dbus_interface, self.propname,

712

self.value_to_set,

713

dbus_interface=dbus.PROPERTIES_IFACE)

714

715

@property

716

def propname(self):

717

raise NotImplementedError()

718

719

720

class EnableCmd(PropertyCmd):

721

propname = "Enabled"

722

value_to_set = dbus.Boolean(True)

723

724

725

class DisableCmd(PropertyCmd):

726

propname = "Enabled"

727

value_to_set = dbus.Boolean(False)

728

729

730

class BumpTimeoutCmd(PropertyCmd):

731

propname = "LastCheckedOK"

732

value_to_set = ""

733

734

735

class StartCheckerCmd(PropertyCmd):

736

propname = "CheckerRunning"

737

value_to_set = dbus.Boolean(True)

738

739

740

class StopCheckerCmd(PropertyCmd):

741

propname = "CheckerRunning"

742

value_to_set = dbus.Boolean(False)

743

744

745

class ApproveByDefaultCmd(PropertyCmd):

746

propname = "ApprovedByDefault"

747

value_to_set = dbus.Boolean(True)

748

749

750

class DenyByDefaultCmd(PropertyCmd):

751

propname = "ApprovedByDefault"

752

value_to_set = dbus.Boolean(False)

753

754

755

class PropertyValueCmd(PropertyCmd):

756

"""Abstract class for PropertyCmd recieving a value as argument"""

757

def __init__(self, value):

758

self.value_to_set = value

759

760

761

class SetCheckerCmd(PropertyValueCmd):

762

propname = "Checker"

763

764

765

class SetHostCmd(PropertyValueCmd):

766

propname = "Host"

767

768

769

class SetSecretCmd(PropertyValueCmd):

770

propname = "Secret"

771

772

@property

773

def value_to_set(self):

774

return self._vts

775

776

@value_to_set.setter

777

def value_to_set(self, value):

778

"""When setting, read data from supplied file object"""

779

self._vts = value.read()

780

value.close()

781

782

783

class MillisecondsPropertyValueArgumentCmd(PropertyValueCmd):

784

"""Abstract class for PropertyValueCmd taking a value argument as

785

a datetime.timedelta() but should store it as milliseconds."""

786

787

@property

788

def value_to_set(self):

789

return self._vts

790

791

@value_to_set.setter

792

def value_to_set(self, value):

793

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

794

self._vts = int(round(value.total_seconds() * 1000))

795

796

797

class SetTimeoutCmd(MillisecondsPropertyValueArgumentCmd):

798

propname = "Timeout"

799

800

801

class SetExtendedTimeoutCmd(MillisecondsPropertyValueArgumentCmd):

802

propname = "ExtendedTimeout"

803

804

805

class SetIntervalCmd(MillisecondsPropertyValueArgumentCmd):

806

propname = "Interval"

807

808

809

class SetApprovalDelayCmd(MillisecondsPropertyValueArgumentCmd):

810

propname = "ApprovalDelay"

811

812

813

class SetApprovalDurationCmd(MillisecondsPropertyValueArgumentCmd):

814

propname = "ApprovalDuration"

815

816

817

818

class Test_string_to_delta(unittest.TestCase):

819

def test_handles_basic_rfc3339(self):

820

self.assertEqual(string_to_delta("PT0S"),

821

datetime.timedelta())

822

self.assertEqual(string_to_delta("P0D"),

823

datetime.timedelta())

824

self.assertEqual(string_to_delta("PT1S"),

825

datetime.timedelta(0, 1))

826

self.assertEqual(string_to_delta("PT2H"),

827

datetime.timedelta(0, 7200))

828

829

def test_falls_back_to_pre_1_6_1_with_warning(self):

830

# assertLogs only exists in Python 3.4

831

if hasattr(self, "assertLogs"):

832

with self.assertLogs(log, logging.WARNING):

833

value = string_to_delta("2h")

834

else:

835

class WarningFilter(logging.Filter):

836

"""Don't show, but record the presence of, warnings"""

837

def filter(self, record):

838

is_warning = record.levelno >= logging.WARNING

839

self.found = is_warning or getattr(self, "found",

840

False)

841

return not is_warning

842

warning_filter = WarningFilter()

843

log.addFilter(warning_filter)

844

try:

845

value = string_to_delta("2h")

846

finally:

847

log.removeFilter(warning_filter)

848

self.assertTrue(getattr(warning_filter, "found", False))

849

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

850

851

852

class Test_check_option_syntax(unittest.TestCase):

853

def setUp(self):

854

self.parser = argparse.ArgumentParser()

855

add_command_line_options(self.parser)

856

857

def test_actions_requires_client_or_all(self):

858

for action, value in self.actions.items():

859

options = self.parser.parse_args()

860

setattr(options, action, value)

861

with self.assertParseError():

862

self.check_option_syntax(options)

863

864

# This mostly corresponds to the definition from has_actions() in

865

# check_option_syntax()

866

actions = {

867

# The actual values set here are not that important, but we do

868

# at least stick to the correct types, even though they are

869

# never used

870

"enable": True,

871

"disable": True,

872

"bump_timeout": True,

873

"start_checker": True,

874

"stop_checker": True,

875

"is_enabled": True,

876

"remove": True,

877

"checker": "x",

878

"timeout": datetime.timedelta(),

879

"extended_timeout": datetime.timedelta(),

880

"interval": datetime.timedelta(),

881

"approved_by_default": True,

882

"approval_delay": datetime.timedelta(),

883

"approval_duration": datetime.timedelta(),

884

"host": "x",

885

"secret": io.BytesIO(b"x"),

886

"approve": True,

887

"deny": True,

888

}

889

890

@contextlib.contextmanager

891

def assertParseError(self):

892

with self.assertRaises(SystemExit) as e:

893

with self.temporarily_suppress_stderr():

894

yield

895

# Exit code from argparse is guaranteed to be "2". Reference:

896

# https://docs.python.org/3/library

897

# /argparse.html#exiting-methods

898

self.assertEqual(e.exception.code, 2)

899

900

@staticmethod

901

@contextlib.contextmanager

902

def temporarily_suppress_stderr():

903

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

904

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

905

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

906

os.close(null)

239

907

try:

240

mandos_clients = mandos_serv.GetAllClientsWithProperties()

908

yield

241

909

finally:

242

#restore stderr

910

# restore stderr

243

911

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

244

912

os.close(stderrcopy)

245

except dbus.exceptions.DBusException, e:

246

print("Access denied: Accessing mandos server through dbus.",

247

file=sys.stderr)

248

sys.exit(1)

249

250

# Compile dict of (clients: properties) to process

251

clients={}

252

253

if options.all or not options.client:

254

clients = dict((bus.get_object(busname, path), properties)

255

for path, properties in

256

mandos_clients.iteritems())

257

else:

258

for name in options.client:

259

for path, client in mandos_clients.iteritems():

260

if client["Name"] == name:

261

client_objc = bus.get_object(busname, path)

262

clients[client_objc] = client

263

break

264

else:

265

print("Client not found on server: %r" % name,

266

file=sys.stderr)

267

sys.exit(1)

268

269

if not has_actions(options) and clients:

270

if options.verbose:

271

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

272

"LastCheckedOK", "Created", "Interval",

273

"Host", "Fingerprint", "CheckerRunning",

274

"LastEnabled", "ApprovalPending",

275

"ApprovedByDefault",

276

"LastApprovalRequest", "ApprovalDelay",

277

"ApprovalDuration", "Checker",

278

"ExtendedTimeout")

279

else:

280

keywords = defaultkeywords

281

282

print_clients(clients.values(), keywords)

283

else:

284

# Process each client in the list by all selected options

285

for client in clients:

286

if options.remove:

287

mandos_serv.RemoveClient(client.__dbus_object_path__)

288

if options.enable:

289

client.Enable(dbus_interface=client_interface)

290

if options.disable:

291

client.Disable(dbus_interface=client_interface)

292

if options.bump_timeout:

293

client.CheckedOK(dbus_interface=client_interface)

294

if options.start_checker:

295

client.StartChecker(dbus_interface=client_interface)

296

if options.stop_checker:

297

client.StopChecker(dbus_interface=client_interface)

298

if options.is_enabled:

299

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

300

"Enabled",

301

dbus_interface=

302

dbus.PROPERTIES_IFACE)

303

else 1)

304

if options.checker is not None:

305

client.Set(client_interface, "Checker",

306

options.checker,

307

dbus_interface=dbus.PROPERTIES_IFACE)

308

if options.host is not None:

309

client.Set(client_interface, "Host", options.host,

310

dbus_interface=dbus.PROPERTIES_IFACE)

311

if options.interval is not None:

312

client.Set(client_interface, "Interval",

313

timedelta_to_milliseconds

314

(string_to_delta(options.interval)),

315

dbus_interface=dbus.PROPERTIES_IFACE)

316

if options.approval_delay is not None:

317

client.Set(client_interface, "ApprovalDelay",

318

timedelta_to_milliseconds

319

(string_to_delta(options.

320

approval_delay)),

321

dbus_interface=dbus.PROPERTIES_IFACE)

322

if options.approval_duration is not None:

323

client.Set(client_interface, "ApprovalDuration",

324

timedelta_to_milliseconds

325

(string_to_delta(options.

326

approval_duration)),

327

dbus_interface=dbus.PROPERTIES_IFACE)

328

if options.timeout is not None:

329

client.Set(client_interface, "Timeout",

330

timedelta_to_milliseconds

331

(string_to_delta(options.timeout)),

332

dbus_interface=dbus.PROPERTIES_IFACE)

333

if options.extended_timeout is not None:

334

client.Set(client_interface, "ExtendedTimeout",

335

timedelta_to_milliseconds

336

(string_to_delta(options.extended_timeout)),

337

dbus_interface=dbus.PROPERTIES_IFACE)

338

if options.secret is not None:

339

client.Set(client_interface, "Secret",

340

dbus.ByteArray(open(options.secret,

341

"rb").read()),

342

dbus_interface=dbus.PROPERTIES_IFACE)

343

if options.approved_by_default is not None:

344

client.Set(client_interface, "ApprovedByDefault",

345

dbus.Boolean(options

346

.approved_by_default),

347

dbus_interface=dbus.PROPERTIES_IFACE)

348

if options.approve:

349

client.Approve(dbus.Boolean(True),

350

dbus_interface=client_interface)

351

elif options.deny:

352

client.Approve(dbus.Boolean(False),

353

dbus_interface=client_interface)

913

914

def check_option_syntax(self, options):

915

check_option_syntax(self.parser, options)

916

917

def test_actions_conflicts_with_verbose(self):

918

for action, value in self.actions.items():

919

options = self.parser.parse_args()

920

setattr(options, action, value)

921

options.verbose = True

922

with self.assertParseError():

923

self.check_option_syntax(options)

924

925

def test_dump_json_conflicts_with_verbose(self):

926

options = self.parser.parse_args()

927

options.dump_json = True

928

options.verbose = True

929

with self.assertParseError():

930

self.check_option_syntax(options)

931

932

def test_dump_json_conflicts_with_action(self):

933

for action, value in self.actions.items():

934

options = self.parser.parse_args()

935

setattr(options, action, value)

936

options.dump_json = True

937

with self.assertParseError():

938

self.check_option_syntax(options)

939

940

def test_all_can_not_be_alone(self):

941

options = self.parser.parse_args()

942

options.all = True

943

with self.assertParseError():

944

self.check_option_syntax(options)

945

946

def test_all_is_ok_with_any_action(self):

947

for action, value in self.actions.items():

948

options = self.parser.parse_args()

949

setattr(options, action, value)

950

options.all = True

951

self.check_option_syntax(options)

952

953

def test_is_enabled_fails_without_client(self):

954

options = self.parser.parse_args()

955

options.is_enabled = True

956

with self.assertParseError():

957

self.check_option_syntax(options)

958

959

def test_is_enabled_works_with_one_client(self):

960

options = self.parser.parse_args()

961

options.is_enabled = True

962

options.client = ["foo"]

963

self.check_option_syntax(options)

964

965

def test_is_enabled_fails_with_two_clients(self):

966

options = self.parser.parse_args()

967

options.is_enabled = True

968

options.client = ["foo", "barbar"]

969

with self.assertParseError():

970

self.check_option_syntax(options)

971

972

def test_remove_can_only_be_combined_with_action_deny(self):

973

for action, value in self.actions.items():

974

if action in {"remove", "deny"}:

975

continue

976

options = self.parser.parse_args()

977

setattr(options, action, value)

978

options.all = True

979

options.remove = True

980

with self.assertParseError():

981

self.check_option_syntax(options)

982

983

984

class Test_commands_from_options(unittest.TestCase):

985

def setUp(self):

986

self.parser = argparse.ArgumentParser()

987

add_command_line_options(self.parser)

988

989

def test_is_enabled(self):

990

self.assert_command_from_args(["--is-enabled", "foo"],

991

IsEnabledCmd)

992

993

def assert_command_from_args(self, args, command_cls,

994

**cmd_attrs):

995

"""Assert that parsing ARGS should result in an instance of

996

COMMAND_CLS with (optionally) all supplied attributes (CMD_ATTRS)."""

997

options = self.parser.parse_args(args)

998

check_option_syntax(self.parser, options)

999

commands = commands_from_options(options)

1000

self.assertEqual(len(commands), 1)

1001

command = commands[0]

1002

self.assertIsInstance(command, command_cls)

1003

for key, value in cmd_attrs.items():

1004

self.assertEqual(getattr(command, key), value)

1005

1006

def test_is_enabled_short(self):

1007

self.assert_command_from_args(["-V", "foo"], IsEnabledCmd)

1008

1009

def test_approve(self):

1010

self.assert_command_from_args(["--approve", "foo"],

1011

ApproveCmd)

1012

1013

def test_approve_short(self):

1014

self.assert_command_from_args(["-A", "foo"], ApproveCmd)

1015

1016

def test_deny(self):

1017

self.assert_command_from_args(["--deny", "foo"], DenyCmd)

1018

1019

def test_deny_short(self):

1020

self.assert_command_from_args(["-D", "foo"], DenyCmd)

1021

1022

def test_remove(self):

1023

self.assert_command_from_args(["--remove", "foo"],

1024

RemoveCmd)

1025

1026

def test_deny_before_remove(self):

1027

options = self.parser.parse_args(["--deny", "--remove",

1028

"foo"])

1029

check_option_syntax(self.parser, options)

1030

commands = commands_from_options(options)

1031

self.assertEqual(len(commands), 2)

1032

self.assertIsInstance(commands[0], DenyCmd)

1033

self.assertIsInstance(commands[1], RemoveCmd)

1034

1035

def test_deny_before_remove_reversed(self):

1036

options = self.parser.parse_args(["--remove", "--deny",

1037

"--all"])

1038

check_option_syntax(self.parser, options)

1039

commands = commands_from_options(options)

1040

self.assertEqual(len(commands), 2)

1041

self.assertIsInstance(commands[0], DenyCmd)

1042

self.assertIsInstance(commands[1], RemoveCmd)

1043

1044

def test_remove_short(self):

1045

self.assert_command_from_args(["-r", "foo"], RemoveCmd)

1046

1047

def test_dump_json(self):

1048

self.assert_command_from_args(["--dump-json"], DumpJSONCmd)

1049

1050

def test_enable(self):

1051

self.assert_command_from_args(["--enable", "foo"], EnableCmd)

1052

1053

def test_enable_short(self):

1054

self.assert_command_from_args(["-e", "foo"], EnableCmd)

1055

1056

def test_disable(self):

1057

self.assert_command_from_args(["--disable", "foo"],

1058

DisableCmd)

1059

1060

def test_disable_short(self):

1061

self.assert_command_from_args(["-d", "foo"], DisableCmd)

1062

1063

def test_bump_timeout(self):

1064

self.assert_command_from_args(["--bump-timeout", "foo"],

1065

BumpTimeoutCmd)

1066

1067

def test_bump_timeout_short(self):

1068

self.assert_command_from_args(["-b", "foo"], BumpTimeoutCmd)

1069

1070

def test_start_checker(self):

1071

self.assert_command_from_args(["--start-checker", "foo"],

1072

StartCheckerCmd)

1073

1074

def test_stop_checker(self):

1075

self.assert_command_from_args(["--stop-checker", "foo"],

1076

StopCheckerCmd)

1077

1078

def test_approve_by_default(self):

1079

self.assert_command_from_args(["--approve-by-default", "foo"],

1080

ApproveByDefaultCmd)

1081

1082

def test_deny_by_default(self):

1083

self.assert_command_from_args(["--deny-by-default", "foo"],

1084

DenyByDefaultCmd)

1085

1086

def test_checker(self):

1087

self.assert_command_from_args(["--checker", ":", "foo"],

1088

SetCheckerCmd, value_to_set=":")

1089

1090

def test_checker_empty(self):

1091

self.assert_command_from_args(["--checker", "", "foo"],

1092

SetCheckerCmd, value_to_set="")

1093

1094

def test_checker_short(self):

1095

self.assert_command_from_args(["-c", ":", "foo"],

1096

SetCheckerCmd, value_to_set=":")

1097

1098

def test_host(self):

1099

self.assert_command_from_args(["--host", "foo.example.org",

1100

"foo"], SetHostCmd,

1101

value_to_set="foo.example.org")

1102

1103

def test_host_short(self):

1104

self.assert_command_from_args(["-H", "foo.example.org",

1105

"foo"], SetHostCmd,

1106

value_to_set="foo.example.org")

1107

1108

def test_secret_devnull(self):

1109

self.assert_command_from_args(["--secret", os.path.devnull,

1110

"foo"], SetSecretCmd,

1111

value_to_set=b"")

1112

1113

def test_secret_tempfile(self):

1114

with tempfile.NamedTemporaryFile(mode="r+b") as f:

1115

value = b"secret\0xyzzy\nbar"

1116

f.write(value)

1117

f.seek(0)

1118

self.assert_command_from_args(["--secret", f.name,

1119

"foo"], SetSecretCmd,

1120

value_to_set=value)

1121

1122

def test_secret_devnull_short(self):

1123

self.assert_command_from_args(["-s", os.path.devnull, "foo"],

1124

SetSecretCmd, value_to_set=b"")

1125

1126

def test_secret_tempfile_short(self):

1127

with tempfile.NamedTemporaryFile(mode="r+b") as f:

1128

value = b"secret\0xyzzy\nbar"

1129

f.write(value)

1130

f.seek(0)

1131

self.assert_command_from_args(["-s", f.name, "foo"],

1132

SetSecretCmd,

1133

value_to_set=value)

1134

1135

def test_timeout(self):

1136

self.assert_command_from_args(["--timeout", "PT5M", "foo"],

1137

SetTimeoutCmd,

1138

value_to_set=300000)

1139

1140

def test_timeout_short(self):

1141

self.assert_command_from_args(["-t", "PT5M", "foo"],

1142

SetTimeoutCmd,

1143

value_to_set=300000)

1144

1145

def test_extended_timeout(self):

1146

self.assert_command_from_args(["--extended-timeout", "PT15M",

1147

"foo"],

1148

SetExtendedTimeoutCmd,

1149

value_to_set=900000)

1150

1151

def test_interval(self):

1152

self.assert_command_from_args(["--interval", "PT2M", "foo"],

1153

SetIntervalCmd,

1154

value_to_set=120000)

1155

1156

def test_interval_short(self):

1157

self.assert_command_from_args(["-i", "PT2M", "foo"],

1158

SetIntervalCmd,

1159

value_to_set=120000)

1160

1161

def test_approval_delay(self):

1162

self.assert_command_from_args(["--approval-delay", "PT30S",

1163

"foo"], SetApprovalDelayCmd,

1164

value_to_set=30000)

1165

1166

def test_approval_duration(self):

1167

self.assert_command_from_args(["--approval-duration", "PT1S",

1168

"foo"], SetApprovalDurationCmd,

1169

value_to_set=1000)

1170

1171

def test_print_table(self):

1172

self.assert_command_from_args([], PrintTableCmd,

1173

verbose=False)

1174

1175

def test_print_table_verbose(self):

1176

self.assert_command_from_args(["--verbose"], PrintTableCmd,

1177

verbose=True)

1178

1179

def test_print_table_verbose_short(self):

1180

self.assert_command_from_args(["-v"], PrintTableCmd,

1181

verbose=True)

1182

1183

1184

class TestCmd(unittest.TestCase):

1185

"""Abstract class for tests of command classes"""

1186

1187

def setUp(self):

1188

testcase = self

1189

class MockClient(object):

1190

def __init__(self, name, **attributes):

1191

self.__dbus_object_path__ = "/clients/{}".format(name)

1192

self.attributes = attributes

1193

self.attributes["Name"] = name

1194

self.calls = []

1195

def Set(self, interface, propname, value, dbus_interface):

1196

testcase.assertEqual(interface, client_dbus_interface)

1197

testcase.assertEqual(dbus_interface,

1198

dbus.PROPERTIES_IFACE)

1199

self.attributes[propname] = value

1200

def Get(self, interface, propname, dbus_interface):

1201

testcase.assertEqual(interface, client_dbus_interface)

1202

testcase.assertEqual(dbus_interface,

1203

dbus.PROPERTIES_IFACE)

1204

return self.attributes[propname]

1205

def Approve(self, approve, dbus_interface):

1206

testcase.assertEqual(dbus_interface,

1207

client_dbus_interface)

1208

self.calls.append(("Approve", (approve,

1209

dbus_interface)))

1210

self.client = MockClient(

1211

"foo",

1212

KeyID=("92ed150794387c03ce684574b1139a65"

1213

"94a34f895daaaf09fd8ea90a27cddb12"),

1214

Secret=b"secret",

1215

Host="foo.example.org",

1216

Enabled=dbus.Boolean(True),

1217

Timeout=300000,

1218

LastCheckedOK="2019-02-03T00:00:00",

1219

Created="2019-01-02T00:00:00",

1220

Interval=120000,

1221

Fingerprint=("778827225BA7DE539C5A"

1222

"7CFA59CFF7CDBD9A5920"),

1223

CheckerRunning=dbus.Boolean(False),

1224

LastEnabled="2019-01-03T00:00:00",

1225

ApprovalPending=dbus.Boolean(False),

1226

ApprovedByDefault=dbus.Boolean(True),

1227

LastApprovalRequest="",

1228

ApprovalDelay=0,

1229

ApprovalDuration=1000,

1230

Checker="fping -q -- %(host)s",

1231

ExtendedTimeout=900000,

1232

Expires="2019-02-04T00:00:00",

1233

LastCheckerStatus=0)

1234

self.other_client = MockClient(

1235

"barbar",

1236

KeyID=("0558568eedd67d622f5c83b35a115f79"

1237

"6ab612cff5ad227247e46c2b020f441c"),

1238

Secret=b"secretbar",

1239

Host="192.0.2.3",

1240

Enabled=dbus.Boolean(True),

1241

Timeout=300000,

1242

LastCheckedOK="2019-02-04T00:00:00",

1243

Created="2019-01-03T00:00:00",

1244

Interval=120000,

1245

Fingerprint=("3E393AEAEFB84C7E89E2"

1246

"F547B3A107558FCA3A27"),

1247

CheckerRunning=dbus.Boolean(True),

1248

LastEnabled="2019-01-04T00:00:00",

1249

ApprovalPending=dbus.Boolean(False),

1250

ApprovedByDefault=dbus.Boolean(False),

1251

LastApprovalRequest="2019-01-03T00:00:00",

1252

ApprovalDelay=30000,

1253

ApprovalDuration=93785000,

1254

Checker=":",

1255

ExtendedTimeout=900000,

1256

Expires="2019-02-05T00:00:00",

1257

LastCheckerStatus=-2)

1258

self.clients = collections.OrderedDict(

1259

[

1260

("/clients/foo", self.client.attributes),

1261

("/clients/barbar", self.other_client.attributes),

1262

])

1263

self.one_client = {"/clients/foo": self.client.attributes}

1264

1265

@property

1266

def bus(self):

1267

class Bus(object):

1268

@staticmethod

1269

def get_object(client_bus_name, path):

1270

self.assertEqual(client_bus_name, dbus_busname)

1271

return {

1272

# Note: "self" here is the TestCmd instance, not

1273

# the Bus instance, since this is a static method!

1274

"/clients/foo": self.client,

1275

"/clients/barbar": self.other_client,

1276

}[path]

1277

return Bus()

1278

1279

1280

class TestIsEnabledCmd(TestCmd):

1281

def test_is_enabled(self):

1282

self.assertTrue(all(IsEnabledCmd().is_enabled(client,

1283

properties)

1284

for client, properties

1285

in self.clients.items()))

1286

1287

def test_is_enabled_run_exits_successfully(self):

1288

with self.assertRaises(SystemExit) as e:

1289

IsEnabledCmd().run(self.one_client)

1290

if e.exception.code is not None:

1291

self.assertEqual(e.exception.code, 0)

1292

else:

1293

self.assertIsNone(e.exception.code)

1294

1295

def test_is_enabled_run_exits_with_failure(self):

1296

self.client.attributes["Enabled"] = dbus.Boolean(False)

1297

with self.assertRaises(SystemExit) as e:

1298

IsEnabledCmd().run(self.one_client)

1299

if isinstance(e.exception.code, int):

1300

self.assertNotEqual(e.exception.code, 0)

1301

else:

1302

self.assertIsNotNone(e.exception.code)

1303

1304

1305

class TestApproveCmd(TestCmd):

1306

def test_approve(self):

1307

ApproveCmd().run(self.clients, self.bus)

1308

for clientpath in self.clients:

1309

client = self.bus.get_object(dbus_busname, clientpath)

1310

self.assertIn(("Approve", (True, client_dbus_interface)),

1311

client.calls)

1312

1313

1314

class TestDenyCmd(TestCmd):

1315

def test_deny(self):

1316

DenyCmd().run(self.clients, self.bus)

1317

for clientpath in self.clients:

1318

client = self.bus.get_object(dbus_busname, clientpath)

1319

self.assertIn(("Approve", (False, client_dbus_interface)),

1320

client.calls)

1321

1322

1323

class TestRemoveCmd(TestCmd):

1324

def test_remove(self):

1325

class MockMandos(object):

1326

def __init__(self):

1327

self.calls = []

1328

def RemoveClient(self, dbus_path):

1329

self.calls.append(("RemoveClient", (dbus_path,)))

1330

mandos = MockMandos()

1331

super(TestRemoveCmd, self).setUp()

1332

RemoveCmd().run(self.clients, self.bus, mandos)

1333

self.assertEqual(len(mandos.calls), 2)

1334

for clientpath in self.clients:

1335

self.assertIn(("RemoveClient", (clientpath,)),

1336

mandos.calls)

1337

1338

1339

class TestDumpJSONCmd(TestCmd):

1340

def setUp(self):

1341

self.expected_json = {

1342

"foo": {

1343

"Name": "foo",

1344

"KeyID": ("92ed150794387c03ce684574b1139a65"

1345

"94a34f895daaaf09fd8ea90a27cddb12"),

1346

"Host": "foo.example.org",

1347

"Enabled": True,

1348

"Timeout": 300000,

1349

"LastCheckedOK": "2019-02-03T00:00:00",

1350

"Created": "2019-01-02T00:00:00",

1351

"Interval": 120000,

1352

"Fingerprint": ("778827225BA7DE539C5A"

1353

"7CFA59CFF7CDBD9A5920"),

1354

"CheckerRunning": False,

1355

"LastEnabled": "2019-01-03T00:00:00",

1356

"ApprovalPending": False,

1357

"ApprovedByDefault": True,

1358

"LastApprovalRequest": "",

1359

"ApprovalDelay": 0,

1360

"ApprovalDuration": 1000,

1361

"Checker": "fping -q -- %(host)s",

1362

"ExtendedTimeout": 900000,

1363

"Expires": "2019-02-04T00:00:00",

1364

"LastCheckerStatus": 0,

1365

},

1366

"barbar": {

1367

"Name": "barbar",

1368

"KeyID": ("0558568eedd67d622f5c83b35a115f79"

1369

"6ab612cff5ad227247e46c2b020f441c"),

1370

"Host": "192.0.2.3",

1371

"Enabled": True,

1372

"Timeout": 300000,

1373

"LastCheckedOK": "2019-02-04T00:00:00",

1374

"Created": "2019-01-03T00:00:00",

1375

"Interval": 120000,

1376

"Fingerprint": ("3E393AEAEFB84C7E89E2"

1377

"F547B3A107558FCA3A27"),

1378

"CheckerRunning": True,

1379

"LastEnabled": "2019-01-04T00:00:00",

1380

"ApprovalPending": False,

1381

"ApprovedByDefault": False,

1382

"LastApprovalRequest": "2019-01-03T00:00:00",

1383

"ApprovalDelay": 30000,

1384

"ApprovalDuration": 93785000,

1385

"Checker": ":",

1386

"ExtendedTimeout": 900000,

1387

"Expires": "2019-02-05T00:00:00",

1388

"LastCheckerStatus": -2,

1389

},

1390

}

1391

return super(TestDumpJSONCmd, self).setUp()

1392

1393

def test_normal(self):

1394

json_data = json.loads(DumpJSONCmd().output(self.clients))

1395

self.assertDictEqual(json_data, self.expected_json)

1396

1397

def test_one_client(self):

1398

clients = self.one_client

1399

json_data = json.loads(DumpJSONCmd().output(clients))

1400

expected_json = {"foo": self.expected_json["foo"]}

1401

self.assertDictEqual(json_data, expected_json)

1402

1403

1404

class TestPrintTableCmd(TestCmd):

1405

def test_normal(self):

1406

output = PrintTableCmd().output(self.clients.values())

1407

expected_output = "\n".join((

1408

"Name Enabled Timeout Last Successful Check",

1409

"foo Yes 00:05:00 2019-02-03T00:00:00 ",

1410

"barbar Yes 00:05:00 2019-02-04T00:00:00 ",

1411

))

1412

self.assertEqual(output, expected_output)

1413

1414

def test_verbose(self):

1415

output = PrintTableCmd(verbose=True).output(

1416

self.clients.values())

1417

columns = (

1418

(

1419

"Name ",

1420

"foo ",

1421

"barbar ",

1422

),(

1423

"Enabled ",

1424

"Yes ",

1425

"Yes ",

1426

),(

1427

"Timeout ",

1428

"00:05:00 ",

1429

"00:05:00 ",

1430

),(

1431

"Last Successful Check ",

1432

"2019-02-03T00:00:00 ",

1433

"2019-02-04T00:00:00 ",

1434

),(

1435

"Created ",

1436

"2019-01-02T00:00:00 ",

1437

"2019-01-03T00:00:00 ",

1438

),(

1439

"Interval ",

1440

"00:02:00 ",

1441

"00:02:00 ",

1442

),(

1443

"Host ",

1444

"foo.example.org ",

1445

"192.0.2.3 ",

1446

),(

1447

("Key ID "

1448

" "),

1449

("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"

1450

"ea90a27cddb12 "),

1451

("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"

1452

"46c2b020f441c "),

1453

),(

1454

"Fingerprint ",

1455

"778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",

1456

"3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",

1457

),(

1458

"Check Is Running ",

1459

"No ",

1460

"Yes ",

1461

),(

1462

"Last Enabled ",

1463

"2019-01-03T00:00:00 ",

1464

"2019-01-04T00:00:00 ",

1465

),(

1466

"Approval Is Pending ",

1467

"No ",

1468

"No ",

1469

),(

1470

"Approved By Default ",

1471

"Yes ",

1472

"No ",

1473

),(

1474

"Last Approval Request ",

1475

" ",

1476

"2019-01-03T00:00:00 ",

1477

),(

1478

"Approval Delay ",

1479

"00:00:00 ",

1480

"00:00:30 ",

1481

),(

1482

"Approval Duration ",

1483

"00:00:01 ",

1484

"1T02:03:05 ",

1485

),(

1486

"Checker ",

1487

"fping -q -- %(host)s ",

1488

": ",

1489

),(

1490

"Extended Timeout ",

1491

"00:15:00 ",

1492

"00:15:00 ",

1493

),(

1494

"Expires ",

1495

"2019-02-04T00:00:00 ",

1496

"2019-02-05T00:00:00 ",

1497

),(

1498

"Last Checker Status",

1499

"0 ",

1500

"-2 ",

1501

)

1502

)

1503

num_lines = max(len(rows) for rows in columns)

1504

expected_output = "\n".join("".join(rows[line]

1505

for rows in columns)

1506

for line in range(num_lines))

1507

self.assertEqual(output, expected_output)

1508

1509

def test_one_client(self):

1510

output = PrintTableCmd().output(self.one_client.values())

1511

expected_output = "\n".join((

1512

"Name Enabled Timeout Last Successful Check",

1513

"foo Yes 00:05:00 2019-02-03T00:00:00 ",

1514

))

1515

self.assertEqual(output, expected_output)

1516

1517

1518

class TestPropertyCmd(TestCmd):

1519

"""Abstract class for tests of PropertyCmd classes"""

1520

def runTest(self):

1521

if not hasattr(self, "command"):

1522

return

1523

values_to_get = getattr(self, "values_to_get",

1524

self.values_to_set)

1525

for value_to_set, value_to_get in zip(self.values_to_set,

1526

values_to_get):

1527

for clientpath in self.clients:

1528

client = self.bus.get_object(dbus_busname, clientpath)

1529

old_value = client.attributes[self.propname]

1530

self.assertNotIsInstance(old_value, self.Unique)

1531

client.attributes[self.propname] = self.Unique()

1532

self.run_command(value_to_set, self.clients)

1533

for clientpath in self.clients:

1534

client = self.bus.get_object(dbus_busname, clientpath)

1535

value = client.attributes[self.propname]

1536

self.assertNotIsInstance(value, self.Unique)

1537

self.assertEqual(value, value_to_get)

1538

1539

class Unique(object):

1540

"""Class for objects which exist only to be unique objects,

1541

since unittest.mock.sentinel only exists in Python 3.3"""

1542

1543

def run_command(self, value, clients):

1544

self.command().run(clients, self.bus)

1545

1546

1547

class TestEnableCmd(TestPropertyCmd):

1548

command = EnableCmd

1549

propname = "Enabled"

1550

values_to_set = [dbus.Boolean(True)]

1551

1552

1553

class TestDisableCmd(TestPropertyCmd):

1554

command = DisableCmd

1555

propname = "Enabled"

1556

values_to_set = [dbus.Boolean(False)]

1557

1558

1559

class TestBumpTimeoutCmd(TestPropertyCmd):

1560

command = BumpTimeoutCmd

1561

propname = "LastCheckedOK"

1562

values_to_set = [""]

1563

1564

1565

class TestStartCheckerCmd(TestPropertyCmd):

1566

command = StartCheckerCmd

1567

propname = "CheckerRunning"

1568

values_to_set = [dbus.Boolean(True)]

1569

1570

1571

class TestStopCheckerCmd(TestPropertyCmd):

1572

command = StopCheckerCmd

1573

propname = "CheckerRunning"

1574

values_to_set = [dbus.Boolean(False)]

1575

1576

1577

class TestApproveByDefaultCmd(TestPropertyCmd):

1578

command = ApproveByDefaultCmd

1579

propname = "ApprovedByDefault"

1580

values_to_set = [dbus.Boolean(True)]

1581

1582

1583

class TestDenyByDefaultCmd(TestPropertyCmd):

1584

command = DenyByDefaultCmd

1585

propname = "ApprovedByDefault"

1586

values_to_set = [dbus.Boolean(False)]

1587

1588

1589

class TestPropertyValueCmd(TestPropertyCmd):

1590

"""Abstract class for tests of PropertyValueCmd classes"""

1591

1592

def runTest(self):

1593

if type(self) is TestPropertyValueCmd:

1594

return

1595

return super(TestPropertyValueCmd, self).runTest()

1596

1597

def run_command(self, value, clients):

1598

self.command(value).run(clients, self.bus)

1599

1600

1601

class TestSetCheckerCmd(TestPropertyValueCmd):

1602

command = SetCheckerCmd

1603

propname = "Checker"

1604

values_to_set = ["", ":", "fping -q -- %s"]

1605

1606

1607

class TestSetHostCmd(TestPropertyValueCmd):

1608

command = SetHostCmd

1609

propname = "Host"

1610

values_to_set = ["192.0.2.3", "foo.example.org"]

1611

1612

1613

class TestSetSecretCmd(TestPropertyValueCmd):

1614

command = SetSecretCmd

1615

propname = "Secret"

1616

values_to_set = [io.BytesIO(b""),

1617

io.BytesIO(b"secret\0xyzzy\nbar")]

1618

values_to_get = [b"", b"secret\0xyzzy\nbar"]

1619

1620

1621

class TestSetTimeoutCmd(TestPropertyValueCmd):

1622

command = SetTimeoutCmd

1623

propname = "Timeout"

1624

values_to_set = [datetime.timedelta(),

1625

datetime.timedelta(minutes=5),

1626

datetime.timedelta(seconds=1),

1627

datetime.timedelta(weeks=1),

1628

datetime.timedelta(weeks=52)]

1629

values_to_get = [0, 300000, 1000, 604800000, 31449600000]

1630

1631

1632

class TestSetExtendedTimeoutCmd(TestPropertyValueCmd):

1633

command = SetExtendedTimeoutCmd

1634

propname = "ExtendedTimeout"

1635

values_to_set = [datetime.timedelta(),

1636

datetime.timedelta(minutes=5),

1637

datetime.timedelta(seconds=1),

1638

datetime.timedelta(weeks=1),

1639

datetime.timedelta(weeks=52)]

1640

values_to_get = [0, 300000, 1000, 604800000, 31449600000]

1641

1642

1643

class TestSetIntervalCmd(TestPropertyValueCmd):

1644

command = SetIntervalCmd

1645

propname = "Interval"

1646

values_to_set = [datetime.timedelta(),

1647

datetime.timedelta(minutes=5),

1648

datetime.timedelta(seconds=1),

1649

datetime.timedelta(weeks=1),

1650

datetime.timedelta(weeks=52)]

1651

values_to_get = [0, 300000, 1000, 604800000, 31449600000]

1652

1653

1654

class TestSetApprovalDelayCmd(TestPropertyValueCmd):

1655

command = SetApprovalDelayCmd

1656

propname = "ApprovalDelay"

1657

values_to_set = [datetime.timedelta(),

1658

datetime.timedelta(minutes=5),

1659

datetime.timedelta(seconds=1),

1660

datetime.timedelta(weeks=1),

1661

datetime.timedelta(weeks=52)]

1662

values_to_get = [0, 300000, 1000, 604800000, 31449600000]

1663

1664

1665

class TestSetApprovalDurationCmd(TestPropertyValueCmd):

1666

command = SetApprovalDurationCmd

1667

propname = "ApprovalDuration"

1668

values_to_set = [datetime.timedelta(),

1669

datetime.timedelta(minutes=5),

1670

datetime.timedelta(seconds=1),

1671

datetime.timedelta(weeks=1),

1672

datetime.timedelta(weeks=52)]

1673

values_to_get = [0, 300000, 1000, 604800000, 31449600000]

1674

1675

1676

1677

def should_only_run_tests():

1678

parser = argparse.ArgumentParser(add_help=False)

1679

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

1680

args, unknown_args = parser.parse_known_args()

1681

run_tests = args.check

1682

if run_tests:

1683

# Remove --check argument from sys.argv

1684

sys.argv[1:] = unknown_args

1685

return run_tests

1686

1687

# Add all tests from doctest strings

1688

def load_tests(loader, tests, none):

1689

import doctest

1690

tests.addTests(doctest.DocTestSuite())

1691

return tests

354

1692

355

1693

if __name__ == "__main__":

356

main()

1694

if should_only_run_tests():

1695

# Call using ./tdd-python-script --check [--verbose]

1696

unittest.main()

1697

else:

1698

main()