/mandos/release : revision 237.7.14

22

# Contact the authors at <mandos@fukt.bsnet.se>.

23

#

24

25

from __future__ import division

25

from __future__ import (division, absolute_import, print_function,

26

unicode_literals)

27

26

28

import sys

27

29

import dbus

28

30

from optparse import OptionParser

31

33

import re

32

34

import os

33

35

34

locale.setlocale(locale.LC_ALL, u'')

36

locale.setlocale(locale.LC_ALL, "")

35

37

36

38

tablewords = {

37

'Name': u'Name',

38

'Enabled': u'Enabled',

39

'Timeout': u'Timeout',

40

'LastCheckedOK': u'Last Successful Check',

41

'LastApprovalRequest': u'Last Approval Request',

42

'Created': u'Created',

43

'Interval': u'Interval',

44

'Host': u'Host',

45

'Fingerprint': u'Fingerprint',

46

'CheckerRunning': u'Check Is Running',

47

'LastEnabled': u'Last Enabled',

48

'ApprovalPending': u'Approval Is Pending',

49

'ApprovedByDefault': u'Approved By Default',

50

'ApprovalDelay': u"Approval Delay",

51

'ApprovalDuration': u"Approval Duration",

52

'Checker': u'Checker',

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

53

55

}

54

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

55

domain = 'se.bsnet.fukt'

56

busname = domain + '.Mandos'

57

server_path = '/'

58

server_interface = domain + '.Mandos'

59

client_interface = domain + '.Mandos.Client'

60

version = "1.2.1"

56

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

57

domain = "se.bsnet.fukt"

58

busname = domain + ".Mandos"

59

server_path = "/"

60

server_interface = domain + ".Mandos"

61

client_interface = domain + ".Mandos.Client"

62

version = "1.2.3"

61

63

62

64

def timedelta_to_milliseconds(td):

63

"Convert a datetime.timedelta object to milliseconds"

65

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

64

66

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

65

67

+ (td.seconds * 1000)

66

68

+ (td.microseconds // 1000))

67

69

68

70

def milliseconds_to_string(ms):

69

71

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

70

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

72

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

71

73

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

72

74

"hours": td.seconds // 3600,

73

75

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

78

80

def string_to_delta(interval):

79

81

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

80

82

81

>>> string_to_delta('7d')

83

>>> string_to_delta("7d")

82

84

datetime.timedelta(7)

83

>>> string_to_delta('60s')

85

>>> string_to_delta("60s")

84

86

datetime.timedelta(0, 60)

85

>>> string_to_delta('60m')

87

>>> string_to_delta("60m")

86

88

datetime.timedelta(0, 3600)

87

>>> string_to_delta('24h')

89

>>> string_to_delta("24h")

88

90

datetime.timedelta(1)

89

>>> string_to_delta(u'1w')

91

>>> string_to_delta("1w")

90

92

datetime.timedelta(7)

91

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

93

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

92

94

datetime.timedelta(0, 330)

93

95

"""

94

96

timevalue = datetime.timedelta(0)

98

100

try:

99

101

suffix = unicode(s[-1])

100

102

value = int(s[:-1])

101

if suffix == u"d":

103

if suffix == "d":

102

104

delta = datetime.timedelta(value)

103

elif suffix == u"s":

105

elif suffix == "s":

104

106

delta = datetime.timedelta(0, value)

105

elif suffix == u"m":

107

elif suffix == "m":

106

108

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

107

elif suffix == u"h":

109

elif suffix == "h":

108

110

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

109

elif suffix == u"w":

111

elif suffix == "w":

110

112

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

111

113

else:

112

114

raise ValueError

118

120

def print_clients(clients, keywords):

119

121

def valuetostring(value, keyword):

120

122

if type(value) is dbus.Boolean:

121

return u"Yes" if value else u"No"

122

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

123

u"ApprovalDuration"):

123

return "Yes" if value else "No"

124

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

125

"ApprovalDuration"):

124

126

return milliseconds_to_string(value)

125

127

return unicode(value)

126

128

127

129

# Create format string to print table rows

128

format_string = u' '.join(u'%%-%ds' %

129

max(len(tablewords[key]),

130

max(len(valuetostring(client[key],

131

key))

132

for client in

133

clients))

134

for key in keywords)

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)

135

137

# Print header line

136

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

138

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

137

139

for client in clients:

138

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

139

for key in keywords)

140

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

141

for key in keywords))

140

142

141

143

def has_actions(options):

142

144

return any((options.enable,

184

186

parser.add_option("-i", "--interval", type="string",

185

187

help="Set checker interval for client")

186

188

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

187

dest=u"approved_by_default",

189

dest="approved_by_default",

188

190

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

189

191

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

190

dest=u"approved_by_default",

192

dest="approved_by_default",

191

193

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

192

194

parser.add_option("--approval-delay", type="string",

193

195

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

204

206

options, client_names = parser.parse_args()

205

207

206

208

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

207

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

209

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

208

210

if options.verbose and has_actions(options):

209

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

210

' --all.')

211

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

212

" --all.")

211

213

if options.all and not has_actions(options):

212

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

214

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

213

215

214

216

try:

215

217

bus = dbus.SystemBus()

216

218

mandos_dbus_objc = bus.get_object(busname, server_path)

217

219

except dbus.exceptions.DBusException:

218

print >> sys.stderr, "Could not connect to Mandos server"

220

print("Could not connect to Mandos server",

221

file=sys.stderr)

219

222

sys.exit(1)

220

223

221

224

mandos_serv = dbus.Interface(mandos_dbus_objc,

234

237

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

235

238

os.close(stderrcopy)

236

239

except dbus.exceptions.DBusException, e:

237

print >> sys.stderr, "Access denied: Accessing mandos server through dbus."

240

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

241

file=sys.stderr)

238

242

sys.exit(1)

239

243

240

244

# Compile dict of (clients: properties) to process

247

251

else:

248

252

for name in client_names:

249

253

for path, client in mandos_clients.iteritems():

250

if client['Name'] == name:

254

if client["Name"] == name:

251

255

client_objc = bus.get_object(busname, path)

252

256

clients[client_objc] = client

253

257

break

254

258

else:

255

print >> sys.stderr, "Client not found on server: %r" % name

259

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

260

file=sys.stderr)

256

261

sys.exit(1)

257

262

258

263

if not has_actions(options) and clients:

259

264

if options.verbose:

260

keywords = ('Name', 'Enabled', 'Timeout',

261

'LastCheckedOK', 'Created', 'Interval',

262

'Host', 'Fingerprint', 'CheckerRunning',

263

'LastEnabled', 'ApprovalPending',

264

'ApprovedByDefault',

265

'LastApprovalRequest', 'ApprovalDelay',

266

'ApprovalDuration', 'Checker')

265

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

266

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

267

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

268

"LastEnabled", "ApprovalPending",

269

"ApprovedByDefault",

270

"LastApprovalRequest", "ApprovalDelay",

271

"ApprovalDuration", "Checker")

267

272

else:

268

273

keywords = defaultkeywords

269

274

285

290

client.StopChecker(dbus_interface=client_interface)

286

291

if options.is_enabled:

287

292

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

288

u"Enabled",

293

"Enabled",

289

294

dbus_interface=dbus.PROPERTIES_IFACE)

290

295

else 1)

291

296

if options.checker:

292

client.Set(client_interface, u"Checker", options.checker,

297

client.Set(client_interface, "Checker", options.checker,

293

298

dbus_interface=dbus.PROPERTIES_IFACE)

294

299

if options.host:

295

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

300

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

296

301

dbus_interface=dbus.PROPERTIES_IFACE)

297

302

if options.interval:

298

client.Set(client_interface, u"Interval",

303

client.Set(client_interface, "Interval",

299

304

timedelta_to_milliseconds

300

305

(string_to_delta(options.interval)),

301

306

dbus_interface=dbus.PROPERTIES_IFACE)

302

307

if options.approval_delay:

303

client.Set(client_interface, u"ApprovalDelay",

308

client.Set(client_interface, "ApprovalDelay",

304

309

timedelta_to_milliseconds

305

310

(string_to_delta(options.

306

311

approval_delay)),

307

312

dbus_interface=dbus.PROPERTIES_IFACE)

308

313

if options.approval_duration:

309

client.Set(client_interface, u"ApprovalDuration",

314

client.Set(client_interface, "ApprovalDuration",

310

315

timedelta_to_milliseconds

311

316

(string_to_delta(options.

312

317

approval_duration)),

313

318

dbus_interface=dbus.PROPERTIES_IFACE)

314

319

if options.timeout:

315

client.Set(client_interface, u"Timeout",

320

client.Set(client_interface, "Timeout",

316

321

timedelta_to_milliseconds

317

322

(string_to_delta(options.timeout)),

318

323

dbus_interface=dbus.PROPERTIES_IFACE)

319

324

if options.secret:

320

client.Set(client_interface, u"Secret",

325

client.Set(client_interface, "Secret",

321

326

dbus.ByteArray(open(options.secret,

322

u'rb').read()),

327

"rb").read()),

323

328

dbus_interface=dbus.PROPERTIES_IFACE)

324

329

if options.approved_by_default is not None:

325

client.Set(client_interface, u"ApprovedByDefault",

330

client.Set(client_interface, "ApprovedByDefault",

326

331

dbus.Boolean(options

327

332

.approved_by_default),

328

333

dbus_interface=dbus.PROPERTIES_IFACE)

333

338

client.Approve(dbus.Boolean(False),

334

339

dbus_interface=client_interface)

335

340

336

if __name__ == '__main__':

341

if __name__ == "__main__":

337

342

main()