/mandos/trunk : revision 1091

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

import abc

49

50

import dbus as dbus_python

51

52

# Show warnings by default

53

if not sys.warnoptions:

54

import warnings

55

warnings.simplefilter("default")

56

57

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

58

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

59

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

60

61

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

62

63

if sys.version_info.major == 2:

64

str = unicode

65

import StringIO

66

io.StringIO = StringIO.StringIO

35

67

36

68

locale.setlocale(locale.LC_ALL, "")

37

69

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

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

value = datetime.timedelta(0)

97

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

98

99

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

100

if suffix == "d":

101

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

102

elif suffix == "s":

103

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

104

elif suffix == "m":

105

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

106

elif suffix == "h":

107

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

108

elif suffix == "w":

109

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

110

elif suffix == "":

111

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

112

return value

113

114

def print_clients(clients, keywords):

115

def valuetostring(value, keyword):

116

if type(value) is dbus.Boolean:

117

return "Yes" if value else "No"

118

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

119

"ApprovalDuration"):

120

return milliseconds_to_string(value)

121

return unicode(value)

122

123

# Create format string to print table rows

124

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

125

max(len(tablewords[key]),

126

max(len(valuetostring(client[key],

127

key))

128

for client in

129

clients))

130

for key in keywords)

131

# Print header line

132

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

133

for client in clients:

134

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

135

for key in keywords))

136

137

def has_actions(options):

138

return any((options.enable,

139

options.disable,

140

options.bump_timeout,

141

options.start_checker,

142

options.stop_checker,

143

options.is_enabled,

144

options.remove,

145

options.checker is not None,

146

options.timeout is not None,

147

options.extended_timeout is not None,

148

options.interval is not None,

149

options.approved_by_default is not None,

150

options.approval_delay is not None,

151

options.approval_duration is not None,

152

options.host is not None,

153

options.secret is not None,

154

options.approve,

155

options.deny))

70

version = "1.8.3"

71

156

72

157

73

def main():

158

74

parser = argparse.ArgumentParser()

75

add_command_line_options(parser)

76

77

options = parser.parse_args()

78

check_option_syntax(parser, options)

79

80

clientnames = options.client

81

82

if options.debug:

83

log.setLevel(logging.DEBUG)

84

85

bus = dbus_python_adapter.CachingBus(dbus_python)

86

87

try:

88

all_clients = bus.get_clients_and_properties()

89

except dbus.ConnectFailed as e:

90

log.critical("Could not connect to Mandos server: %s", e)

91

sys.exit(1)

92

except dbus.Error as e:

93

log.critical(

94

"Failed to access Mandos server through D-Bus:\n%s", e)

95

sys.exit(1)

96

97

# Compile dict of (clientpath: properties) to process

98

if not clientnames:

99

clients = all_clients

100

else:

101

clients = {}

102

for name in clientnames:

103

for objpath, properties in all_clients.items():

104

if properties["Name"] == name:

105

clients[objpath] = properties

106

break

107

else:

108

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

109

sys.exit(1)

110

111

commands = commands_from_options(options)

112

113

for command in commands:

114

command.run(clients, bus)

115

116

117

def add_command_line_options(parser):

159

118

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

160

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

119

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

161

120

help="show version number and exit")

162

121

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

163

122

help="Select all clients")

164

123

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

165

124

help="Print all fields")

166

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

167

help="Enable client")

168

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

169

help="disable client")

125

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

126

help="Dump client data in JSON format")

127

enable_disable = parser.add_mutually_exclusive_group()

128

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

129

help="Enable client")

130

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

131

action="store_true",

132

help="disable client")

170

133

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

171

134

help="Bump timeout for client")

172

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

173

help="Start checker for client")

174

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

175

help="Stop checker for client")

135

start_stop_checker = parser.add_mutually_exclusive_group()

136

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

137

action="store_true",

138

help="Start checker for client")

139

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

140

action="store_true",

141

help="Stop checker for client")

176

142

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

177

143

help="Check if client is enabled")

178

144

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

179

145

help="Remove client")

180

146

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

181

147

help="Set checker command for client")

182

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

148

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

183

149

help="Set timeout for client")

184

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

150

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

185

151

help="Set extended timeout for client")

186

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

152

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

187

153

help="Set checker interval for client")

188

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

189

default=None, dest="approved_by_default",

190

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

191

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

192

dest="approved_by_default",

193

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

194

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

154

approve_deny_default = parser.add_mutually_exclusive_group()

155

approve_deny_default.add_argument(

156

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

157

default=None, dest="approved_by_default",

158

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

159

approve_deny_default.add_argument(

160

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

161

dest="approved_by_default",

162

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

163

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

195

164

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

196

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

165

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

197

166

help="Set duration of one client approval")

198

167

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

199

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

168

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

169

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

200

170

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

201

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

202

help="Approve any current client request")

203

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

204

help="Deny any current client request")

171

approve_deny = parser.add_mutually_exclusive_group()

172

approve_deny.add_argument(

173

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

174

help="Approve any current client request")

175

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

176

help="Deny any current client request")

177

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

178

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

179

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

180

help="Run self-test")

205

181

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

206

options = parser.parse_args()

207

208

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

182

183

184

def string_to_delta(interval):

185

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

186

187

try:

188

return rfc3339_duration_to_delta(interval)

189

except ValueError as e:

190

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

191

' '.join(e.args))

192

return parse_pre_1_6_1_interval(interval)

193

194

195

def rfc3339_duration_to_delta(duration):

196

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

197

198

>>> rfc3339_duration_to_delta("P7D")

199

datetime.timedelta(7)

200

>>> rfc3339_duration_to_delta("PT60S")

201

datetime.timedelta(0, 60)

202

>>> rfc3339_duration_to_delta("PT60M")

203

datetime.timedelta(0, 3600)

204

>>> rfc3339_duration_to_delta("P60M")

205

datetime.timedelta(1680)

206

>>> rfc3339_duration_to_delta("PT24H")

207

datetime.timedelta(1)

208

>>> rfc3339_duration_to_delta("P1W")

209

datetime.timedelta(7)

210

>>> rfc3339_duration_to_delta("PT5M30S")

211

datetime.timedelta(0, 330)

212

>>> rfc3339_duration_to_delta("P1DT3M20S")

213

datetime.timedelta(1, 200)

214

>>> # Can not be empty:

215

>>> rfc3339_duration_to_delta("")

216

Traceback (most recent call last):

217

...

218

ValueError: Invalid RFC 3339 duration: ""

219

>>> # Must start with "P":

220

>>> rfc3339_duration_to_delta("1D")

221

Traceback (most recent call last):

222

...

223

ValueError: Invalid RFC 3339 duration: "1D"

224

>>> # Must use correct order

225

>>> rfc3339_duration_to_delta("PT1S2M")

226

Traceback (most recent call last):

227

...

228

ValueError: Invalid RFC 3339 duration: "PT1S2M"

229

>>> # Time needs time marker

230

>>> rfc3339_duration_to_delta("P1H2S")

231

Traceback (most recent call last):

232

...

233

ValueError: Invalid RFC 3339 duration: "P1H2S"

234

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

235

>>> rfc3339_duration_to_delta("P1D2W")

236

Traceback (most recent call last):

237

...

238

ValueError: Invalid RFC 3339 duration: "P1D2W"

239

>>> rfc3339_duration_to_delta("P2W2H")

240

Traceback (most recent call last):

241

...

242

ValueError: Invalid RFC 3339 duration: "P2W2H"

243

"""

244

245

# Parsing an RFC 3339 duration with regular expressions is not

246

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

247

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

248

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

249

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

250

# avoid excessive use of external libraries.

251

252

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

253

Token = collections.namedtuple("Token", (

254

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

255

# a "group" containing digits

256

"value", # datetime.timedelta or None

257

"followers")) # Tokens valid after this token

258

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

259

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

260

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

261

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

262

datetime.timedelta(seconds=1),

263

frozenset((token_end, )))

264

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

265

datetime.timedelta(minutes=1),

266

frozenset((token_second, token_end)))

267

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

268

datetime.timedelta(hours=1),

269

frozenset((token_minute, token_end)))

270

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

271

None,

272

frozenset((token_hour, token_minute,

273

token_second)))

274

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

275

datetime.timedelta(days=1),

276

frozenset((token_time, token_end)))

277

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

278

datetime.timedelta(weeks=4),

279

frozenset((token_day, token_end)))

280

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

281

datetime.timedelta(weeks=52),

282

frozenset((token_month, token_end)))

283

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

284

datetime.timedelta(weeks=1),

285

frozenset((token_end, )))

286

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

287

frozenset((token_year, token_month,

288

token_day, token_time,

289

token_week)))

290

# Define starting values:

291

# Value so far

292

value = datetime.timedelta()

293

found_token = None

294

# Following valid tokens

295

followers = frozenset((token_duration, ))

296

# String left to parse

297

s = duration

298

# Loop until end token is found

299

while found_token is not token_end:

300

# Search for any currently valid tokens

301

for token in followers:

302

match = token.regexp.match(s)

303

if match is not None:

304

# Token found

305

if token.value is not None:

306

# Value found, parse digits

307

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

308

# Add to value so far

309

value += factor * token.value

310

# Strip token from string

311

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

312

# Go to found token

313

found_token = token

314

# Set valid next tokens

315

followers = found_token.followers

316

break

317

else:

318

# No currently valid tokens were found

319

raise ValueError("Invalid RFC 3339 duration: \"{}\""

320

.format(duration))

321

# End token found

322

return value

323

324

325

def parse_pre_1_6_1_interval(interval):

326

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

327

and return a datetime.timedelta

328

329

>>> parse_pre_1_6_1_interval('7d')

330

datetime.timedelta(7)

331

>>> parse_pre_1_6_1_interval('60s')

332

datetime.timedelta(0, 60)

333

>>> parse_pre_1_6_1_interval('60m')

334

datetime.timedelta(0, 3600)

335

>>> parse_pre_1_6_1_interval('24h')

336

datetime.timedelta(1)

337

>>> parse_pre_1_6_1_interval('1w')

338

datetime.timedelta(7)

339

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

340

datetime.timedelta(0, 330)

341

>>> parse_pre_1_6_1_interval('')

342

datetime.timedelta(0)

343

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

344

>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')

345

datetime.timedelta(2, 480, 18000)

346

347

"""

348

349

value = datetime.timedelta(0)

350

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

351

352

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

353

if suffix == "d":

354

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

355

elif suffix == "s":

356

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

357

elif suffix == "m":

358

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

359

elif suffix == "h":

360

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

361

elif suffix == "w":

362

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

363

elif suffix == "":

364

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

365

return value

366

367

368

def check_option_syntax(parser, options):

369

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

370

argparse"""

371

372

def has_actions(options):

373

return any((options.enable,

374

options.disable,

375

options.bump_timeout,

376

options.start_checker,

377

options.stop_checker,

378

options.is_enabled,

379

options.remove,

380

options.checker is not None,

381

options.timeout is not None,

382

options.extended_timeout is not None,

383

options.interval is not None,

384

options.approved_by_default is not None,

385

options.approval_delay is not None,

386

options.approval_duration is not None,

387

options.host is not None,

388

options.secret is not None,

389

options.approve,

390

options.deny))

391

392

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

209

393

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

210

394

if options.verbose and has_actions(options):

211

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

212

" --all.")

395

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

396

if options.dump_json and (options.verbose

397

or has_actions(options)):

398

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

213

399

if options.all and not has_actions(options):

214

400

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

215

216

try:

217

bus = dbus.SystemBus()

218

mandos_dbus_objc = bus.get_object(busname, server_path)

219

except dbus.exceptions.DBusException:

220

print("Could not connect to Mandos server",

221

file=sys.stderr)

222

sys.exit(1)

223

224

mandos_serv = dbus.Interface(mandos_dbus_objc,

225

dbus_interface = server_interface)

226

227

#block stderr since dbus library prints to stderr

228

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

229

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

230

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

231

os.close(null)

232

try:

233

try:

234

mandos_clients = mandos_serv.GetAllClientsWithProperties()

235

finally:

236

#restore stderr

237

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

238

os.close(stderrcopy)

239

except dbus.exceptions.DBusException:

240

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

241

file=sys.stderr)

242

sys.exit(1)

243

244

# Compile dict of (clients: properties) to process

245

clients={}

246

247

if options.all or not options.client:

248

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

249

for path, properties in

250

mandos_clients.iteritems())

251

else:

252

for name in options.client:

253

for path, client in mandos_clients.iteritems():

254

if client["Name"] == name:

255

client_objc = bus.get_object(busname, path)

256

clients[client_objc] = client

257

break

258

else:

259

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

260

file=sys.stderr)

261

sys.exit(1)

262

263

if not has_actions(options) and clients:

264

if options.verbose:

265

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

266

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

267

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

401

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

402

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

403

if options.remove:

404

options.remove = False

405

if has_actions(options) and not options.deny:

406

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

407

options.remove = True

408

409

410

411

class dbus(object):

412

413

class SystemBus(object):

414

415

object_manager_iface = "org.freedesktop.DBus.ObjectManager"

416

def get_managed_objects(self, busname, objectpath):

417

return self.call_method("GetManagedObjects", busname,

418

objectpath,

419

self.object_manager_iface)

420

421

properties_iface = "org.freedesktop.DBus.Properties"

422

def set_property(self, busname, objectpath, interface, key,

423

value):

424

self.call_method("Set", busname, objectpath,

425

self.properties_iface, interface, key,

426

value)

427

428

429

class MandosBus(SystemBus):

430

busname_domain = "se.recompile"

431

busname = busname_domain + ".Mandos"

432

server_path = "/"

433

server_interface = busname_domain + ".Mandos"

434

client_interface = busname_domain + ".Mandos.Client"

435

del busname_domain

436

437

def get_clients_and_properties(self):

438

managed_objects = self.get_managed_objects(

439

self.busname, self.server_path)

440

return {objpath: properties[self.client_interface]

441

for objpath, properties in managed_objects.items()

442

if self.client_interface in properties}

443

444

def set_client_property(self, objectpath, key, value):

445

return self.set_property(self.busname, objectpath,

446

self.client_interface, key,

447

value)

448

449

def call_client_method(self, objectpath, method, *args):

450

return self.call_method(method, self.busname, objectpath,

451

self.client_interface, *args)

452

453

def call_server_method(self, method, *args):

454

return self.call_method(method, self.busname,

455

self.server_path,

456

self.server_interface, *args)

457

458

class Error(Exception):

459

pass

460

461

class ConnectFailed(Error):

462

pass

463

464

465

class dbus_python_adapter(object):

466

467

class SystemBus(dbus.MandosBus):

468

"""Use dbus-python"""

469

470

def __init__(self, module=dbus_python):

471

self.dbus_python = module

472

self.bus = self.dbus_python.SystemBus()

473

474

@contextlib.contextmanager

475

def convert_exception(self, exception_class=dbus.Error):

476

try:

477

yield

478

except self.dbus_python.exceptions.DBusException as e:

479

# This does what "raise from" would do

480

exc = exception_class(*e.args)

481

exc.__cause__ = e

482

raise exc

483

484

def call_method(self, methodname, busname, objectpath,

485

interface, *args):

486

proxy_object = self.get_object(busname, objectpath)

487

log.debug("D-Bus: %s:%s:%s.%s(%s)", busname, objectpath,

488

interface, methodname,

489

", ".join(repr(a) for a in args))

490

method = getattr(proxy_object, methodname)

491

with self.convert_exception():

492

with dbus_python_adapter.SilenceLogger(

493

"dbus.proxies"):

494

value = method(*args, dbus_interface=interface)

495

return self.type_filter(value)

496

497

def get_object(self, busname, objectpath):

498

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

499

busname, objectpath)

500

with self.convert_exception(dbus.ConnectFailed):

501

return self.bus.get_object(busname, objectpath)

502

503

def type_filter(self, value):

504

"""Convert the most bothersome types to Python types"""

505

if isinstance(value, self.dbus_python.Boolean):

506

return bool(value)

507

if isinstance(value, self.dbus_python.ObjectPath):

508

return str(value)

509

# Also recurse into dictionaries

510

if isinstance(value, self.dbus_python.Dictionary):

511

return {self.type_filter(key):

512

self.type_filter(subval)

513

for key, subval in value.items()}

514

return value

515

516

517

class SilenceLogger(object):

518

"Simple context manager to silence a particular logger"

519

def __init__(self, loggername):

520

self.logger = logging.getLogger(loggername)

521

522

def __enter__(self):

523

self.logger.addFilter(self.nullfilter)

524

525

class NullFilter(logging.Filter):

526

def filter(self, record):

527

return False

528

529

nullfilter = NullFilter()

530

531

def __exit__(self, exc_type, exc_val, exc_tb):

532

self.logger.removeFilter(self.nullfilter)

533

534

535

class CachingBus(SystemBus):

536

"""A caching layer for dbus_python_adapter.SystemBus"""

537

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

538

self.object_cache = {}

539

super(dbus_python_adapter.CachingBus,

540

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

541

def get_object(self, busname, objectpath):

542

try:

543

return self.object_cache[(busname, objectpath)]

544

except KeyError:

545

new_object = super(

546

dbus_python_adapter.CachingBus,

547

self).get_object(busname, objectpath)

548

self.object_cache[(busname, objectpath)] = new_object

549

return new_object

550

551

552

def commands_from_options(options):

553

554

commands = []

555

556

if options.is_enabled:

557

commands.append(command.IsEnabled())

558

559

if options.approve:

560

commands.append(command.Approve())

561

562

if options.deny:

563

commands.append(command.Deny())

564

565

if options.remove:

566

commands.append(command.Remove())

567

568

if options.dump_json:

569

commands.append(command.DumpJSON())

570

571

if options.enable:

572

commands.append(command.Enable())

573

574

if options.disable:

575

commands.append(command.Disable())

576

577

if options.bump_timeout:

578

commands.append(command.BumpTimeout())

579

580

if options.start_checker:

581

commands.append(command.StartChecker())

582

583

if options.stop_checker:

584

commands.append(command.StopChecker())

585

586

if options.approved_by_default is not None:

587

if options.approved_by_default:

588

commands.append(command.ApproveByDefault())

589

else:

590

commands.append(command.DenyByDefault())

591

592

if options.checker is not None:

593

commands.append(command.SetChecker(options.checker))

594

595

if options.host is not None:

596

commands.append(command.SetHost(options.host))

597

598

if options.secret is not None:

599

commands.append(command.SetSecret(options.secret))

600

601

if options.timeout is not None:

602

commands.append(command.SetTimeout(options.timeout))

603

604

if options.extended_timeout:

605

commands.append(

606

command.SetExtendedTimeout(options.extended_timeout))

607

608

if options.interval is not None:

609

commands.append(command.SetInterval(options.interval))

610

611

if options.approval_delay is not None:

612

commands.append(

613

command.SetApprovalDelay(options.approval_delay))

614

615

if options.approval_duration is not None:

616

commands.append(

617

command.SetApprovalDuration(options.approval_duration))

618

619

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

620

# optionally verbosely

621

if not commands:

622

commands.append(command.PrintTable(verbose=options.verbose))

623

624

return commands

625

626

627

class command(object):

628

"""A namespace for command classes"""

629

630

class Base(object):

631

"""Abstract base class for commands"""

632

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

633

"""Normal commands should implement run_on_one_client(),

634

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

635

override this run() method instead.

636

"""

637

self.bus = bus

638

for client, properties in clients.items():

639

self.run_on_one_client(client, properties)

640

641

642

class IsEnabled(Base):

643

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

644

properties = next(iter(clients.values()))

645

if properties["Enabled"]:

646

sys.exit(0)

647

sys.exit(1)

648

649

650

class Approve(Base):

651

def run_on_one_client(self, client, properties):

652

self.bus.call_client_method(client, "Approve", True)

653

654

655

class Deny(Base):

656

def run_on_one_client(self, client, properties):

657

self.bus.call_client_method(client, "Approve", False)

658

659

660

class Remove(Base):

661

def run(self, clients, bus):

662

for clientpath in frozenset(clients.keys()):

663

bus.call_server_method("RemoveClient", clientpath)

664

665

666

class Output(Base):

667

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

668

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

669

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

670

"Fingerprint", "CheckerRunning",

268

671

"LastEnabled", "ApprovalPending",

269

"ApprovedByDefault",

270

"LastApprovalRequest", "ApprovalDelay",

271

"ApprovalDuration", "Checker",

272

"ExtendedTimeout")

273

else:

274

keywords = defaultkeywords

275

276

print_clients(clients.values(), keywords)

277

else:

278

# Process each client in the list by all selected options

279

for client in clients:

280

if options.remove:

281

mandos_serv.RemoveClient(client.__dbus_object_path__)

282

if options.enable:

283

client.Enable(dbus_interface=client_interface)

284

if options.disable:

285

client.Disable(dbus_interface=client_interface)

286

if options.bump_timeout:

287

client.CheckedOK(dbus_interface=client_interface)

288

if options.start_checker:

289

client.StartChecker(dbus_interface=client_interface)

290

if options.stop_checker:

291

client.StopChecker(dbus_interface=client_interface)

292

if options.is_enabled:

293

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

294

"Enabled",

295

dbus_interface=

296

dbus.PROPERTIES_IFACE)

297

else 1)

298

if options.checker is not None:

299

client.Set(client_interface, "Checker",

300

options.checker,

301

dbus_interface=dbus.PROPERTIES_IFACE)

302

if options.host is not None:

303

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

304

dbus_interface=dbus.PROPERTIES_IFACE)

305

if options.interval is not None:

306

client.Set(client_interface, "Interval",

307

timedelta_to_milliseconds

308

(string_to_delta(options.interval)),

309

dbus_interface=dbus.PROPERTIES_IFACE)

310

if options.approval_delay is not None:

311

client.Set(client_interface, "ApprovalDelay",

312

timedelta_to_milliseconds

313

(string_to_delta(options.

314

approval_delay)),

315

dbus_interface=dbus.PROPERTIES_IFACE)

316

if options.approval_duration is not None:

317

client.Set(client_interface, "ApprovalDuration",

318

timedelta_to_milliseconds

319

(string_to_delta(options.

320

approval_duration)),

321

dbus_interface=dbus.PROPERTIES_IFACE)

322

if options.timeout is not None:

323

client.Set(client_interface, "Timeout",

324

timedelta_to_milliseconds

325

(string_to_delta(options.timeout)),

326

dbus_interface=dbus.PROPERTIES_IFACE)

327

if options.extended_timeout is not None:

328

client.Set(client_interface, "ExtendedTimeout",

329

timedelta_to_milliseconds

330

(string_to_delta(options.extended_timeout)),

331

dbus_interface=dbus.PROPERTIES_IFACE)

332

if options.secret is not None:

333

client.Set(client_interface, "Secret",

334

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

335

dbus_interface=dbus.PROPERTIES_IFACE)

336

if options.approved_by_default is not None:

337

client.Set(client_interface, "ApprovedByDefault",

338

dbus.Boolean(options

339

.approved_by_default),

340

dbus_interface=dbus.PROPERTIES_IFACE)

341

if options.approve:

342

client.Approve(dbus.Boolean(True),

343

dbus_interface=client_interface)

344

elif options.deny:

345

client.Approve(dbus.Boolean(False),

346

dbus_interface=client_interface)

672

"ApprovedByDefault", "LastApprovalRequest",

673

"ApprovalDelay", "ApprovalDuration",

674

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

675

"LastCheckerStatus")

676

677

678

class DumpJSON(Output):

679

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

680

data = {properties["Name"]:

681

{key: properties[key]

682

for key in self.all_keywords}

683

for properties in clients.values()}

684

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

685

686

687

class PrintTable(Output):

688

def __init__(self, verbose=False):

689

self.verbose = verbose

690

691

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

692

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

693

"LastCheckedOK")

694

keywords = default_keywords

695

if self.verbose:

696

keywords = self.all_keywords

697

print(self.TableOfClients(clients.values(), keywords))

698

699

class TableOfClients(object):

700

tableheaders = {

701

"Name": "Name",

702

"Enabled": "Enabled",

703

"Timeout": "Timeout",

704

"LastCheckedOK": "Last Successful Check",

705

"LastApprovalRequest": "Last Approval Request",

706

"Created": "Created",

707

"Interval": "Interval",

708

"Host": "Host",

709

"Fingerprint": "Fingerprint",

710

"KeyID": "Key ID",

711

"CheckerRunning": "Check Is Running",

712

"LastEnabled": "Last Enabled",

713

"ApprovalPending": "Approval Is Pending",

714

"ApprovedByDefault": "Approved By Default",

715

"ApprovalDelay": "Approval Delay",

716

"ApprovalDuration": "Approval Duration",

717

"Checker": "Checker",

718

"ExtendedTimeout": "Extended Timeout",

719

"Expires": "Expires",

720

"LastCheckerStatus": "Last Checker Status",

721

}

722

723

def __init__(self, clients, keywords):

724

self.clients = clients

725

self.keywords = keywords

726

727

def __str__(self):

728

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

729

730

if sys.version_info.major == 2:

731

__unicode__ = __str__

732

def __str__(self):

733

return str(self).encode(

734

locale.getpreferredencoding())

735

736

def rows(self):

737

format_string = self.row_formatting_string()

738

rows = [self.header_line(format_string)]

739

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

740

for client in self.clients)

741

return rows

742

743

def row_formatting_string(self):

744

"Format string used to format table rows"

745

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

746

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

747

*(len(self.string_from_client(client,

748

key))

749

for client in self.clients)),

750

key=key)

751

for key in self.keywords)

752

753

def string_from_client(self, client, key):

754

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

755

756

@classmethod

757

def valuetostring(cls, value, keyword):

758

if isinstance(value, bool):

759

return "Yes" if value else "No"

760

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

761

"ApprovalDuration", "ExtendedTimeout"):

762

return cls.milliseconds_to_string(value)

763

return str(value)

764

765

def header_line(self, format_string):

766

return format_string.format(**self.tableheaders)

767

768

def client_line(self, client, format_string):

769

return format_string.format(

770

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

771

for key in self.keywords})

772

773

@staticmethod

774

def milliseconds_to_string(ms):

775

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

776

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

777

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

778

if td.days else "",

779

hours=td.seconds // 3600,

780

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

781

seconds=td.seconds % 60))

782

783

784

class PropertySetter(Base):

785

"Abstract class for Actions for setting one client property"

786

787

def run_on_one_client(self, client, properties=None):

788

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

789

self.bus.set_client_property(client, self.propname,

790

self.value_to_set)

791

792

@property

793

def propname(self):

794

raise NotImplementedError()

795

796

797

class Enable(PropertySetter):

798

propname = "Enabled"

799

value_to_set = True

800

801

802

class Disable(PropertySetter):

803

propname = "Enabled"

804

value_to_set = False

805

806

807

class BumpTimeout(PropertySetter):

808

propname = "LastCheckedOK"

809

value_to_set = ""

810

811

812

class StartChecker(PropertySetter):

813

propname = "CheckerRunning"

814

value_to_set = True

815

816

817

class StopChecker(PropertySetter):

818

propname = "CheckerRunning"

819

value_to_set = False

820

821

822

class ApproveByDefault(PropertySetter):

823

propname = "ApprovedByDefault"

824

value_to_set = True

825

826

827

class DenyByDefault(PropertySetter):

828

propname = "ApprovedByDefault"

829

value_to_set = False

830

831

832

class PropertySetterValue(PropertySetter):

833

"""Abstract class for PropertySetter recieving a value as

834

constructor argument instead of a class attribute."""

835

def __init__(self, value):

836

self.value_to_set = value

837

838

839

class SetChecker(PropertySetterValue):

840

propname = "Checker"

841

842

843

class SetHost(PropertySetterValue):

844

propname = "Host"

845

846

847

class SetSecret(PropertySetterValue):

848

propname = "Secret"

849

850

@property

851

def value_to_set(self):

852

return self._vts

853

854

@value_to_set.setter

855

def value_to_set(self, value):

856

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

857

self._vts = value.read()

858

value.close()

859

860

861

class PropertySetterValueMilliseconds(PropertySetterValue):

862

"""Abstract class for PropertySetterValue taking a value

863

argument as a datetime.timedelta() but should store it as

864

milliseconds."""

865

866

@property

867

def value_to_set(self):

868

return self._vts

869

870

@value_to_set.setter

871

def value_to_set(self, value):

872

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

873

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

874

875

876

class SetTimeout(PropertySetterValueMilliseconds):

877

propname = "Timeout"

878

879

880

class SetExtendedTimeout(PropertySetterValueMilliseconds):

881

propname = "ExtendedTimeout"

882

883

884

class SetInterval(PropertySetterValueMilliseconds):

885

propname = "Interval"

886

887

888

class SetApprovalDelay(PropertySetterValueMilliseconds):

889

propname = "ApprovalDelay"

890

891

892

class SetApprovalDuration(PropertySetterValueMilliseconds):

893

propname = "ApprovalDuration"

894

895

896

897

class TestCaseWithAssertLogs(unittest.TestCase):

898

"""unittest.TestCase.assertLogs only exists in Python 3.4"""

899

900

if not hasattr(unittest.TestCase, "assertLogs"):

901

@contextlib.contextmanager

902

def assertLogs(self, logger, level=logging.INFO):

903

capturing_handler = self.CapturingLevelHandler(level)

904

old_level = logger.level

905

old_propagate = logger.propagate

906

logger.addHandler(capturing_handler)

907

logger.setLevel(level)

908

logger.propagate = False

909

try:

910

yield capturing_handler.watcher

911

finally:

912

logger.propagate = old_propagate

913

logger.removeHandler(capturing_handler)

914

logger.setLevel(old_level)

915

self.assertGreater(len(capturing_handler.watcher.records),

916

0)

917

918

class CapturingLevelHandler(logging.Handler):

919

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

920

logging.Handler.__init__(self, *args, **kwargs)

921

self.watcher = self.LoggingWatcher([], [])

922

def emit(self, record):

923

self.watcher.records.append(record)

924

self.watcher.output.append(self.format(record))

925

926

LoggingWatcher = collections.namedtuple("LoggingWatcher",

927

("records",

928

"output"))

929

930

931

class Unique(object):

932

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

933

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

934

935

936

class Test_string_to_delta(TestCaseWithAssertLogs):

937

# Just test basic RFC 3339 functionality here, the doc string for

938

# rfc3339_duration_to_delta() already has more comprehensive

939

# tests, which are run by doctest.

940

941

def test_rfc3339_zero_seconds(self):

942

self.assertEqual(datetime.timedelta(),

943

string_to_delta("PT0S"))

944

945

def test_rfc3339_zero_days(self):

946

self.assertEqual(datetime.timedelta(), string_to_delta("P0D"))

947

948

def test_rfc3339_one_second(self):

949

self.assertEqual(datetime.timedelta(0, 1),

950

string_to_delta("PT1S"))

951

952

def test_rfc3339_two_hours(self):

953

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

954

string_to_delta("PT2H"))

955

956

def test_falls_back_to_pre_1_6_1_with_warning(self):

957

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

958

value = string_to_delta("2h")

959

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

960

961

962

class Test_check_option_syntax(unittest.TestCase):

963

def setUp(self):

964

self.parser = argparse.ArgumentParser()

965

add_command_line_options(self.parser)

966

967

def test_actions_requires_client_or_all(self):

968

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

969

options = self.parser.parse_args()

970

setattr(options, action, value)

971

with self.assertParseError():

972

self.check_option_syntax(options)

973

974

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

975

# check_option_syntax()

976

actions = {

977

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

978

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

979

# never used

980

"enable": True,

981

"disable": True,

982

"bump_timeout": True,

983

"start_checker": True,

984

"stop_checker": True,

985

"is_enabled": True,

986

"remove": True,

987

"checker": "x",

988

"timeout": datetime.timedelta(),

989

"extended_timeout": datetime.timedelta(),

990

"interval": datetime.timedelta(),

991

"approved_by_default": True,

992

"approval_delay": datetime.timedelta(),

993

"approval_duration": datetime.timedelta(),

994

"host": "x",

995

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

996

"approve": True,

997

"deny": True,

998

}

999

1000

@contextlib.contextmanager

1001

def assertParseError(self):

1002

with self.assertRaises(SystemExit) as e:

1003

with self.redirect_stderr_to_devnull():

1004

yield

1005

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

1006

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

1007

# /argparse.html#exiting-methods

1008

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

1009

1010

@staticmethod

1011

@contextlib.contextmanager

1012

def redirect_stderr_to_devnull():

1013

old_stderr = sys.stderr

1014

with contextlib.closing(open(os.devnull, "w")) as null:

1015

sys.stderr = null

1016

try:

1017

yield

1018

finally:

1019

sys.stderr = old_stderr

1020

1021

def check_option_syntax(self, options):

1022

check_option_syntax(self.parser, options)

1023

1024

def test_actions_all_conflicts_with_verbose(self):

1025

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

1026

options = self.parser.parse_args()

1027

setattr(options, action, value)

1028

options.all = True

1029

options.verbose = True

1030

with self.assertParseError():

1031

self.check_option_syntax(options)

1032

1033

def test_actions_with_client_conflicts_with_verbose(self):

1034

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

1035

options = self.parser.parse_args()

1036

setattr(options, action, value)

1037

options.verbose = True

1038

options.client = ["client"]

1039

with self.assertParseError():

1040

self.check_option_syntax(options)

1041

1042

def test_dump_json_conflicts_with_verbose(self):

1043

options = self.parser.parse_args()

1044

options.dump_json = True

1045

options.verbose = True

1046

with self.assertParseError():

1047

self.check_option_syntax(options)

1048

1049

def test_dump_json_conflicts_with_action(self):

1050

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

1051

options = self.parser.parse_args()

1052

setattr(options, action, value)

1053

options.dump_json = True

1054

with self.assertParseError():

1055

self.check_option_syntax(options)

1056

1057

def test_all_can_not_be_alone(self):

1058

options = self.parser.parse_args()

1059

options.all = True

1060

with self.assertParseError():

1061

self.check_option_syntax(options)

1062

1063

def test_all_is_ok_with_any_action(self):

1064

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

1065

options = self.parser.parse_args()

1066

setattr(options, action, value)

1067

options.all = True

1068

self.check_option_syntax(options)

1069

1070

def test_any_action_is_ok_with_one_client(self):

1071

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

1072

options = self.parser.parse_args()

1073

setattr(options, action, value)

1074

options.client = ["client"]

1075

self.check_option_syntax(options)

1076

1077

def test_one_client_with_all_actions_except_is_enabled(self):

1078

options = self.parser.parse_args()

1079

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

1080

if action == "is_enabled":

1081

continue

1082

setattr(options, action, value)

1083

options.client = ["client"]

1084

self.check_option_syntax(options)

1085

1086

def test_two_clients_with_all_actions_except_is_enabled(self):

1087

options = self.parser.parse_args()

1088

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

1089

if action == "is_enabled":

1090

continue

1091

setattr(options, action, value)

1092

options.client = ["client1", "client2"]

1093

self.check_option_syntax(options)

1094

1095

def test_two_clients_are_ok_with_actions_except_is_enabled(self):

1096

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

1097

if action == "is_enabled":

1098

continue

1099

options = self.parser.parse_args()

1100

setattr(options, action, value)

1101

options.client = ["client1", "client2"]

1102

self.check_option_syntax(options)

1103

1104

def test_is_enabled_fails_without_client(self):

1105

options = self.parser.parse_args()

1106

options.is_enabled = True

1107

with self.assertParseError():

1108

self.check_option_syntax(options)

1109

1110

def test_is_enabled_fails_with_two_clients(self):

1111

options = self.parser.parse_args()

1112

options.is_enabled = True

1113

options.client = ["client1", "client2"]

1114

with self.assertParseError():

1115

self.check_option_syntax(options)

1116

1117

def test_remove_can_only_be_combined_with_action_deny(self):

1118

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

1119

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

1120

continue

1121

options = self.parser.parse_args()

1122

setattr(options, action, value)

1123

options.all = True

1124

options.remove = True

1125

with self.assertParseError():

1126

self.check_option_syntax(options)

1127

1128

1129

class Test_dbus_exceptions(unittest.TestCase):

1130

1131

def test_dbus_ConnectFailed_is_Error(self):

1132

with self.assertRaises(dbus.Error):

1133

raise dbus.ConnectFailed()

1134

1135

1136

class Test_dbus_MandosBus(unittest.TestCase):

1137

1138

class MockMandosBus(dbus.MandosBus):

1139

def __init__(self):

1140

self._name = "se.recompile.Mandos"

1141

self._server_path = "/"

1142

self._server_interface = "se.recompile.Mandos"

1143

self._client_interface = "se.recompile.Mandos.Client"

1144

self.calls = []

1145

self.call_method_return = Unique()

1146

1147

def call_method(self, methodname, busname, objectpath,

1148

interface, *args):

1149

self.calls.append((methodname, busname, objectpath,

1150

interface, args))

1151

return self.call_method_return

1152

1153

def setUp(self):

1154

self.bus = self.MockMandosBus()

1155

1156

def test_set_client_property(self):

1157

self.bus.set_client_property("objectpath", "key", "value")

1158

expected_call = ("Set", self.bus._name, "objectpath",

1159

"org.freedesktop.DBus.Properties",

1160

(self.bus._client_interface, "key", "value"))

1161

self.assertIn(expected_call, self.bus.calls)

1162

1163

def test_call_client_method(self):

1164

ret = self.bus.call_client_method("objectpath", "methodname")

1165

self.assertIs(self.bus.call_method_return, ret)

1166

expected_call = ("methodname", self.bus._name, "objectpath",

1167

self.bus._client_interface, ())

1168

self.assertIn(expected_call, self.bus.calls)

1169

1170

def test_call_client_method_with_args(self):

1171

args = (Unique(), Unique())

1172

ret = self.bus.call_client_method("objectpath", "methodname",

1173

*args)

1174

self.assertIs(self.bus.call_method_return, ret)

1175

expected_call = ("methodname", self.bus._name, "objectpath",

1176

self.bus._client_interface,

1177

(args[0], args[1]))

1178

self.assertIn(expected_call, self.bus.calls)

1179

1180

def test_get_clients_and_properties(self):

1181

managed_objects = {

1182

"objectpath": {

1183

self.bus._client_interface: {

1184

"key": "value",

1185

"bool": True,

1186

},

1187

"irrelevant_interface": {

1188

"key": "othervalue",

1189

"bool": False,

1190

},

1191

},

1192

"other_objectpath": {

1193

"other_irrelevant_interface": {

1194

"key": "value 3",

1195

"bool": None,

1196

},

1197

},

1198

}

1199

expected_clients_and_properties = {

1200

"objectpath": {

1201

"key": "value",

1202

"bool": True,

1203

}

1204

}

1205

self.bus.call_method_return = managed_objects

1206

ret = self.bus.get_clients_and_properties()

1207

self.assertDictEqual(expected_clients_and_properties, ret)

1208

expected_call = ("GetManagedObjects", self.bus._name,

1209

self.bus._server_path,

1210

"org.freedesktop.DBus.ObjectManager", ())

1211

self.assertIn(expected_call, self.bus.calls)

1212

1213

def test_call_server_method(self):

1214

ret = self.bus.call_server_method("methodname")

1215

self.assertIs(self.bus.call_method_return, ret)

1216

expected_call = ("methodname", self.bus._name,

1217

self.bus._server_path,

1218

self.bus._server_interface, ())

1219

self.assertIn(expected_call, self.bus.calls)

1220

1221

def test_call_server_method_with_args(self):

1222

args = (Unique(), Unique())

1223

ret = self.bus.call_server_method("methodname", *args)

1224

self.assertIs(self.bus.call_method_return, ret)

1225

expected_call = ("methodname", self.bus._name,

1226

self.bus._server_path,

1227

self.bus._server_interface,

1228

(args[0], args[1]))

1229

self.assertIn(expected_call, self.bus.calls)

1230

1231

1232

class Test_dbus_python_adapter_SystemBus(TestCaseWithAssertLogs):

1233

1234

def MockDBusPython_func(self, func):

1235

class mock_dbus_python(object):

1236

"""mock dbus-python module"""

1237

class exceptions(object):

1238

"""Pseudo-namespace"""

1239

class DBusException(Exception):

1240

pass

1241

class SystemBus(object):

1242

@staticmethod

1243

def get_object(busname, objectpath):

1244

DBusObject = collections.namedtuple(

1245

"DBusObject", ("methodname",))

1246

def method(*args, **kwargs):

1247

self.assertEqual({"dbus_interface":

1248

"interface"},

1249

kwargs)

1250

return func(*args)

1251

return DBusObject(methodname=method)

1252

class Boolean(object):

1253

def __init__(self, value):

1254

self.value = bool(value)

1255

def __bool__(self):

1256

return self.value

1257

if sys.version_info.major == 2:

1258

__nonzero__ = __bool__

1259

class ObjectPath(str):

1260

pass

1261

class Dictionary(dict):

1262

pass

1263

return mock_dbus_python

1264

1265

def call_method(self, bus, methodname, busname, objectpath,

1266

interface, *args):

1267

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

1268

return bus.call_method(methodname, busname, objectpath,

1269

interface, *args)

1270

1271

def test_call_method_returns(self):

1272

expected_method_return = Unique()

1273

method_args = (Unique(), Unique())

1274

def func(*args):

1275

self.assertEqual(len(method_args), len(args))

1276

for marg, arg in zip(method_args, args):

1277

self.assertIs(marg, arg)

1278

return expected_method_return

1279

mock_dbus_python = self.MockDBusPython_func(func)

1280

bus = dbus_python_adapter.SystemBus(mock_dbus_python)

1281

ret = self.call_method(bus, "methodname", "busname",

1282

"objectpath", "interface",

1283

*method_args)

1284

self.assertIs(ret, expected_method_return)

1285

1286

def test_call_method_filters_bool_true(self):

1287

def func():

1288

return method_return

1289

mock_dbus_python = self.MockDBusPython_func(func)

1290

bus = dbus_python_adapter.SystemBus(mock_dbus_python)

1291

method_return = mock_dbus_python.Boolean(True)

1292

ret = self.call_method(bus, "methodname", "busname",

1293

"objectpath", "interface")

1294

self.assertTrue(ret)

1295

self.assertNotIsInstance(ret, mock_dbus_python.Boolean)

1296

1297

def test_call_method_filters_bool_false(self):

1298

def func():

1299

return method_return

1300

mock_dbus_python = self.MockDBusPython_func(func)

1301

bus = dbus_python_adapter.SystemBus(mock_dbus_python)

1302

method_return = mock_dbus_python.Boolean(False)

1303

ret = self.call_method(bus, "methodname", "busname",

1304

"objectpath", "interface")

1305

self.assertFalse(ret)

1306

self.assertNotIsInstance(ret, mock_dbus_python.Boolean)

1307

1308

def test_call_method_filters_objectpath(self):

1309

def func():

1310

return method_return

1311

mock_dbus_python = self.MockDBusPython_func(func)

1312

bus = dbus_python_adapter.SystemBus(mock_dbus_python)

1313

method_return = mock_dbus_python.ObjectPath("objectpath")

1314

ret = self.call_method(bus, "methodname", "busname",

1315

"objectpath", "interface")

1316

self.assertEqual("objectpath", ret)

1317

self.assertIsNot("objectpath", ret)

1318

self.assertNotIsInstance(ret, mock_dbus_python.ObjectPath)

1319

1320

def test_call_method_filters_booleans_in_dict(self):

1321

def func():

1322

return method_return

1323

mock_dbus_python = self.MockDBusPython_func(func)

1324

bus = dbus_python_adapter.SystemBus(mock_dbus_python)

1325

method_return = mock_dbus_python.Dictionary(

1326

{mock_dbus_python.Boolean(True):

1327

mock_dbus_python.Boolean(False),

1328

mock_dbus_python.Boolean(False):

1329

mock_dbus_python.Boolean(True)})

1330

ret = self.call_method(bus, "methodname", "busname",

1331

"objectpath", "interface")

1332

expected_method_return = {True: False,

1333

False: True}

1334

self.assertEqual(expected_method_return, ret)

1335

self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)

1336

1337

def test_call_method_filters_objectpaths_in_dict(self):

1338

def func():

1339

return method_return

1340

mock_dbus_python = self.MockDBusPython_func(func)

1341

bus = dbus_python_adapter.SystemBus(mock_dbus_python)

1342

method_return = mock_dbus_python.Dictionary(

1343

{mock_dbus_python.ObjectPath("objectpath_key_1"):

1344

mock_dbus_python.ObjectPath("objectpath_value_1"),

1345

mock_dbus_python.ObjectPath("objectpath_key_2"):

1346

mock_dbus_python.ObjectPath("objectpath_value_2")})

1347

ret = self.call_method(bus, "methodname", "busname",

1348

"objectpath", "interface")

1349

expected_method_return = {str(key): str(value)

1350

for key, value in

1351

method_return.items()}

1352

self.assertEqual(expected_method_return, ret)

1353

self.assertIsInstance(ret, dict)

1354

self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)

1355

1356

def test_call_method_filters_dict_in_dict(self):

1357

def func():

1358

return method_return

1359

mock_dbus_python = self.MockDBusPython_func(func)

1360

bus = dbus_python_adapter.SystemBus(mock_dbus_python)

1361

method_return = mock_dbus_python.Dictionary(

1362

{"key1": mock_dbus_python.Dictionary({"key11": "value11",

1363

"key12": "value12"}),

1364

"key2": mock_dbus_python.Dictionary({"key21": "value21",

1365

"key22": "value22"})})

1366

ret = self.call_method(bus, "methodname", "busname",

1367

"objectpath", "interface")

1368

expected_method_return = {

1369

"key1": {"key11": "value11",

1370

"key12": "value12"},

1371

"key2": {"key21": "value21",

1372

"key22": "value22"},

1373

}

1374

self.assertEqual(expected_method_return, ret)

1375

self.assertIsInstance(ret, dict)

1376

self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)

1377

for key, value in ret.items():

1378

self.assertIsInstance(value, dict)

1379

self.assertEqual(expected_method_return[key], value)

1380

self.assertNotIsInstance(value,

1381

mock_dbus_python.Dictionary)

1382

1383

def test_call_method_filters_dict_three_deep(self):

1384

def func():

1385

return method_return

1386

mock_dbus_python = self.MockDBusPython_func(func)

1387

bus = dbus_python_adapter.SystemBus(mock_dbus_python)

1388

method_return = mock_dbus_python.Dictionary(

1389

{"key1":

1390

mock_dbus_python.Dictionary(

1391

{"key2":

1392

mock_dbus_python.Dictionary(

1393

{"key3":

1394

mock_dbus_python.Boolean(True),

1395

}),

1396

}),

1397

})

1398

ret = self.call_method(bus, "methodname", "busname",

1399

"objectpath", "interface")

1400

expected_method_return = {"key1": {"key2": {"key3": True}}}

1401

self.assertEqual(expected_method_return, ret)

1402

self.assertIsInstance(ret, dict)

1403

self.assertNotIsInstance(ret, mock_dbus_python.Dictionary)

1404

self.assertIsInstance(ret["key1"], dict)

1405

self.assertNotIsInstance(ret["key1"],

1406

mock_dbus_python.Dictionary)

1407

self.assertIsInstance(ret["key1"]["key2"], dict)

1408

self.assertNotIsInstance(ret["key1"]["key2"],

1409

mock_dbus_python.Dictionary)

1410

self.assertTrue(ret["key1"]["key2"]["key3"])

1411

self.assertNotIsInstance(ret["key1"]["key2"]["key3"],

1412

mock_dbus_python.Boolean)

1413

1414

def test_call_method_handles_exception(self):

1415

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

1416

1417

def func():

1418

dbus_logger.error("Test")

1419

raise mock_dbus_python.exceptions.DBusException()

1420

1421

mock_dbus_python = self.MockDBusPython_func(func)

1422

bus = dbus_python_adapter.SystemBus(mock_dbus_python)

1423

1424

class CountingHandler(logging.Handler):

1425

count = 0

1426

def emit(self, record):

1427

self.count += 1

1428

1429

counting_handler = CountingHandler()

1430

1431

dbus_logger.addHandler(counting_handler)

1432

1433

try:

1434

with self.assertRaises(dbus.Error) as e:

1435

self.call_method(bus, "methodname", "busname",

1436

"objectpath", "interface")

1437

finally:

1438

dbus_logger.removeFilter(counting_handler)

1439

1440

self.assertNotIsInstance(e, dbus.ConnectFailed)

1441

1442

# Make sure the dbus logger was suppressed

1443

self.assertEqual(0, counting_handler.count)

1444

1445

def test_get_object_converts_to_correct_exception(self):

1446

bus = dbus_python_adapter.SystemBus(

1447

self.fake_dbus_python_raises_exception_on_connect)

1448

with self.assertRaises(dbus.ConnectFailed):

1449

self.call_method(bus, "methodname", "busname",

1450

"objectpath", "interface")

1451

1452

class fake_dbus_python_raises_exception_on_connect(object):

1453

"""fake dbus-python module"""

1454

class exceptions(object):

1455

"""Pseudo-namespace"""

1456

class DBusException(Exception):

1457

pass

1458

1459

@classmethod

1460

def SystemBus(cls):

1461

def get_object(busname, objectpath):

1462

raise cls.exceptions.DBusException()

1463

Bus = collections.namedtuple("Bus", ["get_object"])

1464

return Bus(get_object=get_object)

1465

1466

1467

class Test_dbus_python_adapter_CachingBus(unittest.TestCase):

1468

class mock_dbus_python(object):

1469

"""mock dbus-python modules"""

1470

class SystemBus(object):

1471

@staticmethod

1472

def get_object(busname, objectpath):

1473

return Unique()

1474

1475

def setUp(self):

1476

self.bus = dbus_python_adapter.CachingBus(

1477

self.mock_dbus_python)

1478

1479

def test_returns_distinct_objectpaths(self):

1480

obj1 = self.bus.get_object("busname", "objectpath1")

1481

self.assertIsInstance(obj1, Unique)

1482

obj2 = self.bus.get_object("busname", "objectpath2")

1483

self.assertIsInstance(obj2, Unique)

1484

self.assertIsNot(obj1, obj2)

1485

1486

def test_returns_distinct_busnames(self):

1487

obj1 = self.bus.get_object("busname1", "objectpath")

1488

self.assertIsInstance(obj1, Unique)

1489

obj2 = self.bus.get_object("busname2", "objectpath")

1490

self.assertIsInstance(obj2, Unique)

1491

self.assertIsNot(obj1, obj2)

1492

1493

def test_returns_distinct_both(self):

1494

obj1 = self.bus.get_object("busname1", "objectpath")

1495

self.assertIsInstance(obj1, Unique)

1496

obj2 = self.bus.get_object("busname2", "objectpath")

1497

self.assertIsInstance(obj2, Unique)

1498

self.assertIsNot(obj1, obj2)

1499

1500

def test_returns_same(self):

1501

obj1 = self.bus.get_object("busname", "objectpath")

1502

self.assertIsInstance(obj1, Unique)

1503

obj2 = self.bus.get_object("busname", "objectpath")

1504

self.assertIsInstance(obj2, Unique)

1505

self.assertIs(obj1, obj2)

1506

1507

def test_returns_same_old(self):

1508

obj1 = self.bus.get_object("busname1", "objectpath1")

1509

self.assertIsInstance(obj1, Unique)

1510

obj2 = self.bus.get_object("busname2", "objectpath2")

1511

self.assertIsInstance(obj2, Unique)

1512

obj1b = self.bus.get_object("busname1", "objectpath1")

1513

self.assertIsInstance(obj1b, Unique)

1514

self.assertIsNot(obj1, obj2)

1515

self.assertIsNot(obj2, obj1b)

1516

self.assertIs(obj1, obj1b)

1517

1518

1519

class Test_commands_from_options(unittest.TestCase):

1520

1521

def setUp(self):

1522

self.parser = argparse.ArgumentParser()

1523

add_command_line_options(self.parser)

1524

1525

def test_is_enabled(self):

1526

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

1527

command.IsEnabled)

1528

1529

def assert_command_from_args(self, args, command_cls,

1530

**cmd_attrs):

1531

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

1532

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

1533

options = self.parser.parse_args(args)

1534

check_option_syntax(self.parser, options)

1535

commands = commands_from_options(options)

1536

self.assertEqual(1, len(commands))

1537

command = commands[0]

1538

self.assertIsInstance(command, command_cls)

1539

for key, value in cmd_attrs.items():

1540

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

1541

1542

def test_is_enabled_short(self):

1543

self.assert_command_from_args(["-V", "client"],

1544

command.IsEnabled)

1545

1546

def test_approve(self):

1547

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

1548

command.Approve)

1549

1550

def test_approve_short(self):

1551

self.assert_command_from_args(["-A", "client"],

1552

command.Approve)

1553

1554

def test_deny(self):

1555

self.assert_command_from_args(["--deny", "client"],

1556

command.Deny)

1557

1558

def test_deny_short(self):

1559

self.assert_command_from_args(["-D", "client"], command.Deny)

1560

1561

def test_remove(self):

1562

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

1563

command.Remove)

1564

1565

def test_deny_before_remove(self):

1566

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

1567

"client"])

1568

check_option_syntax(self.parser, options)

1569

commands = commands_from_options(options)

1570

self.assertEqual(2, len(commands))

1571

self.assertIsInstance(commands[0], command.Deny)

1572

self.assertIsInstance(commands[1], command.Remove)

1573

1574

def test_deny_before_remove_reversed(self):

1575

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

1576

"--all"])

1577

check_option_syntax(self.parser, options)

1578

commands = commands_from_options(options)

1579

self.assertEqual(2, len(commands))

1580

self.assertIsInstance(commands[0], command.Deny)

1581

self.assertIsInstance(commands[1], command.Remove)

1582

1583

def test_remove_short(self):

1584

self.assert_command_from_args(["-r", "client"],

1585

command.Remove)

1586

1587

def test_dump_json(self):

1588

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

1589

command.DumpJSON)

1590

1591

def test_enable(self):

1592

self.assert_command_from_args(["--enable", "client"],

1593

command.Enable)

1594

1595

def test_enable_short(self):

1596

self.assert_command_from_args(["-e", "client"],

1597

command.Enable)

1598

1599

def test_disable(self):

1600

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

1601

command.Disable)

1602

1603

def test_disable_short(self):

1604

self.assert_command_from_args(["-d", "client"],

1605

command.Disable)

1606

1607

def test_bump_timeout(self):

1608

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

1609

command.BumpTimeout)

1610

1611

def test_bump_timeout_short(self):

1612

self.assert_command_from_args(["-b", "client"],

1613

command.BumpTimeout)

1614

1615

def test_start_checker(self):

1616

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

1617

command.StartChecker)

1618

1619

def test_stop_checker(self):

1620

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

1621

command.StopChecker)

1622

1623

def test_approve_by_default(self):

1624

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

1625

"client"],

1626

command.ApproveByDefault)

1627

1628

def test_deny_by_default(self):

1629

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

1630

command.DenyByDefault)

1631

1632

def test_checker(self):

1633

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

1634

command.SetChecker,

1635

value_to_set=":")

1636

1637

def test_checker_empty(self):

1638

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

1639

command.SetChecker,

1640

value_to_set="")

1641

1642

def test_checker_short(self):

1643

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

1644

command.SetChecker,

1645

value_to_set=":")

1646

1647

def test_host(self):

1648

self.assert_command_from_args(

1649

["--host", "client.example.org", "client"],

1650

command.SetHost, value_to_set="client.example.org")

1651

1652

def test_host_short(self):

1653

self.assert_command_from_args(

1654

["-H", "client.example.org", "client"], command.SetHost,

1655

value_to_set="client.example.org")

1656

1657

def test_secret_devnull(self):

1658

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

1659

"client"], command.SetSecret,

1660

value_to_set=b"")

1661

1662

def test_secret_tempfile(self):

1663

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

1664

value = b"secret\0xyzzy\nbar"

1665

f.write(value)

1666

f.seek(0)

1667

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

1668

"client"],

1669

command.SetSecret,

1670

value_to_set=value)

1671

1672

def test_secret_devnull_short(self):

1673

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

1674

"client"], command.SetSecret,

1675

value_to_set=b"")

1676

1677

def test_secret_tempfile_short(self):

1678

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

1679

value = b"secret\0xyzzy\nbar"

1680

f.write(value)

1681

f.seek(0)

1682

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

1683

command.SetSecret,

1684

value_to_set=value)

1685

1686

def test_timeout(self):

1687

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

1688

command.SetTimeout,

1689

value_to_set=300000)

1690

1691

def test_timeout_short(self):

1692

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

1693

command.SetTimeout,

1694

value_to_set=300000)

1695

1696

def test_extended_timeout(self):

1697

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

1698

"client"],

1699

command.SetExtendedTimeout,

1700

value_to_set=900000)

1701

1702

def test_interval(self):

1703

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

1704

"client"], command.SetInterval,

1705

value_to_set=120000)

1706

1707

def test_interval_short(self):

1708

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

1709

command.SetInterval,

1710

value_to_set=120000)

1711

1712

def test_approval_delay(self):

1713

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

1714

"client"],

1715

command.SetApprovalDelay,

1716

value_to_set=30000)

1717

1718

def test_approval_duration(self):

1719

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

1720

"client"],

1721

command.SetApprovalDuration,

1722

value_to_set=1000)

1723

1724

def test_print_table(self):

1725

self.assert_command_from_args([], command.PrintTable,

1726

verbose=False)

1727

1728

def test_print_table_verbose(self):

1729

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

1730

command.PrintTable,

1731

verbose=True)

1732

1733

def test_print_table_verbose_short(self):

1734

self.assert_command_from_args(["-v"], command.PrintTable,

1735

verbose=True)

1736

1737

1738

class TestCommand(unittest.TestCase):

1739

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

1740

1741

class FakeMandosBus(dbus.MandosBus):

1742

def __init__(self, testcase):

1743

self.client_properties = {

1744

"Name": "foo",

1745

"KeyID": ("92ed150794387c03ce684574b1139a65"

1746

"94a34f895daaaf09fd8ea90a27cddb12"),

1747

"Secret": b"secret",

1748

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

1749

"Enabled": True,

1750

"Timeout": 300000,

1751

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

1752

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

1753

"Interval": 120000,

1754

"Fingerprint": ("778827225BA7DE539C5A"

1755

"7CFA59CFF7CDBD9A5920"),

1756

"CheckerRunning": False,

1757

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

1758

"ApprovalPending": False,

1759

"ApprovedByDefault": True,

1760

"LastApprovalRequest": "",

1761

"ApprovalDelay": 0,

1762

"ApprovalDuration": 1000,

1763

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

1764

"ExtendedTimeout": 900000,

1765

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

1766

"LastCheckerStatus": 0,

1767

}

1768

self.other_client_properties = {

1769

"Name": "barbar",

1770

"KeyID": ("0558568eedd67d622f5c83b35a115f79"

1771

"6ab612cff5ad227247e46c2b020f441c"),

1772

"Secret": b"secretbar",

1773

"Host": "192.0.2.3",

1774

"Enabled": True,

1775

"Timeout": 300000,

1776

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

1777

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

1778

"Interval": 120000,

1779

"Fingerprint": ("3E393AEAEFB84C7E89E2"

1780

"F547B3A107558FCA3A27"),

1781

"CheckerRunning": True,

1782

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

1783

"ApprovalPending": False,

1784

"ApprovedByDefault": False,

1785

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

1786

"ApprovalDelay": 30000,

1787

"ApprovalDuration": 93785000,

1788

"Checker": ":",

1789

"ExtendedTimeout": 900000,

1790

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

1791

"LastCheckerStatus": -2,

1792

}

1793

self.clients = collections.OrderedDict(

1794

[

1795

("client_objectpath", self.client_properties),

1796

("other_client_objectpath",

1797

self.other_client_properties),

1798

])

1799

self.one_client = {"client_objectpath":

1800

self.client_properties}

1801

self.testcase = testcase

1802

self.calls = []

1803

1804

def call_method(self, methodname, busname, objectpath,

1805

interface, *args):

1806

self.testcase.assertEqual("se.recompile.Mandos", busname)

1807

self.calls.append((methodname, busname, objectpath,

1808

interface, args))

1809

if interface == "org.freedesktop.DBus.Properties":

1810

if methodname == "Set":

1811

self.testcase.assertEqual(3, len(args))

1812

interface, key, value = args

1813

self.testcase.assertEqual(

1814

"se.recompile.Mandos.Client", interface)

1815

self.clients[objectpath][key] = value

1816

return

1817

elif interface == "se.recompile.Mandos":

1818

self.testcase.assertEqual("RemoveClient", methodname)

1819

self.testcase.assertEqual(1, len(args))

1820

clientpath = args[0]

1821

del self.clients[clientpath]

1822

return

1823

elif interface == "se.recompile.Mandos.Client":

1824

if methodname == "Approve":

1825

self.testcase.assertEqual(1, len(args))

1826

return

1827

raise ValueError()

1828

1829

def setUp(self):

1830

self.bus = self.FakeMandosBus(self)

1831

1832

1833

class TestBaseCommands(TestCommand):

1834

1835

def test_IsEnabled_exits_successfully(self):

1836

with self.assertRaises(SystemExit) as e:

1837

command.IsEnabled().run(self.bus.one_client)

1838

if e.exception.code is not None:

1839

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

1840

else:

1841

self.assertIsNone(e.exception.code)

1842

1843

def test_IsEnabled_exits_with_failure(self):

1844

self.bus.client_properties["Enabled"] = False

1845

with self.assertRaises(SystemExit) as e:

1846

command.IsEnabled().run(self.bus.one_client)

1847

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

1848

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

1849

else:

1850

self.assertIsNotNone(e.exception.code)

1851

1852

def test_Approve(self):

1853

busname = "se.recompile.Mandos"

1854

client_interface = "se.recompile.Mandos.Client"

1855

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

1856

for clientpath in self.bus.clients:

1857

self.assertIn(("Approve", busname, clientpath,

1858

client_interface, (True,)), self.bus.calls)

1859

1860

def test_Deny(self):

1861

busname = "se.recompile.Mandos"

1862

client_interface = "se.recompile.Mandos.Client"

1863

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

1864

for clientpath in self.bus.clients:

1865

self.assertIn(("Approve", busname, clientpath,

1866

client_interface, (False,)),

1867

self.bus.calls)

1868

1869

def test_Remove(self):

1870

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

1871

for clientpath in self.bus.clients:

1872

self.assertIn(("RemoveClient", dbus_busname,

1873

dbus_server_path, dbus_server_interface,

1874

(clientpath,)), self.bus.calls)

1875

1876

expected_json = {

1877

"foo": {

1878

"Name": "foo",

1879

"KeyID": ("92ed150794387c03ce684574b1139a65"

1880

"94a34f895daaaf09fd8ea90a27cddb12"),

1881

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

1882

"Enabled": True,

1883

"Timeout": 300000,

1884

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

1885

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

1886

"Interval": 120000,

1887

"Fingerprint": ("778827225BA7DE539C5A"

1888

"7CFA59CFF7CDBD9A5920"),

1889

"CheckerRunning": False,

1890

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

1891

"ApprovalPending": False,

1892

"ApprovedByDefault": True,

1893

"LastApprovalRequest": "",

1894

"ApprovalDelay": 0,

1895

"ApprovalDuration": 1000,

1896

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

1897

"ExtendedTimeout": 900000,

1898

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

1899

"LastCheckerStatus": 0,

1900

},

1901

"barbar": {

1902

"Name": "barbar",

1903

"KeyID": ("0558568eedd67d622f5c83b35a115f79"

1904

"6ab612cff5ad227247e46c2b020f441c"),

1905

"Host": "192.0.2.3",

1906

"Enabled": True,

1907

"Timeout": 300000,

1908

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

1909

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

1910

"Interval": 120000,

1911

"Fingerprint": ("3E393AEAEFB84C7E89E2"

1912

"F547B3A107558FCA3A27"),

1913

"CheckerRunning": True,

1914

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

1915

"ApprovalPending": False,

1916

"ApprovedByDefault": False,

1917

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

1918

"ApprovalDelay": 30000,

1919

"ApprovalDuration": 93785000,

1920

"Checker": ":",

1921

"ExtendedTimeout": 900000,

1922

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

1923

"LastCheckerStatus": -2,

1924

},

1925

}

1926

1927

def test_DumpJSON_normal(self):

1928

with self.capture_stdout_to_buffer() as buffer:

1929

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

1930

json_data = json.loads(buffer.getvalue())

1931

self.assertDictEqual(self.expected_json, json_data)

1932

1933

@staticmethod

1934

@contextlib.contextmanager

1935

def capture_stdout_to_buffer():

1936

capture_buffer = io.StringIO()

1937

old_stdout = sys.stdout

1938

sys.stdout = capture_buffer

1939

try:

1940

yield capture_buffer

1941

finally:

1942

sys.stdout = old_stdout

1943

1944

def test_DumpJSON_one_client(self):

1945

with self.capture_stdout_to_buffer() as buffer:

1946

command.DumpJSON().run(self.bus.one_client)

1947

json_data = json.loads(buffer.getvalue())

1948

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

1949

self.assertDictEqual(expected_json, json_data)

1950

1951

def test_PrintTable_normal(self):

1952

with self.capture_stdout_to_buffer() as buffer:

1953

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

1954

expected_output = "\n".join((

1955

"Name Enabled Timeout Last Successful Check",

1956

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

1957

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

1958

)) + "\n"

1959

self.assertEqual(expected_output, buffer.getvalue())

1960

1961

def test_PrintTable_verbose(self):

1962

with self.capture_stdout_to_buffer() as buffer:

1963

command.PrintTable(verbose=True).run(self.bus.clients)

1964

columns = (

1965

(

1966

"Name ",

1967

"foo ",

1968

"barbar ",

1969

),(

1970

"Enabled ",

1971

"Yes ",

1972

"Yes ",

1973

),(

1974

"Timeout ",

1975

"00:05:00 ",

1976

"00:05:00 ",

1977

),(

1978

"Last Successful Check ",

1979

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

1980

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

1981

),(

1982

"Created ",

1983

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

1984

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

1985

),(

1986

"Interval ",

1987

"00:02:00 ",

1988

"00:02:00 ",

1989

),(

1990

"Host ",

1991

"foo.example.org ",

1992

"192.0.2.3 ",

1993

),(

1994

("Key ID "

1995

" "),

1996

("92ed150794387c03ce684574b1139a6594a34f895daaaf09fd8"

1997

"ea90a27cddb12 "),

1998

("0558568eedd67d622f5c83b35a115f796ab612cff5ad227247e"

1999

"46c2b020f441c "),

2000

),(

2001

"Fingerprint ",

2002

"778827225BA7DE539C5A7CFA59CFF7CDBD9A5920 ",

2003

"3E393AEAEFB84C7E89E2F547B3A107558FCA3A27 ",

2004

),(

2005

"Check Is Running ",

2006

"No ",

2007

"Yes ",

2008

),(

2009

"Last Enabled ",

2010

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

2011

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

2012

),(

2013

"Approval Is Pending ",

2014

"No ",

2015

"No ",

2016

),(

2017

"Approved By Default ",

2018

"Yes ",

2019

"No ",

2020

),(

2021

"Last Approval Request ",

2022

" ",

2023

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

2024

),(

2025

"Approval Delay ",

2026

"00:00:00 ",

2027

"00:00:30 ",

2028

),(

2029

"Approval Duration ",

2030

"00:00:01 ",

2031

"1T02:03:05 ",

2032

),(

2033

"Checker ",

2034

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

2035

": ",

2036

),(

2037

"Extended Timeout ",

2038

"00:15:00 ",

2039

"00:15:00 ",

2040

),(

2041

"Expires ",

2042

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

2043

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

2044

),(

2045

"Last Checker Status",

2046

"0 ",

2047

"-2 ",

2048

)

2049

)

2050

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

2051

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

2052

for rows in columns)

2053

for line in range(num_lines))

2054

+ "\n")

2055

self.assertEqual(expected_output, buffer.getvalue())

2056

2057

def test_PrintTable_one_client(self):

2058

with self.capture_stdout_to_buffer() as buffer:

2059

command.PrintTable().run(self.bus.one_client)

2060

expected_output = "\n".join((

2061

"Name Enabled Timeout Last Successful Check",

2062

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

2063

)) + "\n"

2064

self.assertEqual(expected_output, buffer.getvalue())

2065

2066

2067

class TestPropertySetterCmd(TestCommand):

2068

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

2069

2070

def runTest(self):

2071

if not hasattr(self, "command"):

2072

return # Abstract TestCase class

2073

values_to_get = getattr(self, "values_to_get",

2074

self.values_to_set)

2075

for value_to_set, value_to_get in zip(self.values_to_set,

2076

values_to_get):

2077

for clientpath in self.bus.clients:

2078

self.bus.clients[clientpath][self.propname] = Unique()

2079

self.run_command(value_to_set, self.bus.clients)

2080

for clientpath in self.bus.clients:

2081

value = self.bus.clients[clientpath][self.propname]

2082

self.assertNotIsInstance(value, Unique)

2083

self.assertEqual(value_to_get, value)

2084

2085

def run_command(self, value, clients):

2086

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

2087

2088

2089

class TestEnableCmd(TestPropertySetterCmd):

2090

command = command.Enable

2091

propname = "Enabled"

2092

values_to_set = [True]

2093

2094

2095

class TestDisableCmd(TestPropertySetterCmd):

2096

command = command.Disable

2097

propname = "Enabled"

2098

values_to_set = [False]

2099

2100

2101

class TestBumpTimeoutCmd(TestPropertySetterCmd):

2102

command = command.BumpTimeout

2103

propname = "LastCheckedOK"

2104

values_to_set = [""]

2105

2106

2107

class TestStartCheckerCmd(TestPropertySetterCmd):

2108

command = command.StartChecker

2109

propname = "CheckerRunning"

2110

values_to_set = [True]

2111

2112

2113

class TestStopCheckerCmd(TestPropertySetterCmd):

2114

command = command.StopChecker

2115

propname = "CheckerRunning"

2116

values_to_set = [False]

2117

2118

2119

class TestApproveByDefaultCmd(TestPropertySetterCmd):

2120

command = command.ApproveByDefault

2121

propname = "ApprovedByDefault"

2122

values_to_set = [True]

2123

2124

2125

class TestDenyByDefaultCmd(TestPropertySetterCmd):

2126

command = command.DenyByDefault

2127

propname = "ApprovedByDefault"

2128

values_to_set = [False]

2129

2130

2131

class TestPropertySetterValueCmd(TestPropertySetterCmd):

2132

"""Abstract class for tests of PropertySetterValueCmd classes"""

2133

2134

def run_command(self, value, clients):

2135

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

2136

2137

2138

class TestSetCheckerCmd(TestPropertySetterValueCmd):

2139

command = command.SetChecker

2140

propname = "Checker"

2141

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

2142

2143

2144

class TestSetHostCmd(TestPropertySetterValueCmd):

2145

command = command.SetHost

2146

propname = "Host"

2147

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

2148

2149

2150

class TestSetSecretCmd(TestPropertySetterValueCmd):

2151

command = command.SetSecret

2152

propname = "Secret"

2153

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

2154

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

2155

values_to_get = [f.getvalue() for f in values_to_set]

2156

2157

2158

class TestSetTimeoutCmd(TestPropertySetterValueCmd):

2159

command = command.SetTimeout

2160

propname = "Timeout"

2161

values_to_set = [datetime.timedelta(),

2162

datetime.timedelta(minutes=5),

2163

datetime.timedelta(seconds=1),

2164

datetime.timedelta(weeks=1),

2165

datetime.timedelta(weeks=52)]

2166

values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]

2167

2168

2169

class TestSetExtendedTimeoutCmd(TestPropertySetterValueCmd):

2170

command = command.SetExtendedTimeout

2171

propname = "ExtendedTimeout"

2172

values_to_set = [datetime.timedelta(),

2173

datetime.timedelta(minutes=5),

2174

datetime.timedelta(seconds=1),

2175

datetime.timedelta(weeks=1),

2176

datetime.timedelta(weeks=52)]

2177

values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]

2178

2179

2180

class TestSetIntervalCmd(TestPropertySetterValueCmd):

2181

command = command.SetInterval

2182

propname = "Interval"

2183

values_to_set = [datetime.timedelta(),

2184

datetime.timedelta(minutes=5),

2185

datetime.timedelta(seconds=1),

2186

datetime.timedelta(weeks=1),

2187

datetime.timedelta(weeks=52)]

2188

values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]

2189

2190

2191

class TestSetApprovalDelayCmd(TestPropertySetterValueCmd):

2192

command = command.SetApprovalDelay

2193

propname = "ApprovalDelay"

2194

values_to_set = [datetime.timedelta(),

2195

datetime.timedelta(minutes=5),

2196

datetime.timedelta(seconds=1),

2197

datetime.timedelta(weeks=1),

2198

datetime.timedelta(weeks=52)]

2199

values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]

2200

2201

2202

class TestSetApprovalDurationCmd(TestPropertySetterValueCmd):

2203

command = command.SetApprovalDuration

2204

propname = "ApprovalDuration"

2205

values_to_set = [datetime.timedelta(),

2206

datetime.timedelta(minutes=5),

2207

datetime.timedelta(seconds=1),

2208

datetime.timedelta(weeks=1),

2209

datetime.timedelta(weeks=52)]

2210

values_to_get = [dt.total_seconds()*1000 for dt in values_to_set]

2211

2212

2213

2214

def should_only_run_tests():

2215

parser = argparse.ArgumentParser(add_help=False)

2216

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

2217

args, unknown_args = parser.parse_known_args()

2218

run_tests = args.check

2219

if run_tests:

2220

# Remove --check argument from sys.argv

2221

sys.argv[1:] = unknown_args

2222

return run_tests

2223

2224

# Add all tests from doctest strings

2225

def load_tests(loader, tests, none):

2226

import doctest

2227

tests.addTests(doctest.DocTestSuite())

2228

return tests

347

2229

348

2230

if __name__ == "__main__":

349

main()

2231

try:

2232

if should_only_run_tests():

2233

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

2234

unittest.main()

2235

else:

2236

main()

2237

finally:

2238

logging.shutdown()