/mandos/release : revision 275

22

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

23

#

24

25

from __future__ import (division, absolute_import, print_function,

26

unicode_literals)

27

25

from __future__ import division

28

26

import sys

29

27

import dbus

30

28

from optparse import OptionParser

33

31

import re

34

32

import os

35

33

36

locale.setlocale(locale.LC_ALL, "")

34

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

37

35

38

36

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

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

55

53

}

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"

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"

63

61

64

62

def timedelta_to_milliseconds(td):

65

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

63

"Convert a datetime.timedelta object to milliseconds"

66

64

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

67

65

+ (td.seconds * 1000)

68

66

+ (td.microseconds // 1000))

69

67

70

68

def milliseconds_to_string(ms):

71

69

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

72

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

70

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

73

71

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

74

72

"hours": td.seconds // 3600,

75

73

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

80

78

def string_to_delta(interval):

81

79

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

82

80

83

>>> string_to_delta("7d")

81

>>> string_to_delta('7d')

84

82

datetime.timedelta(7)

85

>>> string_to_delta("60s")

83

>>> string_to_delta('60s')

86

84

datetime.timedelta(0, 60)

87

>>> string_to_delta("60m")

85

>>> string_to_delta('60m')

88

86

datetime.timedelta(0, 3600)

89

>>> string_to_delta("24h")

87

>>> string_to_delta('24h')

90

88

datetime.timedelta(1)

91

>>> string_to_delta("1w")

89

>>> string_to_delta(u'1w')

92

90

datetime.timedelta(7)

93

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

91

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

94

92

datetime.timedelta(0, 330)

95

93

"""

96

94

timevalue = datetime.timedelta(0)

100

98

try:

101

99

suffix = unicode(s[-1])

102

100

value = int(s[:-1])

103

if suffix == "d":

101

if suffix == u"d":

104

102

delta = datetime.timedelta(value)

105

elif suffix == "s":

103

elif suffix == u"s":

106

104

delta = datetime.timedelta(0, value)

107

elif suffix == "m":

105

elif suffix == u"m":

108

106

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

109

elif suffix == "h":

107

elif suffix == u"h":

110

108

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

111

elif suffix == "w":

109

elif suffix == u"w":

112

110

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

113

111

else:

114

112

raise ValueError

120

118

def print_clients(clients, keywords):

121

119

def valuetostring(value, keyword):

122

120

if type(value) is dbus.Boolean:

123

return "Yes" if value else "No"

124

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

125

"ApprovalDuration"):

121

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

122

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

123

u"ApprovalDuration"):

126

124

return milliseconds_to_string(value)

127

125

return unicode(value)

128

126

129

127

# Create format string to print table rows

130

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

131

max(len(tablewords[key]),

132

max(len(valuetostring(client[key],

133

key))

134

for client in

135

clients))

136

for key in keywords)

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)

137

135

# Print header line

138

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

136

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

139

137

for client in clients:

140

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

141

for key in keywords))

138

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

139

for key in keywords)

142

140

143

141

def has_actions(options):

144

142

return any((options.enable,

186

184

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

187

185

help="Set checker interval for client")

188

186

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

189

dest="approved_by_default",

187

dest=u"approved_by_default",

190

188

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

191

189

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

192

dest="approved_by_default",

190

dest=u"approved_by_default",

193

191

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

194

192

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

195

193

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

206

204

options, client_names = parser.parse_args()

207

205

208

206

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

209

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

207

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

210

208

if options.verbose and has_actions(options):

211

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

212

" --all.")

209

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

210

' --all.')

213

211

if options.all and not has_actions(options):

214

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

212

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

215

213

216

214

try:

217

215

bus = dbus.SystemBus()

218

216

mandos_dbus_objc = bus.get_object(busname, server_path)

219

217

except dbus.exceptions.DBusException:

220

print("Could not connect to Mandos server",

221

file=sys.stderr)

218

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

222

219

sys.exit(1)

223

220

224

221

mandos_serv = dbus.Interface(mandos_dbus_objc,

237

234

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

238

235

os.close(stderrcopy)

239

236

except dbus.exceptions.DBusException, e:

240

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

241

file=sys.stderr)

237

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

242

238

sys.exit(1)

243

239

244

240

# Compile dict of (clients: properties) to process

251

247

else:

252

248

for name in client_names:

253

249

for path, client in mandos_clients.iteritems():

254

if client["Name"] == name:

250

if client['Name'] == name:

255

251

client_objc = bus.get_object(busname, path)

256

252

clients[client_objc] = client

257

253

break

258

254

else:

259

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

260

file=sys.stderr)

255

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

261

256

sys.exit(1)

262

257

263

258

if not has_actions(options) and clients:

264

259

if options.verbose:

265

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

266

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

267

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

268

"LastEnabled", "ApprovalPending",

269

"ApprovedByDefault",

270

"LastApprovalRequest", "ApprovalDelay",

271

"ApprovalDuration", "Checker")

260

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

261

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

262

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

263

'LastEnabled', 'ApprovalPending',

264

'ApprovedByDefault',

265

'LastApprovalRequest', 'ApprovalDelay',

266

'ApprovalDuration', 'Checker')

272

267

else:

273

268

keywords = defaultkeywords

274

269

290

285

client.StopChecker(dbus_interface=client_interface)

291

286

if options.is_enabled:

292

287

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

293

"Enabled",

288

u"Enabled",

294

289

dbus_interface=dbus.PROPERTIES_IFACE)

295

290

else 1)

296

291

if options.checker:

297

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

292

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

298

293

dbus_interface=dbus.PROPERTIES_IFACE)

299

294

if options.host:

300

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

295

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

301

296

dbus_interface=dbus.PROPERTIES_IFACE)

302

297

if options.interval:

303

client.Set(client_interface, "Interval",

298

client.Set(client_interface, u"Interval",

304

299

timedelta_to_milliseconds

305

300

(string_to_delta(options.interval)),

306

301

dbus_interface=dbus.PROPERTIES_IFACE)

307

302

if options.approval_delay:

308

client.Set(client_interface, "ApprovalDelay",

303

client.Set(client_interface, u"ApprovalDelay",

309

304

timedelta_to_milliseconds

310

305

(string_to_delta(options.

311

306

approval_delay)),

312

307

dbus_interface=dbus.PROPERTIES_IFACE)

313

308

if options.approval_duration:

314

client.Set(client_interface, "ApprovalDuration",

309

client.Set(client_interface, u"ApprovalDuration",

315

310

timedelta_to_milliseconds

316

311

(string_to_delta(options.

317

312

approval_duration)),

318

313

dbus_interface=dbus.PROPERTIES_IFACE)

319

314

if options.timeout:

320

client.Set(client_interface, "Timeout",

315

client.Set(client_interface, u"Timeout",

321

316

timedelta_to_milliseconds

322

317

(string_to_delta(options.timeout)),

323

318

dbus_interface=dbus.PROPERTIES_IFACE)

324

319

if options.secret:

325

client.Set(client_interface, "Secret",

320

client.Set(client_interface, u"Secret",

326

321

dbus.ByteArray(open(options.secret,

327

"rb").read()),

322

u'rb').read()),

328

323

dbus_interface=dbus.PROPERTIES_IFACE)

329

324

if options.approved_by_default is not None:

330

client.Set(client_interface, "ApprovedByDefault",

325

client.Set(client_interface, u"ApprovedByDefault",

331

326

dbus.Boolean(options

332

327

.approved_by_default),

333

328

dbus_interface=dbus.PROPERTIES_IFACE)

338

333

client.Approve(dbus.Boolean(False),

339

334

dbus_interface=client_interface)

340

335

341

if __name__ == "__main__":

336

if __name__ == '__main__':

342

337

main()