/mandos/release : revision 237.7.133

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/>.

20

# along with this program. If not, see

21

# <http://www.gnu.org/licenses/>.

21

22

#

22

23

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

23

24

#

25

26

from __future__ import (division, absolute_import, print_function,

26

27

unicode_literals)

27

28

29

from future_builtins import *

30

28

31

import sys

29

32

import os

30

33

import signal

52

55

domain = 'se.recompile'

53

56

server_interface = domain + '.Mandos'

54

57

client_interface = domain + '.Mandos.Client'

55

version = "1.4.1"

58

version = "1.5.3"

56

59

57

60

# Always run in monochrome mode

58

61

urwid.curses_display.curses.has_colors = lambda : False

83

86

properties and calls a hook function when any of them are

84

87

changed.

85

88

"""

86

def __init__(self, proxy_object=None, *args, **kwargs):

89

def __init__(self, proxy_object=None, properties=None, **kwargs):

87

90

self.proxy = proxy_object # Mandos Client proxy object

88

89

self.properties = dict()

91

self.properties = dict() if properties is None else properties

90

92

self.property_changed_match = (

91

93

self.proxy.connect_to_signal("PropertyChanged",

92

self.property_changed,

94

self._property_changed,

93

95

client_interface,

94

96

byte_arrays=True))

95

97

96

self.properties.update(

97

self.proxy.GetAll(client_interface,

98

dbus_interface = dbus.PROPERTIES_IFACE))

99

100

#XXX This breaks good super behaviour

101

# super(MandosClientPropertyCache, self).__init__(

102

# *args, **kwargs)

98

if properties is None:

99

self.properties.update(

100

self.proxy.GetAll(client_interface,

101

dbus_interface

102

= dbus.PROPERTIES_IFACE))

103

104

super(MandosClientPropertyCache, self).__init__(**kwargs)

105

106

def _property_changed(self, property, value):

107

"""Helper which takes positional arguments"""

108

return self.property_changed(property=property, value=value)

103

109

104

110

def property_changed(self, property=None, value=None):

105

111

"""This is called whenever we get a PropertyChanged signal

108

114

# Update properties dict with new value

109

115

self.properties[property] = value

110

116

111

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

117

def delete(self):

112

118

self.property_changed_match.remove()

113

super(MandosClientPropertyCache, self).__init__(

114

*args, **kwargs)

115

119

116

120

117

121

class MandosClientWidget(urwid.FlowWidget, MandosClientPropertyCache):

119

123

"""

120

124

121

125

def __init__(self, server_proxy_object=None, update_hook=None,

122

delete_hook=None, logger=None, *args, **kwargs):

126

delete_hook=None, logger=None, **kwargs):

123

127

# Called on update

124

128

self.update_hook = update_hook

125

129

# Called on delete

130

134

self.logger = logger

131

135

132

136

self._update_timer_callback_tag = None

133

self._update_timer_callback_lock = 0

134

self.last_checker_failed = False

135

137

136

138

# The widget shown normally

137

139

self._text_widget = urwid.Text("")

138

140

# The widget shown when we have focus

139

141

self._focus_text_widget = urwid.Text("")

140

super(MandosClientWidget, self).__init__(

141

update_hook=update_hook, delete_hook=delete_hook,

142

*args, **kwargs)

142

super(MandosClientWidget, self).__init__(**kwargs)

143

self.update()

144

self.opened = False

145

146

last_checked_ok = isoformat_to_datetime(self.properties

147

["LastCheckedOK"])

148

if last_checked_ok is None:

149

self.last_checker_failed = True

150

else:

151

self.last_checker_failed = ((datetime.datetime.utcnow()

152

- last_checked_ok)

153

> datetime.timedelta

154

(milliseconds=

155

self.properties

156

["Interval"]))

157

158

if self.last_checker_failed:

159

self.using_timer(True)

160

161

if self.need_approval:

162

self.using_timer(True)

163

164

146

self.match_objects = (

165

147

self.proxy.connect_to_signal("CheckerCompleted",

166

148

self.checker_completed,

182

164

self.rejected,

183

165

client_interface,

184

166

byte_arrays=True))

185

#self.logger('Created client %s' % (self.properties["Name"]))

167

#self.logger('Created client {0}'

168

# .format(self.properties["Name"]))

186

169

187

def property_changed(self, property=None, value=None):

188

super(self, MandosClientWidget).property_changed(property,

189

value)

190

if property == "ApprovalPending":

191

using_timer(bool(value))

192

193

170

def using_timer(self, flag):

194

171

"""Call this method with True or False when timer should be

195

172

activated or deactivated.

196

173

"""

197

old = self._update_timer_callback_lock

198

if flag:

199

self._update_timer_callback_lock += 1

200

else:

201

self._update_timer_callback_lock -= 1

202

if old == 0 and self._update_timer_callback_lock:

174

if flag and self._update_timer_callback_tag is None:

203

175

# Will update the shown timer value every second

204

176

self._update_timer_callback_tag = (gobject.timeout_add

205

177

(1000,

206

178

self.update_timer))

207

elif old and self._update_timer_callback_lock == 0:

179

elif not (flag or self._update_timer_callback_tag is None):

208

180

gobject.source_remove(self._update_timer_callback_tag)

209

181

self._update_timer_callback_tag = None

210

182

211

183

def checker_completed(self, exitstatus, condition, command):

212

184

if exitstatus == 0:

213

if self.last_checker_failed:

214

self.last_checker_failed = False

215

self.using_timer(False)

216

#self.logger('Checker for client %s (command "%s")'

217

# ' was successful'

218

# % (self.properties["Name"], command))

219

185

self.update()

220

186

return

221

187

# Checker failed

222

if not self.last_checker_failed:

223

self.last_checker_failed = True

224

self.using_timer(True)

225

188

if os.WIFEXITED(condition):

226

self.logger('Checker for client %s (command "%s")'

227

' failed with exit code %s'

228

% (self.properties["Name"], command,

229

os.WEXITSTATUS(condition)))

189

self.logger('Checker for client {0} (command "{1}")'

190

' failed with exit code {2}'

191

.format(self.properties["Name"], command,

192

os.WEXITSTATUS(condition)))

230

193

elif os.WIFSIGNALED(condition):

231

self.logger('Checker for client %s (command "%s")'

232

' was killed by signal %s'

233

% (self.properties["Name"], command,

234

os.WTERMSIG(condition)))

194

self.logger('Checker for client {0} (command "{1}") was'

195

' killed by signal {2}'

196

.format(self.properties["Name"], command,

197

os.WTERMSIG(condition)))

235

198

elif os.WCOREDUMP(condition):

236

self.logger('Checker for client %s (command "%s")'

199

self.logger('Checker for client {0} (command "{1}")'

237

200

' dumped core'

238

% (self.properties["Name"], command))

201

.format(self.properties["Name"], command))

239

202

else:

240

self.logger('Checker for client %s completed'

241

' mysteriously')

203

self.logger('Checker for client {0} completed'

204

' mysteriously'

205

.format(self.properties["Name"]))

242

206

self.update()

243

207

244

208

def checker_started(self, command):

245

209

"""Server signals that a checker started. This could be useful

246

210

to log in the future. """

247

#self.logger('Client %s started checker "%s"'

248

# % (self.properties["Name"], unicode(command)))

211

#self.logger('Client {0} started checker "{1}"'

212

# .format(self.properties["Name"],

213

# unicode(command)))

249

214

pass

250

215

251

216

def got_secret(self):

252

self.last_checker_failed = False

253

self.logger('Client %s received its secret'

254

% self.properties["Name"])

217

self.logger('Client {0} received its secret'

218

.format(self.properties["Name"]))

255

219

256

220

def need_approval(self, timeout, default):

257

221

if not default:

258

message = 'Client %s needs approval within %s seconds'

222

message = 'Client {0} needs approval within {1} seconds'

259

223

else:

260

message = 'Client %s will get its secret in %s seconds'

261

self.logger(message

262

% (self.properties["Name"], timeout/1000))

263

self.using_timer(True)

224

message = 'Client {0} will get its secret in {1} seconds'

225

self.logger(message.format(self.properties["Name"],

226

timeout/1000))

264

227

265

228

def rejected(self, reason):

266

self.logger('Client %s was rejected; reason: %s'

267

% (self.properties["Name"], reason))

229

self.logger('Client {0} was rejected; reason: {1}'

230

.format(self.properties["Name"], reason))

268

231

269

232

def selectable(self):

270

233

"""Make this a "selectable" widget.

292

255

"bold-underline-blink":

293

256

"bold-underline-blink-standout",

294

257

}

295

258

296

259

# Rebuild focus and non-focus widgets using current properties

297

260

298

261

# Base part of a client. Name!

299

base = ('%(name)s: '

300

% {"name": self.properties["Name"]})

262

base = '{name}: '.format(name=self.properties["Name"])

301

263

if not self.properties["Enabled"]:

302

264

message = "DISABLED"

265

self.using_timer(False)

303

266

elif self.properties["ApprovalPending"]:

304

267

timeout = datetime.timedelta(milliseconds

305

268

= self.properties

307

270

last_approval_request = isoformat_to_datetime(

308

271

self.properties["LastApprovalRequest"])

309

272

if last_approval_request is not None:

310

timer = timeout - (datetime.datetime.utcnow()

311

- last_approval_request)

273

timer = max(timeout - (datetime.datetime.utcnow()

274

- last_approval_request),

275

datetime.timedelta())

312

276

else:

313

277

timer = datetime.timedelta()

314

278

if self.properties["ApprovedByDefault"]:

315

message = "Approval in %s. (d)eny?"

279

message = "Approval in {0}. (d)eny?"

316

280

else:

317

message = "Denial in %s. (a)pprove?"

318

message = message % unicode(timer).rsplit(".", 1)[0]

319

elif self.last_checker_failed:

320

# When checker has failed, print a timer until client expires

281

message = "Denial in {0}. (a)pprove?"

282

message = message.format(unicode(timer).rsplit(".", 1)[0])

283

self.using_timer(True)

284

elif self.properties["LastCheckerStatus"] != 0:

285

# When checker has failed, show timer until client expires

321

286

expires = self.properties["Expires"]

322

287

if expires == "":

323

288

timer = datetime.timedelta(0)

324

289

else:

325

expires = datetime.datetime.strptime(expires,

326

'%Y-%m-%dT%H:%M:%S.%f')

327

timer = expires - datetime.datetime.utcnow()

290

expires = (datetime.datetime.strptime

291

(expires, '%Y-%m-%dT%H:%M:%S.%f'))

292

timer = max(expires - datetime.datetime.utcnow(),

293

datetime.timedelta())

328

294

message = ('A checker has failed! Time until client'

329

' gets disabled: %s'

330

% unicode(timer).rsplit(".", 1)[0])

295

' gets disabled: {0}'

296

.format(unicode(timer).rsplit(".", 1)[0]))

297

self.using_timer(True)

331

298

else:

332

299

message = "enabled"

333

self._text = "%s%s" % (base, message)

334

300

self.using_timer(False)

301

self._text = "{0}{1}".format(base, message)

302

335

303

if not urwid.supports_unicode():

336

304

self._text = self._text.encode("ascii", "replace")

337

305

textlist = [("normal", self._text)]

354

322

self.update()

355

323

return True # Keep calling this

356

324

357

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

325

def delete(self, **kwargs):

358

326

if self._update_timer_callback_tag is not None:

359

327

gobject.source_remove(self._update_timer_callback_tag)

360

328

self._update_timer_callback_tag = None

363

331

self.match_objects = ()

364

332

if self.delete_hook is not None:

365

333

self.delete_hook(self)

366

return super(MandosClientWidget, self).delete(*args, **kwargs)

334

return super(MandosClientWidget, self).delete(**kwargs)

367

335

368

336

def render(self, maxcolrow, focus=False):

369

337

"""Render differently if we have focus.

411

379

else:

412

380

return key

413

381

414

def property_changed(self, property=None, value=None,

415

*args, **kwargs):

382

def property_changed(self, property=None, **kwargs):

416

383

"""Call self.update() if old value is not new value.

417

384

This overrides the method from MandosClientPropertyCache"""

418

385

property_name = unicode(property)

419

386

old_value = self.properties.get(property_name)

420

387

super(MandosClientWidget, self).property_changed(

421

property=property, value=value, *args, **kwargs)

388

property=property, **kwargs)

422

389

if self.properties.get(property_name) != old_value:

423

390

self.update()

424

391

428

395

"down" key presses, thus not allowing any containing widgets to

429

396

use them as an excuse to shift focus away from this widget.

430

397

"""

431

def keypress(self, maxcolrow, key):

432

ret = super(ConstrainedListBox, self).keypress(maxcolrow, key)

398

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

399

ret = super(ConstrainedListBox, self).keypress(*args, **kwargs)

433

400

if ret in ("up", "down"):

434

401

return

435

402

return ret

501

468

self.main_loop = gobject.MainLoop()

502

469

503

470

def client_not_found(self, fingerprint, address):

504

self.log_message(("Client with address %s and fingerprint %s"

505

" could not be found" % (address,

506

fingerprint)))

471

self.log_message("Client with address {0} and fingerprint"

472

" {1} could not be found"

473

.format(address, fingerprint))

507

474

508

475

def rebuild(self):

509

476

"""This rebuilds the User Interface.

562

529

client = self.clients_dict[path]

563

530

except KeyError:

564

531

# not found?

565

self.log_message("Unknown client %r (%r) removed", name,

566

path)

532

self.log_message("Unknown client {0!r} ({1!r}) removed"

533

.format(name, path))

567

534

return

568

535

client.delete()

569

536

650

617

logger

651

618

=self.log_message),

652

619

path=path)

653

620

654

621

self.refresh()

655

622

self._input_callback_tag = (gobject.io_add_watch

656

623

(sys.stdin.fileno(),