/mandos/release : revision 237.2.206

1

#!/usr/bin/python

2

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

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

11

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

12

# (at your option) any later version.

13

#

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

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17

# GNU General Public License for more details.

18

#

19

# 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

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

23

#

24

25

from __future__ import (division, absolute_import, print_function,

26

unicode_literals)

27

3

4

from __future__ import division

28

5

import sys

29

6

import dbus

30

7

from optparse import OptionParser

33

10

import re

34

11

import os

35

12

36

locale.setlocale(locale.LC_ALL, "")

13

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

37

14

38

15

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

16

'Name': u'Name',

17

'Enabled': u'Enabled',

18

'Timeout': u'Timeout',

19

'LastCheckedOK': u'Last Successful Check',

20

'LastApprovalRequest': u'Last Approval Request',

21

'Created': u'Created',

22

'Interval': u'Interval',

23

'Host': u'Host',

24

'Fingerprint': u'Fingerprint',

25

'CheckerRunning': u'Check Is Running',

26

'LastEnabled': u'Last Enabled',

27

'ApprovalPending': u'Approval Is Pending',

28

'ApprovedByDefault': u'Approved By Default',

29

'ApprovalDelay': u"Approval Delay",

30

'ApprovalDuration': u"Approval Duration",

31

'Checker': u'Checker',

55

32

}

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"

33

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

34

domain = 'se.bsnet.fukt'

35

busname = domain + '.Mandos'

36

server_path = '/'

37

server_interface = domain + '.Mandos'

38

client_interface = domain + '.Mandos.Client'

39

version = "1.0.14"

63

40

64

41

def timedelta_to_milliseconds(td):

65

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

42

"Convert a datetime.timedelta object to milliseconds"

66

43

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

67

44

+ (td.seconds * 1000)

68

45

+ (td.microseconds // 1000))

69

46

70

47

def milliseconds_to_string(ms):

71

48

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

72

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

49

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

73

50

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

74

51

"hours": td.seconds // 3600,

75

52

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

80

57

def string_to_delta(interval):

81

58

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

82

59

83

>>> string_to_delta("7d")

60

>>> string_to_delta('7d')

84

61

datetime.timedelta(7)

85

>>> string_to_delta("60s")

62

>>> string_to_delta('60s')

86

63

datetime.timedelta(0, 60)

87

>>> string_to_delta("60m")

64

>>> string_to_delta('60m')

88

65

datetime.timedelta(0, 3600)

89

>>> string_to_delta("24h")

66

>>> string_to_delta('24h')

90

67

datetime.timedelta(1)

91

>>> string_to_delta("1w")

68

>>> string_to_delta(u'1w')

92

69

datetime.timedelta(7)

93

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

70

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

94

71

datetime.timedelta(0, 330)

95

72

"""

96

73

timevalue = datetime.timedelta(0)

100

77

try:

101

78

suffix = unicode(s[-1])

102

79

value = int(s[:-1])

103

if suffix == "d":

80

if suffix == u"d":

104

81

delta = datetime.timedelta(value)

105

elif suffix == "s":

82

elif suffix == u"s":

106

83

delta = datetime.timedelta(0, value)

107

elif suffix == "m":

84

elif suffix == u"m":

108

85

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

109

elif suffix == "h":

86

elif suffix == u"h":

110

87

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

111

elif suffix == "w":

88

elif suffix == u"w":

112

89

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

113

90

else:

114

91

raise ValueError

120

97

def print_clients(clients, keywords):

121

98

def valuetostring(value, keyword):

122

99

if type(value) is dbus.Boolean:

123

return "Yes" if value else "No"

124

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

125

"ApprovalDuration"):

100

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

101

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

102

u"ApprovalDuration"):

126

103

return milliseconds_to_string(value)

127

104

return unicode(value)

128

105

129

106

# 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)

107

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

108

max(len(tablewords[key]),

109

max(len(valuetostring(client[key],

110

key))

111

for client in

112

clients))

113

for key in keywords)

137

114

# Print header line

138

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

115

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

139

116

for client in clients:

140

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

141

for key in keywords))

117

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

118

for key in keywords)

142

119

143

120

def has_actions(options):

144

121

return any((options.enable,

186

163

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

187

164

help="Set checker interval for client")

188

165

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

189

dest="approved_by_default",

166

dest=u"approved_by_default",

190

167

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

191

168

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

192

dest="approved_by_default",

169

dest=u"approved_by_default",

193

170

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

194

171

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

195

172

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

206

183

options, client_names = parser.parse_args()

207

184

208

185

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

209

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

186

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

210

187

if options.verbose and has_actions(options):

211

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

212

" --all.")

188

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

189

' --all.')

213

190

if options.all and not has_actions(options):

214

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

191

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

215

192

216

193

try:

217

194

bus = dbus.SystemBus()

218

195

mandos_dbus_objc = bus.get_object(busname, server_path)

219

196

except dbus.exceptions.DBusException:

220

print("Could not connect to Mandos server",

221

file=sys.stderr)

197

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

222

198

sys.exit(1)

223

199

224

200

mandos_serv = dbus.Interface(mandos_dbus_objc,

237

213

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

238

214

os.close(stderrcopy)

239

215

except dbus.exceptions.DBusException, e:

240

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

241

file=sys.stderr)

216

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

242

217

sys.exit(1)

243

218

244

219

# Compile dict of (clients: properties) to process

251

226

else:

252

227

for name in client_names:

253

228

for path, client in mandos_clients.iteritems():

254

if client["Name"] == name:

229

if client['Name'] == name:

255

230

client_objc = bus.get_object(busname, path)

256

231

clients[client_objc] = client

257

232

break

258

233

else:

259

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

260

file=sys.stderr)

234

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

261

235

sys.exit(1)

262

236

263

237

if not has_actions(options) and clients:

264

238

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

239

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

240

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

241

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

242

'LastEnabled', 'ApprovalPending',

243

'ApprovedByDefault',

244

'LastApprovalRequest', 'ApprovalDelay',

245

'ApprovalDuration', 'Checker')

272

246

else:

273

247

keywords = defaultkeywords

274

248

290

264

client.StopChecker(dbus_interface=client_interface)

291

265

if options.is_enabled:

292

266

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

293

"Enabled",

267

u"Enabled",

294

268

dbus_interface=dbus.PROPERTIES_IFACE)

295

269

else 1)

296

270

if options.checker:

297

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

271

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

298

272

dbus_interface=dbus.PROPERTIES_IFACE)

299

273

if options.host:

300

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

274

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

301

275

dbus_interface=dbus.PROPERTIES_IFACE)

302

276

if options.interval:

303

client.Set(client_interface, "Interval",

277

client.Set(client_interface, u"Interval",

304

278

timedelta_to_milliseconds

305

279

(string_to_delta(options.interval)),

306

280

dbus_interface=dbus.PROPERTIES_IFACE)

307

281

if options.approval_delay:

308

client.Set(client_interface, "ApprovalDelay",

282

client.Set(client_interface, u"ApprovalDelay",

309

283

timedelta_to_milliseconds

310

284

(string_to_delta(options.

311

285

approval_delay)),

312

286

dbus_interface=dbus.PROPERTIES_IFACE)

313

287

if options.approval_duration:

314

client.Set(client_interface, "ApprovalDuration",

288

client.Set(client_interface, u"ApprovalDuration",

315

289

timedelta_to_milliseconds

316

290

(string_to_delta(options.

317

291

approval_duration)),

318

292

dbus_interface=dbus.PROPERTIES_IFACE)

319

293

if options.timeout:

320

client.Set(client_interface, "Timeout",

294

client.Set(client_interface, u"Timeout",

321

295

timedelta_to_milliseconds

322

296

(string_to_delta(options.timeout)),

323

297

dbus_interface=dbus.PROPERTIES_IFACE)

324

298

if options.secret:

325

client.Set(client_interface, "Secret",

299

client.Set(client_interface, u"Secret",

326

300

dbus.ByteArray(open(options.secret,

327

"rb").read()),

301

u'rb').read()),

328

302

dbus_interface=dbus.PROPERTIES_IFACE)

329

303

if options.approved_by_default is not None:

330

client.Set(client_interface, "ApprovedByDefault",

304

client.Set(client_interface, u"ApprovedByDefault",

331

305

dbus.Boolean(options

332

306

.approved_by_default),

333

307

dbus_interface=dbus.PROPERTIES_IFACE)

338

312

client.Approve(dbus.Boolean(False),

339

313

dbus_interface=client_interface)

340

314

341

if __name__ == "__main__":

315

if __name__ == '__main__':

342

316

main()