/mandos/release : revision 237.7.671

1

#!/usr/bin/python

2

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

3

#

3

#

4

# Mandos server - give out binary blobs to connecting clients.

5

#

5

#

6

# This program is partly derived from an example program for an Avahi

7

# service publisher, downloaded from

8

# <http://avahi.org/wiki/PythonPublishExample>. This includes the

9

# methods "add", "remove", "server_state_changed",

10

# "entry_group_state_changed", "cleanup", and "activate" in the

11

# "AvahiService" class, and some lines in "main".

12

#

12

#

13

# Everything else is

14

15

16

#

17

# This program is free software: you can redistribute it and/or modify

18

# it under the terms of the GNU General Public License as published by

14

15

16

#

17

# This file is part of Mandos.

18

#

19

# Mandos is free software: you can redistribute it and/or modify it

20

# under the terms of the GNU General Public License as published by

19

21

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

20

22

# (at your option) any later version.

21

23

#

22

# This program is distributed in the hope that it will be useful,

23

# but WITHOUT ANY WARRANTY; without even the implied warranty of

24

# Mandos is distributed in the hope that it will be useful, but

25

# WITHOUT ANY WARRANTY; without even the implied warranty of

24

26

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

25

27

# GNU General Public License for more details.

26

#

28

#

27

29

# You should have received a copy of the GNU General Public License

28

# along with this program. If not, see

29

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

30

#

30

# along with Mandos. If not, see <http://www.gnu.org/licenses/>.

31

#

31

32

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

32

#

33

#

33

34

35

from __future__ import (division, absolute_import, print_function,

35

36

unicode_literals)

36

37

from future_builtins import *

38

try:

39

from future_builtins import *

40

except ImportError:

41

pass

38

42

39

import SocketServer as socketserver

43

try:

44

import SocketServer as socketserver

45

except ImportError:

46

import socketserver

40

47

import socket

41

48

import argparse

42

49

import datetime

43

50

import errno

44

import gnutls.crypto

45

import gnutls.connection

46

import gnutls.errors

47

import gnutls.library.functions

48

import gnutls.library.constants

49

import gnutls.library.types

50

import ConfigParser as configparser

51

try:

52

import ConfigParser as configparser

53

except ImportError:

54

import configparser

51

55

import sys

52

56

import re

53

57

import os

62

66

import struct

63

67

import fcntl

64

68

import functools

65

import cPickle as pickle

69

try:

70

import cPickle as pickle

71

except ImportError:

72

import pickle

66

73

import multiprocessing

67

74

import types

68

75

import binascii

69

76

import tempfile

70

77

import itertools

78

import collections

79

import codecs

71

80

72

81

import dbus

73

82

import dbus.service

74

import gobject

75

import avahi

83

from gi.repository import GLib

76

84

from dbus.mainloop.glib import DBusGMainLoop

77

85

import ctypes

78

86

import ctypes.util

79

87

import xml.dom.minidom

80

88

import inspect

81

import GnuPGInterface

82

89

90

# Try to find the value of SO_BINDTODEVICE:

83

91

try:

92

# This is where SO_BINDTODEVICE is in Python 3.3 (or 3.4?) and

93

# newer, and it is also the most natural place for it:

84

94

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

85

95

except AttributeError:

86

96

try:

97

# This is where SO_BINDTODEVICE was up to and including Python

98

# 2.6, and also 3.2:

87

99

from IN import SO_BINDTODEVICE

88

100

except ImportError:

89

SO_BINDTODEVICE = None

90

91

version = "1.6.0"

101

# In Python 2.7 it seems to have been removed entirely.

102

# Try running the C preprocessor:

103

try:

104

cc = subprocess.Popen(["cc", "--language=c", "-E",

105

"/dev/stdin"],

106

stdin=subprocess.PIPE,

107

stdout=subprocess.PIPE)

108

stdout = cc.communicate(

109

"#include <sys/socket.h>\nSO_BINDTODEVICE\n")[0]

110

SO_BINDTODEVICE = int(stdout.splitlines()[-1])

111

except (OSError, ValueError, IndexError):

112

# No value found

113

SO_BINDTODEVICE = None

114

115

if sys.version_info.major == 2:

116

str = unicode

117

118

version = "1.8.4"

92

119

stored_state_file = "clients.pickle"

93

120

94

121

logger = logging.getLogger()

95

syslogger = (logging.handlers.SysLogHandler

96

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

97

address = str("/dev/log")))

122

syslogger = None

98

123

99

124

try:

100

if_nametoindex = (ctypes.cdll.LoadLibrary

101

(ctypes.util.find_library("c"))

102

.if_nametoindex)

125

if_nametoindex = ctypes.cdll.LoadLibrary(

126

ctypes.util.find_library("c")).if_nametoindex

103

127

except (OSError, AttributeError):

128

104

129

def if_nametoindex(interface):

105

130

"Get an interface index the hard way, i.e. using fcntl()"

106

131

SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h

107

132

with contextlib.closing(socket.socket()) as s:

108

133

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

109

struct.pack(str("16s16x"),

110

interface))

111

interface_index = struct.unpack(str("I"),

112

ifreq[16:20])[0]

134

struct.pack(b"16s16x", interface))

135

interface_index = struct.unpack("I", ifreq[16:20])[0]

113

136

return interface_index

114

137

115

138

139

def copy_function(func):

140

"""Make a copy of a function"""

141

if sys.version_info.major == 2:

142

return types.FunctionType(func.func_code,

143

func.func_globals,

144

func.func_name,

145

func.func_defaults,

146

func.func_closure)

147

else:

148

return types.FunctionType(func.__code__,

149

func.__globals__,

150

func.__name__,

151

func.__defaults__,

152

func.__closure__)

153

154

116

155

def initlogger(debug, level=logging.WARNING):

117

156

"""init logger and add loglevel"""

118

157

158

global syslogger

159

syslogger = (logging.handlers.SysLogHandler(

160

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

161

address="/dev/log"))

119

162

syslogger.setFormatter(logging.Formatter

120

163

('Mandos [%(process)d]: %(levelname)s:'

121

164

' %(message)s'))

122

165

logger.addHandler(syslogger)

123

166

124

167

if debug:

125

168

console = logging.StreamHandler()

126

169

console.setFormatter(logging.Formatter('%(asctime)s %(name)s'

138

181

139

182

class PGPEngine(object):

140

183

"""A simple class for OpenPGP symmetric encryption & decryption"""

184

141

185

def __init__(self):

142

self.gnupg = GnuPGInterface.GnuPG()

143

186

self.tempdir = tempfile.mkdtemp(prefix="mandos-")

144

self.gnupg = GnuPGInterface.GnuPG()

145

self.gnupg.options.meta_interactive = False

146

self.gnupg.options.homedir = self.tempdir

147

self.gnupg.options.extra_args.extend(['--force-mdc',

148

'--quiet',

149

'--no-use-agent'])

150

187

self.gpg = "gpg"

188

try:

189

output = subprocess.check_output(["gpgconf"])

190

for line in output.splitlines():

191

name, text, path = line.split(b":")

192

if name == "gpg":

193

self.gpg = path

194

break

195

except OSError as e:

196

if e.errno != errno.ENOENT:

197

raise

198

self.gnupgargs = ['--batch',

199

'--homedir', self.tempdir,

200

'--force-mdc',

201

'--quiet']

202

# Only GPG version 1 has the --no-use-agent option.

203

if self.gpg == "gpg" or self.gpg.endswith("/gpg"):

204

self.gnupgargs.append("--no-use-agent")

205

151

206

def __enter__(self):

152

207

return self

153

208

154

209

def __exit__(self, exc_type, exc_value, traceback):

155

210

self._cleanup()

156

211

return False

157

212

158

213

def __del__(self):

159

214

self._cleanup()

160

215

161

216

def _cleanup(self):

162

217

if self.tempdir is not None:

163

218

# Delete contents of tempdir

164

219

for root, dirs, files in os.walk(self.tempdir,

165

topdown = False):

220

topdown=False):

166

221

for filename in files:

167

222

os.remove(os.path.join(root, filename))

168

223

for dirname in dirs:

170

225

# Remove tempdir

171

226

os.rmdir(self.tempdir)

172

227

self.tempdir = None

173

228

174

229

def password_encode(self, password):

175

230

# Passphrase can not be empty and can not contain newlines or

176

231

# NUL bytes. So we prefix it and hex encode it.

177

return b"mandos" + binascii.hexlify(password)

178

232

encoded = b"mandos" + binascii.hexlify(password)

233

if len(encoded) > 2048:

234

# GnuPG can't handle long passwords, so encode differently

235

encoded = (b"mandos" + password.replace(b"\\", b"\\\\")

236

.replace(b"\n", b"\\n")

237

.replace(b"\0", b"\\x00"))

238

return encoded

239

179

240

def encrypt(self, data, password):

180

self.gnupg.passphrase = self.password_encode(password)

181

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

182

try:

183

proc = self.gnupg.run(['--symmetric'],

184

create_fhs=['stdin', 'stdout'],

185

attach_fhs={'stderr': devnull})

186

with contextlib.closing(proc.handles['stdin']) as f:

187

f.write(data)

188

with contextlib.closing(proc.handles['stdout']) as f:

189

ciphertext = f.read()

190

proc.wait()

191

except IOError as e:

192

raise PGPError(e)

193

self.gnupg.passphrase = None

241

passphrase = self.password_encode(password)

242

with tempfile.NamedTemporaryFile(

243

dir=self.tempdir) as passfile:

244

passfile.write(passphrase)

245

passfile.flush()

246

proc = subprocess.Popen([self.gpg, '--symmetric',

247

'--passphrase-file',

248

passfile.name]

249

+ self.gnupgargs,

250

stdin=subprocess.PIPE,

251

stdout=subprocess.PIPE,

252

stderr=subprocess.PIPE)

253

ciphertext, err = proc.communicate(input=data)

254

if proc.returncode != 0:

255

raise PGPError(err)

194

256

return ciphertext

195

257

196

258

def decrypt(self, data, password):

197

self.gnupg.passphrase = self.password_encode(password)

198

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

199

try:

200

proc = self.gnupg.run(['--decrypt'],

201

create_fhs=['stdin', 'stdout'],

202

attach_fhs={'stderr': devnull})

203

with contextlib.closing(proc.handles['stdin']) as f:

204

f.write(data)

205

with contextlib.closing(proc.handles['stdout']) as f:

206

decrypted_plaintext = f.read()

207

proc.wait()

208

except IOError as e:

209

raise PGPError(e)

210

self.gnupg.passphrase = None

259

passphrase = self.password_encode(password)

260

with tempfile.NamedTemporaryFile(

261

dir=self.tempdir) as passfile:

262

passfile.write(passphrase)

263

passfile.flush()

264

proc = subprocess.Popen([self.gpg, '--decrypt',

265

'--passphrase-file',

266

passfile.name]

267

+ self.gnupgargs,

268

stdin=subprocess.PIPE,

269

stdout=subprocess.PIPE,

270

stderr=subprocess.PIPE)

271

decrypted_plaintext, err = proc.communicate(input=data)

272

if proc.returncode != 0:

273

raise PGPError(err)

211

274

return decrypted_plaintext

212

275

213

276

277

# Pretend that we have an Avahi module

278

class avahi(object):

279

"""This isn't so much a class as it is a module-like namespace."""

280

IF_UNSPEC = -1 # avahi-common/address.h

281

PROTO_UNSPEC = -1 # avahi-common/address.h

282

PROTO_INET = 0 # avahi-common/address.h

283

PROTO_INET6 = 1 # avahi-common/address.h

284

DBUS_NAME = "org.freedesktop.Avahi"

285

DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"

286

DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"

287

DBUS_PATH_SERVER = "/"

288

289

@staticmethod

290

def string_array_to_txt_array(t):

291

return dbus.Array((dbus.ByteArray(s.encode("utf-8"))

292

for s in t), signature="ay")

293

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

294

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

295

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

296

SERVER_INVALID = 0 # avahi-common/defs.h

297

SERVER_REGISTERING = 1 # avahi-common/defs.h

298

SERVER_RUNNING = 2 # avahi-common/defs.h

299

SERVER_COLLISION = 3 # avahi-common/defs.h

300

SERVER_FAILURE = 4 # avahi-common/defs.h

301

302

214

303

class AvahiError(Exception):

215

304

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

216

305

self.value = value

217

super(AvahiError, self).__init__(value, *args, **kwargs)

218

def __unicode__(self):

219

return unicode(repr(self.value))

306

return super(AvahiError, self).__init__(value, *args,

307

**kwargs)

308

220

309

221

310

class AvahiServiceError(AvahiError):

222

311

pass

223

312

313

224

314

class AvahiGroupError(AvahiError):

225

315

pass

226

316

227

317

228

318

class AvahiService(object):

229

319

"""An Avahi (Zeroconf) service.

230

320

231

321

Attributes:

232

322

interface: integer; avahi.IF_UNSPEC or an interface index.

233

323

Used to optionally bind to the specified interface.

234

324

name: string; Example: 'Mandos'

235

325

type: string; Example: '_mandos._tcp'.

236

See <http://www.dns-sd.org/ServiceTypes.html>

326

See <https://www.iana.org/assignments/service-names-port-numbers>

237

327

port: integer; what port to announce

238

328

TXT: list of strings; TXT record for the service

239

329

domain: string; Domain to publish on, default to .local if empty.

245

335

server: D-Bus Server

246

336

bus: dbus.SystemBus()

247

337

"""

248

249

def __init__(self, interface = avahi.IF_UNSPEC, name = None,

250

servicetype = None, port = None, TXT = None,

251

domain = "", host = "", max_renames = 32768,

252

protocol = avahi.PROTO_UNSPEC, bus = None):

338

339

def __init__(self,

340

interface=avahi.IF_UNSPEC,

341

name=None,

342

servicetype=None,

343

port=None,

344

TXT=None,

345

domain="",

346

host="",

347

max_renames=32768,

348

protocol=avahi.PROTO_UNSPEC,

349

bus=None):

253

350

self.interface = interface

254

351

self.name = name

255

352

self.type = servicetype

264

361

self.server = None

265

362

self.bus = bus

266

363

self.entry_group_state_changed_match = None

267

268

def rename(self):

364

365

def rename(self, remove=True):

269

366

"""Derived from the Avahi example code"""

270

367

if self.rename_count >= self.max_renames:

271

368

logger.critical("No suitable Zeroconf service name found"

272

369

" after %i retries, exiting.",

273

370

self.rename_count)

274

371

raise AvahiServiceError("Too many renames")

275

self.name = unicode(self.server

276

.GetAlternativeServiceName(self.name))

372

self.name = str(

373

self.server.GetAlternativeServiceName(self.name))

374

self.rename_count += 1

277

375

logger.info("Changing Zeroconf service name to %r ...",

278

376

self.name)

279

self.remove()

377

if remove:

378

self.remove()

280

379

try:

281

380

self.add()

282

381

except dbus.exceptions.DBusException as error:

283

logger.critical("D-Bus Exception", exc_info=error)

284

self.cleanup()

285

os._exit(1)

286

self.rename_count += 1

287

382

if (error.get_dbus_name()

383

== "org.freedesktop.Avahi.CollisionError"):

384

logger.info("Local Zeroconf service name collision.")

385

return self.rename(remove=False)

386

else:

387

logger.critical("D-Bus Exception", exc_info=error)

388

self.cleanup()

389

os._exit(1)

390

288

391

def remove(self):

289

392

"""Derived from the Avahi example code"""

290

393

if self.entry_group_state_changed_match is not None:

292

395

self.entry_group_state_changed_match = None

293

396

if self.group is not None:

294

397

self.group.Reset()

295

398

296

399

def add(self):

297

400

"""Derived from the Avahi example code"""

298

401

self.remove()

315

418

dbus.UInt16(self.port),

316

419

avahi.string_array_to_txt_array(self.TXT))

317

420

self.group.Commit()

318

421

319

422

def entry_group_state_changed(self, state, error):

320

423

"""Derived from the Avahi example code"""

321

424

logger.debug("Avahi entry group state change: %i", state)

322

425

323

426

if state == avahi.ENTRY_GROUP_ESTABLISHED:

324

427

logger.debug("Zeroconf service established.")

325

428

elif state == avahi.ENTRY_GROUP_COLLISION:

327

430

self.rename()

328

431

elif state == avahi.ENTRY_GROUP_FAILURE:

329

432

logger.critical("Avahi: Error in group state changed %s",

330

unicode(error))

331

raise AvahiGroupError("State changed: {0!s}"

332

.format(error))

333

433

str(error))

434

raise AvahiGroupError("State changed: {!s}".format(error))

435

334

436

def cleanup(self):

335

437

"""Derived from the Avahi example code"""

336

438

if self.group is not None:

341

443

pass

342

444

self.group = None

343

445

self.remove()

344

446

345

447

def server_state_changed(self, state, error=None):

346

448

"""Derived from the Avahi example code"""

347

449

logger.debug("Avahi server state change: %i", state)

348

bad_states = { avahi.SERVER_INVALID:

349

"Zeroconf server invalid",

350

avahi.SERVER_REGISTERING: None,

351

avahi.SERVER_COLLISION:

352

"Zeroconf server name collision",

353

avahi.SERVER_FAILURE:

354

"Zeroconf server failure" }

450

bad_states = {

451

avahi.SERVER_INVALID: "Zeroconf server invalid",

452

avahi.SERVER_REGISTERING: None,

453

avahi.SERVER_COLLISION: "Zeroconf server name collision",

454

avahi.SERVER_FAILURE: "Zeroconf server failure",

455

}

355

456

if state in bad_states:

356

457

if bad_states[state] is not None:

357

458

if error is None:

360

461

logger.error(bad_states[state] + ": %r", error)

361

462

self.cleanup()

362

463

elif state == avahi.SERVER_RUNNING:

363

self.add()

464

try:

465

self.add()

466

except dbus.exceptions.DBusException as error:

467

if (error.get_dbus_name()

468

== "org.freedesktop.Avahi.CollisionError"):

469

logger.info("Local Zeroconf service name"

470

" collision.")

471

return self.rename(remove=False)

472

else:

473

logger.critical("D-Bus Exception", exc_info=error)

474

self.cleanup()

475

os._exit(1)

364

476

else:

365

477

if error is None:

366

478

logger.debug("Unknown state: %r", state)

367

479

else:

368

480

logger.debug("Unknown state: %r: %r", state, error)

369

481

370

482

def activate(self):

371

483

"""Derived from the Avahi example code"""

372

484

if self.server is None:

376

488

follow_name_owner_changes=True),

377

489

avahi.DBUS_INTERFACE_SERVER)

378

490

self.server.connect_to_signal("StateChanged",

379

self.server_state_changed)

491

self.server_state_changed)

380

492

self.server_state_changed(self.server.GetState())

381

493

382

494

383

495

class AvahiServiceToSyslog(AvahiService):

384

def rename(self):

496

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

385

497

"""Add the new name to the syslog messages"""

386

ret = AvahiService.rename(self)

387

syslogger.setFormatter(logging.Formatter

388

('Mandos ({0}) [%(process)d]:'

389

' %(levelname)s: %(message)s'

390

.format(self.name)))

498

ret = super(AvahiServiceToSyslog, self).rename(*args, **kwargs)

499

syslogger.setFormatter(logging.Formatter(

500

'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'

501

.format(self.name)))

391

502

return ret

392

503

393

504

394

def timedelta_to_milliseconds(td):

395

"Convert a datetime.timedelta() to milliseconds"

396

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

397

+ (td.seconds * 1000)

398

+ (td.microseconds // 1000))

505

# Pretend that we have a GnuTLS module

506

class gnutls(object):

507

"""This isn't so much a class as it is a module-like namespace."""

508

509

library = ctypes.util.find_library("gnutls")

510

if library is None:

511

library = ctypes.util.find_library("gnutls-deb0")

512

_library = ctypes.cdll.LoadLibrary(library)

513

del library

514

515

# Unless otherwise indicated, the constants and types below are

516

# all from the gnutls/gnutls.h C header file.

517

518

# Constants

519

E_SUCCESS = 0

520

E_INTERRUPTED = -52

521

E_AGAIN = -28

522

CRT_OPENPGP = 2

523

CRT_RAWPK = 3

524

CLIENT = 2

525

SHUT_RDWR = 0

526

CRD_CERTIFICATE = 1

527

E_NO_CERTIFICATE_FOUND = -49

528

X509_FMT_DER = 0

529

NO_TICKETS = 1<<10

530

ENABLE_RAWPK = 1<<18

531

CTYPE_PEERS = 3

532

KEYID_USE_SHA256 = 1 # gnutls/x509.h

533

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

534

535

# Types

536

class session_int(ctypes.Structure):

537

_fields_ = []

538

session_t = ctypes.POINTER(session_int)

539

540

class certificate_credentials_st(ctypes.Structure):

541

_fields_ = []

542

certificate_credentials_t = ctypes.POINTER(

543

certificate_credentials_st)

544

certificate_type_t = ctypes.c_int

545

546

class datum_t(ctypes.Structure):

547

_fields_ = [('data', ctypes.POINTER(ctypes.c_ubyte)),

548

('size', ctypes.c_uint)]

549

550

class openpgp_crt_int(ctypes.Structure):

551

_fields_ = []

552

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

553

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

554

log_func = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)

555

credentials_type_t = ctypes.c_int

556

transport_ptr_t = ctypes.c_void_p

557

close_request_t = ctypes.c_int

558

559

# Exceptions

560

class Error(Exception):

561

def __init__(self, message=None, code=None, args=()):

562

# Default usage is by a message string, but if a return

563

# code is passed, convert it to a string with

564

# gnutls.strerror()

565

self.code = code

566

if message is None and code is not None:

567

message = gnutls.strerror(code)

568

return super(gnutls.Error, self).__init__(

569

message, *args)

570

571

class CertificateSecurityError(Error):

572

pass

573

574

# Classes

575

class Credentials(object):

576

def __init__(self):

577

self._c_object = gnutls.certificate_credentials_t()

578

gnutls.certificate_allocate_credentials(

579

ctypes.byref(self._c_object))

580

self.type = gnutls.CRD_CERTIFICATE

581

582

def __del__(self):

583

gnutls.certificate_free_credentials(self._c_object)

584

585

class ClientSession(object):

586

def __init__(self, socket, credentials=None):

587

self._c_object = gnutls.session_t()

588

gnutls_flags = gnutls.CLIENT

589

if gnutls.check_version("3.5.6"):

590

gnutls_flags |= gnutls.NO_TICKETS

591

if gnutls.has_rawpk:

592

gnutls_flags |= gnutls.ENABLE_RAWPK

593

gnutls.init(ctypes.byref(self._c_object), gnutls_flags)

594

del gnutls_flags

595

gnutls.set_default_priority(self._c_object)

596

gnutls.transport_set_ptr(self._c_object, socket.fileno())

597

gnutls.handshake_set_private_extensions(self._c_object,

598

True)

599

self.socket = socket

600

if credentials is None:

601

credentials = gnutls.Credentials()

602

gnutls.credentials_set(self._c_object, credentials.type,

603

ctypes.cast(credentials._c_object,

604

ctypes.c_void_p))

605

self.credentials = credentials

606

607

def __del__(self):

608

gnutls.deinit(self._c_object)

609

610

def handshake(self):

611

return gnutls.handshake(self._c_object)

612

613

def send(self, data):

614

data = bytes(data)

615

data_len = len(data)

616

while data_len > 0:

617

data_len -= gnutls.record_send(self._c_object,

618

data[-data_len:],

619

data_len)

620

621

def bye(self):

622

return gnutls.bye(self._c_object, gnutls.SHUT_RDWR)

623

624

# Error handling functions

625

def _error_code(result):

626

"""A function to raise exceptions on errors, suitable

627

for the 'restype' attribute on ctypes functions"""

628

if result >= 0:

629

return result

630

if result == gnutls.E_NO_CERTIFICATE_FOUND:

631

raise gnutls.CertificateSecurityError(code=result)

632

raise gnutls.Error(code=result)

633

634

def _retry_on_error(result, func, arguments):

635

"""A function to retry on some errors, suitable

636

for the 'errcheck' attribute on ctypes functions"""

637

while result < 0:

638

if result not in (gnutls.E_INTERRUPTED, gnutls.E_AGAIN):

639

return _error_code(result)

640

result = func(*arguments)

641

return result

642

643

# Unless otherwise indicated, the function declarations below are

644

# all from the gnutls/gnutls.h C header file.

645

646

# Functions

647

priority_set_direct = _library.gnutls_priority_set_direct

648

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

649

ctypes.POINTER(ctypes.c_char_p)]

650

priority_set_direct.restype = _error_code

651

652

init = _library.gnutls_init

653

init.argtypes = [ctypes.POINTER(session_t), ctypes.c_int]

654

init.restype = _error_code

655

656

set_default_priority = _library.gnutls_set_default_priority

657

set_default_priority.argtypes = [session_t]

658

set_default_priority.restype = _error_code

659

660

record_send = _library.gnutls_record_send

661

record_send.argtypes = [session_t, ctypes.c_void_p,

662

ctypes.c_size_t]

663

record_send.restype = ctypes.c_ssize_t

664

record_send.errcheck = _retry_on_error

665

666

certificate_allocate_credentials = (

667

_library.gnutls_certificate_allocate_credentials)

668

certificate_allocate_credentials.argtypes = [

669

ctypes.POINTER(certificate_credentials_t)]

670

certificate_allocate_credentials.restype = _error_code

671

672

certificate_free_credentials = (

673

_library.gnutls_certificate_free_credentials)

674

certificate_free_credentials.argtypes = [

675

certificate_credentials_t]

676

certificate_free_credentials.restype = None

677

678

handshake_set_private_extensions = (

679

_library.gnutls_handshake_set_private_extensions)

680

handshake_set_private_extensions.argtypes = [session_t,

681

ctypes.c_int]

682

handshake_set_private_extensions.restype = None

683

684

credentials_set = _library.gnutls_credentials_set

685

credentials_set.argtypes = [session_t, credentials_type_t,

686

ctypes.c_void_p]

687

credentials_set.restype = _error_code

688

689

strerror = _library.gnutls_strerror

690

strerror.argtypes = [ctypes.c_int]

691

strerror.restype = ctypes.c_char_p

692

693

certificate_type_get = _library.gnutls_certificate_type_get

694

certificate_type_get.argtypes = [session_t]

695

certificate_type_get.restype = _error_code

696

697

certificate_get_peers = _library.gnutls_certificate_get_peers

698

certificate_get_peers.argtypes = [session_t,

699

ctypes.POINTER(ctypes.c_uint)]

700

certificate_get_peers.restype = ctypes.POINTER(datum_t)

701

702

global_set_log_level = _library.gnutls_global_set_log_level

703

global_set_log_level.argtypes = [ctypes.c_int]

704

global_set_log_level.restype = None

705

706

global_set_log_function = _library.gnutls_global_set_log_function

707

global_set_log_function.argtypes = [log_func]

708

global_set_log_function.restype = None

709

710

deinit = _library.gnutls_deinit

711

deinit.argtypes = [session_t]

712

deinit.restype = None

713

714

handshake = _library.gnutls_handshake

715

handshake.argtypes = [session_t]

716

handshake.restype = _error_code

717

handshake.errcheck = _retry_on_error

718

719

transport_set_ptr = _library.gnutls_transport_set_ptr

720

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

721

transport_set_ptr.restype = None

722

723

bye = _library.gnutls_bye

724

bye.argtypes = [session_t, close_request_t]

725

bye.restype = _error_code

726

bye.errcheck = _retry_on_error

727

728

check_version = _library.gnutls_check_version

729

check_version.argtypes = [ctypes.c_char_p]

730

check_version.restype = ctypes.c_char_p

731

732

_need_version = b"3.3.0"

733

if check_version(_need_version) is None:

734

raise self.Error("Needs GnuTLS {} or later"

735

.format(_need_version))

736

737

_tls_rawpk_version = b"3.6.6"

738

has_rawpk = bool(check_version(_tls_rawpk_version))

739

740

if has_rawpk:

741

# Types

742

class pubkey_st(ctypes.Structure):

743

_fields = []

744

pubkey_t = ctypes.POINTER(pubkey_st)

745

746

x509_crt_fmt_t = ctypes.c_int

747

748

# All the function declarations below are from gnutls/abstract.h

749

pubkey_init = _library.gnutls_pubkey_init

750

pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]

751

pubkey_init.restype = _error_code

752

753

pubkey_import = _library.gnutls_pubkey_import

754

pubkey_import.argtypes = [pubkey_t, ctypes.POINTER(datum_t),

755

x509_crt_fmt_t]

756

pubkey_import.restype = _error_code

757

758

pubkey_get_key_id = _library.gnutls_pubkey_get_key_id

759

pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,

760

ctypes.POINTER(ctypes.c_ubyte),

761

ctypes.POINTER(ctypes.c_size_t)]

762

pubkey_get_key_id.restype = _error_code

763

764

pubkey_deinit = _library.gnutls_pubkey_deinit

765

pubkey_deinit.argtypes = [pubkey_t]

766

pubkey_deinit.restype = None

767

else:

768

# All the function declarations below are from gnutls/openpgp.h

769

770

openpgp_crt_init = _library.gnutls_openpgp_crt_init

771

openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]

772

openpgp_crt_init.restype = _error_code

773

774

openpgp_crt_import = _library.gnutls_openpgp_crt_import

775

openpgp_crt_import.argtypes = [openpgp_crt_t,

776

ctypes.POINTER(datum_t),

777

openpgp_crt_fmt_t]

778

openpgp_crt_import.restype = _error_code

779

780

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

781

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

782

ctypes.POINTER(ctypes.c_uint)]

783

openpgp_crt_verify_self.restype = _error_code

784

785

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

786

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

787

openpgp_crt_deinit.restype = None

788

789

openpgp_crt_get_fingerprint = (

790

_library.gnutls_openpgp_crt_get_fingerprint)

791

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

792

ctypes.c_void_p,

793

ctypes.POINTER(

794

ctypes.c_size_t)]

795

openpgp_crt_get_fingerprint.restype = _error_code

796

797

if check_version("3.6.4"):

798

certificate_type_get2 = _library.gnutls_certificate_type_get2

799

certificate_type_get2.argtypes = [session_t, ctypes.c_int]

800

certificate_type_get2.restype = _error_code

801

802

# Remove non-public functions

803

del _error_code, _retry_on_error

804

805

806

def call_pipe(connection, # : multiprocessing.Connection

807

func, *args, **kwargs):

808

"""This function is meant to be called by multiprocessing.Process

809

810

This function runs func(*args, **kwargs), and writes the resulting

811

return value on the provided multiprocessing.Connection.

812

"""

813

connection.send(func(*args, **kwargs))

814

connection.close()

399

815

400

816

401

817

class Client(object):

402

818

"""A representation of a client host served by this server.

403

819

404

820

Attributes:

405

821

approved: bool(); 'None' if not yet approved/disapproved

406

822

approval_delay: datetime.timedelta(); Time to wait for approval

408

824

checker: subprocess.Popen(); a running checker process used

409

825

to see if the client lives.

410

826

'None' if no process is running.

411

checker_callback_tag: a gobject event source tag, or None

827

checker_callback_tag: a GLib event source tag, or None

412

828

checker_command: string; External command which is run to check

413

829

if client lives. %() expansions are done at

414

830

runtime with vars(self) as dict, so that for

415

831

instance %(name)s can be used in the command.

416

checker_initiator_tag: a gobject event source tag, or None

832

checker_initiator_tag: a GLib event source tag, or None

417

833

created: datetime.datetime(); (UTC) object creation

418

834

client_structure: Object describing what attributes a client has

419

835

and is used for storing the client at exit

420

836

current_checker_command: string; current running checker_command

421

disable_initiator_tag: a gobject event source tag, or None

837

disable_initiator_tag: a GLib event source tag, or None

422

838

enabled: bool()

423

839

fingerprint: string (40 or 32 hexadecimal digits); used to

424

uniquely identify the client

840

uniquely identify an OpenPGP client

841

key_id: string (64 hexadecimal digits); used to uniquely identify

842

a client using raw public keys

425

843

host: string; available for use by the checker command

426

844

interval: datetime.timedelta(); How often to start a new checker

427

845

last_approval_request: datetime.datetime(); (UTC) or None

429

847

last_checker_status: integer between 0 and 255 reflecting exit

430

848

status of last checker. -1 reflects crashed

431

849

checker, -2 means no checker completed yet.

850

last_checker_signal: The signal which killed the last checker, if

851

last_checker_status is -1

432

852

last_enabled: datetime.datetime(); (UTC) or None

433

853

name: string; from the config file, used in log messages and

434

854

D-Bus identifiers

439

859

runtime_expansions: Allowed attributes for runtime expansion.

440

860

expires: datetime.datetime(); time (UTC) when a client will be

441

861

disabled, or None

862

server_settings: The server_settings dict from main()

442

863

"""

443

864

444

865

runtime_expansions = ("approval_delay", "approval_duration",

445

"created", "enabled", "expires",

866

"created", "enabled", "expires", "key_id",

446

867

"fingerprint", "host", "interval",

447

868

"last_approval_request", "last_checked_ok",

448

869

"last_enabled", "name", "timeout")

449

client_defaults = { "timeout": "5m",

450

"extended_timeout": "15m",

451

"interval": "2m",

452

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

453

"host": "",

454

"approval_delay": "0s",

455

"approval_duration": "1s",

456

"approved_by_default": "True",

457

"enabled": "True",

458

}

459

460

def timeout_milliseconds(self):

461

"Return the 'timeout' attribute in milliseconds"

462

return timedelta_to_milliseconds(self.timeout)

463

464

def extended_timeout_milliseconds(self):

465

"Return the 'extended_timeout' attribute in milliseconds"

466

return timedelta_to_milliseconds(self.extended_timeout)

467

468

def interval_milliseconds(self):

469

"Return the 'interval' attribute in milliseconds"

470

return timedelta_to_milliseconds(self.interval)

471

472

def approval_delay_milliseconds(self):

473

return timedelta_to_milliseconds(self.approval_delay)

474

870

client_defaults = {

871

"timeout": "PT5M",

872

"extended_timeout": "PT15M",

873

"interval": "PT2M",

874

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

875

"host": "",

876

"approval_delay": "PT0S",

877

"approval_duration": "PT1S",

878

"approved_by_default": "True",

879

"enabled": "True",

880

}

881

475

882

@staticmethod

476

883

def config_parser(config):

477

884

"""Construct a new dict of client settings of this form:

484

891

for client_name in config.sections():

485

892

section = dict(config.items(client_name))

486

893

client = settings[client_name] = {}

487

894

488

895

client["host"] = section["host"]

489

896

# Reformat values from string types to Python types

490

897

client["approved_by_default"] = config.getboolean(

491

898

client_name, "approved_by_default")

492

899

client["enabled"] = config.getboolean(client_name,

493

900

"enabled")

494

901

902

# Uppercase and remove spaces from key_id and fingerprint

903

# for later comparison purposes with return value from the

904

# key_id() and fingerprint() functions

905

client["key_id"] = (section.get("key_id", "").upper()

906

.replace(" ", ""))

495

907

client["fingerprint"] = (section["fingerprint"].upper()

496

908

.replace(" ", ""))

497

909

if "secret" in section:

498

client["secret"] = section["secret"].decode("base64")

910

client["secret"] = codecs.decode(section["secret"]

911

.encode("utf-8"),

912

"base64")

499

913

elif "secfile" in section:

500

914

with open(os.path.expanduser(os.path.expandvars

501

915

(section["secfile"])),

502

916

"rb") as secfile:

503

917

client["secret"] = secfile.read()

504

918

else:

505

raise TypeError("No secret or secfile for section {0}"

919

raise TypeError("No secret or secfile for section {}"

506

920

.format(section))

507

921

client["timeout"] = string_to_delta(section["timeout"])

508

922

client["extended_timeout"] = string_to_delta(

516

930

client["last_approval_request"] = None

517

931

client["last_checked_ok"] = None

518

932

client["last_checker_status"] = -2

519

933

520

934

return settings

521

522

def __init__(self, settings, name = None):

935

936

def __init__(self, settings, name=None, server_settings=None):

523

937

self.name = name

938

if server_settings is None:

939

server_settings = {}

940

self.server_settings = server_settings

524

941

# adding all client settings

525

for setting, value in settings.iteritems():

942

for setting, value in settings.items():

526

943

setattr(self, setting, value)

527

944

528

945

if self.enabled:

529

946

if not hasattr(self, "last_enabled"):

530

947

self.last_enabled = datetime.datetime.utcnow()

534

951

else:

535

952

self.last_enabled = None

536

953

self.expires = None

537

954

538

955

logger.debug("Creating client %r", self.name)

539

# Uppercase and remove spaces from fingerprint for later

540

# comparison purposes with return value from the fingerprint()

541

# function

956

logger.debug(" Key ID: %s", self.key_id)

542

957

logger.debug(" Fingerprint: %s", self.fingerprint)

543

958

self.created = settings.get("created",

544

959

datetime.datetime.utcnow())

545

960

546

961

# attributes specific for this server instance

547

962

self.checker = None

548

963

self.checker_initiator_tag = None

551

966

self.current_checker_command = None

552

967

self.approved = None

553

968

self.approvals_pending = 0

554

self.changedstate = (multiprocessing_manager

555

.Condition(multiprocessing_manager

556

.Lock()))

557

self.client_structure = [attr for attr in

558

self.__dict__.iterkeys()

969

self.changedstate = multiprocessing_manager.Condition(

970

multiprocessing_manager.Lock())

971

self.client_structure = [attr

972

for attr in self.__dict__.keys()

559

973

if not attr.startswith("_")]

560

974

self.client_structure.append("client_structure")

561

562

for name, t in inspect.getmembers(type(self),

563

lambda obj:

564

isinstance(obj,

565

property)):

975

976

for name, t in inspect.getmembers(

977

type(self), lambda obj: isinstance(obj, property)):

566

978

if not name.startswith("_"):

567

979

self.client_structure.append(name)

568

980

569

981

# Send notice to process children that client state has changed

570

982

def send_changedstate(self):

571

983

with self.changedstate:

572

984

self.changedstate.notify_all()

573

985

574

986

def enable(self):

575

987

"""Start this client's checker and timeout hooks"""

576

988

if getattr(self, "enabled", False):

581

993

self.last_enabled = datetime.datetime.utcnow()

582

994

self.init_checker()

583

995

self.send_changedstate()

584

996

585

997

def disable(self, quiet=True):

586

998

"""Disable this client."""

587

999

if not getattr(self, "enabled", False):

589

1001

if not quiet:

590

1002

logger.info("Disabling client %s", self.name)

591

1003

if getattr(self, "disable_initiator_tag", None) is not None:

592

gobject.source_remove(self.disable_initiator_tag)

1004

GLib.source_remove(self.disable_initiator_tag)

593

1005

self.disable_initiator_tag = None

594

1006

self.expires = None

595

1007

if getattr(self, "checker_initiator_tag", None) is not None:

596

gobject.source_remove(self.checker_initiator_tag)

1008

GLib.source_remove(self.checker_initiator_tag)

597

1009

self.checker_initiator_tag = None

598

1010

self.stop_checker()

599

1011

self.enabled = False

600

1012

if not quiet:

601

1013

self.send_changedstate()

602

# Do not run this again if called by a gobject.timeout_add

1014

# Do not run this again if called by a GLib.timeout_add

603

1015

return False

604

1016

605

1017

def __del__(self):

606

1018

self.disable()

607

1019

608

1020

def init_checker(self):

609

1021

# Schedule a new checker to be started an 'interval' from now,

610

1022

# and every interval from then on.

611

1023

if self.checker_initiator_tag is not None:

612

gobject.source_remove(self.checker_initiator_tag)

613

self.checker_initiator_tag = (gobject.timeout_add

614

(self.interval_milliseconds(),

615

self.start_checker))

1024

GLib.source_remove(self.checker_initiator_tag)

1025

self.checker_initiator_tag = GLib.timeout_add(

1026

int(self.interval.total_seconds() * 1000),

1027

self.start_checker)

616

1028

# Schedule a disable() when 'timeout' has passed

617

1029

if self.disable_initiator_tag is not None:

618

gobject.source_remove(self.disable_initiator_tag)

619

self.disable_initiator_tag = (gobject.timeout_add

620

(self.timeout_milliseconds(),

621

self.disable))

1030

GLib.source_remove(self.disable_initiator_tag)

1031

self.disable_initiator_tag = GLib.timeout_add(

1032

int(self.timeout.total_seconds() * 1000), self.disable)

622

1033

# Also start a new checker *right now*.

623

1034

self.start_checker()

624

625

def checker_callback(self, pid, condition, command):

1035

1036

def checker_callback(self, source, condition, connection,

1037

command):

626

1038

"""The checker has completed, so take appropriate actions."""

627

1039

self.checker_callback_tag = None

628

1040

self.checker = None

629

if os.WIFEXITED(condition):

630

self.last_checker_status = os.WEXITSTATUS(condition)

1041

# Read return code from connection (see call_pipe)

1042

returncode = connection.recv()

1043

connection.close()

1044

1045

if returncode >= 0:

1046

self.last_checker_status = returncode

1047

self.last_checker_signal = None

631

1048

if self.last_checker_status == 0:

632

1049

logger.info("Checker for %(name)s succeeded",

633

1050

vars(self))

634

1051

self.checked_ok()

635

1052

else:

636

logger.info("Checker for %(name)s failed",

637

vars(self))

1053

logger.info("Checker for %(name)s failed", vars(self))

638

1054

else:

639

1055

self.last_checker_status = -1

1056

self.last_checker_signal = -returncode

640

1057

logger.warning("Checker for %(name)s crashed?",

641

1058

vars(self))

642

1059

return False

1060

643

1061

def checked_ok(self):

644

1062

"""Assert that the client has been seen, alive and well."""

645

1063

self.last_checked_ok = datetime.datetime.utcnow()

646

1064

self.last_checker_status = 0

1065

self.last_checker_signal = None

647

1066

self.bump_timeout()

648

1067

649

1068

def bump_timeout(self, timeout=None):

650

1069

"""Bump up the timeout for this client."""

651

1070

if timeout is None:

652

1071

timeout = self.timeout

653

1072

if self.disable_initiator_tag is not None:

654

gobject.source_remove(self.disable_initiator_tag)

1073

GLib.source_remove(self.disable_initiator_tag)

655

1074

self.disable_initiator_tag = None

656

1075

if getattr(self, "enabled", False):

657

self.disable_initiator_tag = (gobject.timeout_add

658

(timedelta_to_milliseconds

659

(timeout), self.disable))

1076

self.disable_initiator_tag = GLib.timeout_add(

1077

int(timeout.total_seconds() * 1000), self.disable)

660

1078

self.expires = datetime.datetime.utcnow() + timeout

661

1079

662

1080

def need_approval(self):

663

1081

self.last_approval_request = datetime.datetime.utcnow()

664

1082

665

1083

def start_checker(self):

666

1084

"""Start a new checker subprocess if one is not running.

667

1085

668

1086

If a checker already exists, leave it running and do

669

1087

nothing."""

670

1088

# The reason for not killing a running checker is that if we

675

1093

# checkers alone, the checker would have to take more time

676

1094

# than 'timeout' for the client to be disabled, which is as it

677

1095

# should be.

678

679

# If a checker exists, make sure it is not a zombie

680

try:

681

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

682

except (AttributeError, OSError) as error:

683

if (isinstance(error, OSError)

684

and error.errno != errno.ECHILD):

685

raise error

686

else:

687

if pid:

688

logger.warning("Checker was a zombie")

689

gobject.source_remove(self.checker_callback_tag)

690

self.checker_callback(pid, status,

691

self.current_checker_command)

1096

1097

if self.checker is not None and not self.checker.is_alive():

1098

logger.warning("Checker was not alive; joining")

1099

self.checker.join()

1100

self.checker = None

692

1101

# Start a new checker if needed

693

1102

if self.checker is None:

694

1103

# Escape attributes for the shell

695

escaped_attrs = dict(

696

(attr, re.escape(unicode(getattr(self, attr))))

697

for attr in

698

self.runtime_expansions)

1104

escaped_attrs = {

1105

attr: re.escape(str(getattr(self, attr)))

1106

for attr in self.runtime_expansions}

699

1107

try:

700

1108

command = self.checker_command % escaped_attrs

701

1109

except TypeError as error:

702

1110

logger.error('Could not format string "%s"',

703

self.checker_command, exc_info=error)

704

return True # Try again later

1111

self.checker_command,

1112

exc_info=error)

1113

return True # Try again later

705

1114

self.current_checker_command = command

706

try:

707

logger.info("Starting checker %r for %s",

708

command, self.name)

709

# We don't need to redirect stdout and stderr, since

710

# in normal mode, that is already done by daemon(),

711

# and in debug mode we don't want to. (Stdin is

712

# always replaced by /dev/null.)

713

self.checker = subprocess.Popen(command,

714

close_fds=True,

715

shell=True, cwd="/")

716

except OSError as error:

717

logger.error("Failed to start subprocess",

718

exc_info=error)

719

self.checker_callback_tag = (gobject.child_watch_add

720

(self.checker.pid,

721

self.checker_callback,

722

data=command))

723

# The checker may have completed before the gobject

724

# watch was added. Check for this.

725

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

726

if pid:

727

gobject.source_remove(self.checker_callback_tag)

728

self.checker_callback(pid, status, command)

729

# Re-run this periodically if run by gobject.timeout_add

1115

logger.info("Starting checker %r for %s", command,

1116

self.name)

1117

# We don't need to redirect stdout and stderr, since

1118

# in normal mode, that is already done by daemon(),

1119

# and in debug mode we don't want to. (Stdin is

1120

# always replaced by /dev/null.)

1121

# The exception is when not debugging but nevertheless

1122

# running in the foreground; use the previously

1123

# created wnull.

1124

popen_args = {"close_fds": True,

1125

"shell": True,

1126

"cwd": "/"}

1127

if (not self.server_settings["debug"]

1128

and self.server_settings["foreground"]):

1129

popen_args.update({"stdout": wnull,

1130

"stderr": wnull})

1131

pipe = multiprocessing.Pipe(duplex=False)

1132

self.checker = multiprocessing.Process(

1133

target=call_pipe,

1134

args=(pipe[1], subprocess.call, command),

1135

kwargs=popen_args)

1136

self.checker.start()

1137

self.checker_callback_tag = GLib.io_add_watch(

1138

pipe[0].fileno(), GLib.IO_IN,

1139

self.checker_callback, pipe[0], command)

1140

# Re-run this periodically if run by GLib.timeout_add

730

1141

return True

731

1142

732

1143

def stop_checker(self):

733

1144

"""Force the checker process, if any, to stop."""

734

1145

if self.checker_callback_tag:

735

gobject.source_remove(self.checker_callback_tag)

1146

GLib.source_remove(self.checker_callback_tag)

736

1147

self.checker_callback_tag = None

737

1148

if getattr(self, "checker", None) is None:

738

1149

return

739

1150

logger.debug("Stopping checker for %(name)s", vars(self))

740

try:

741

self.checker.terminate()

742

#time.sleep(0.5)

743

#if self.checker.poll() is None:

744

# self.checker.kill()

745

except OSError as error:

746

if error.errno != errno.ESRCH: # No such process

747

raise

1151

self.checker.terminate()

748

1152

self.checker = None

749

1153

750

1154

751

def dbus_service_property(dbus_interface, signature="v",

752

access="readwrite", byte_arrays=False):

1155

def dbus_service_property(dbus_interface,

1156

signature="v",

1157

access="readwrite",

1158

byte_arrays=False):

753

1159

"""Decorators for marking methods of a DBusObjectWithProperties to

754

1160

become properties on the D-Bus.

755

1161

756

1162

The decorated method will be called with no arguments by "Get"

757

1163

and with one argument by "Set".

758

1164

759

1165

The parameters, where they are supported, are the same as

760

1166

dbus.service.method, except there is only "signature", since the

761

1167

type from Get() and the type sent to Set() is the same.

764

1170

# "Set" method, so we fail early here:

765

1171

if byte_arrays and signature != "ay":

766

1172

raise ValueError("Byte arrays not supported for non-'ay'"

767

" signature {0!r}".format(signature))

1173

" signature {!r}".format(signature))

1174

768

1175

def decorator(func):

769

1176

func._dbus_is_property = True

770

1177

func._dbus_interface = dbus_interface

773

1180

func._dbus_name = func.__name__

774

1181

if func._dbus_name.endswith("_dbus_property"):

775

1182

func._dbus_name = func._dbus_name[:-14]

776

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1183

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

777

1184

return func

1185

778

1186

return decorator

779

1187

780

1188

781

1189

def dbus_interface_annotations(dbus_interface):

782

1190

"""Decorator for marking functions returning interface annotations

783

1191

784

1192

Usage:

785

1193

786

1194

@dbus_interface_annotations("org.example.Interface")

787

1195

def _foo(self): # Function name does not matter

788

1196

return {"org.freedesktop.DBus.Deprecated": "true",

789

1197

"org.freedesktop.DBus.Property.EmitsChangedSignal":

790

1198

"false"}

791

1199

"""

1200

792

1201

def decorator(func):

793

1202

func._dbus_is_interface = True

794

1203

func._dbus_interface = dbus_interface

795

1204

func._dbus_name = dbus_interface

796

1205

return func

1206

797

1207

return decorator

798

1208

799

1209

800

1210

def dbus_annotations(annotations):

801

1211

"""Decorator to annotate D-Bus methods, signals or properties

802

1212

Usage:

803

1213

1214

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true",

1215

"org.freedesktop.DBus.Property."

1216

"EmitsChangedSignal": "false"})

804

1217

@dbus_service_property("org.example.Interface", signature="b",

805

1218

access="r")

806

@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",

807

"org.freedesktop.DBus.Property."

808

"EmitsChangedSignal": "false"})

809

1219

def Property_dbus_property(self):

810

1220

return dbus.Boolean(False)

1221

1222

See also the DBusObjectWithAnnotations class.

811

1223

"""

1224

812

1225

def decorator(func):

813

1226

func._dbus_annotations = annotations

814

1227

return func

1228

815

1229

return decorator

816

1230

817

1231

818

1232

class DBusPropertyException(dbus.exceptions.DBusException):

819

1233

"""A base class for D-Bus property-related exceptions

820

1234

"""

821

def __unicode__(self):

822

return unicode(str(self))

1235

pass

823

1236

824

1237

825

1238

class DBusPropertyAccessException(DBusPropertyException):

834

1247

pass

835

1248

836

1249

837

class DBusObjectWithProperties(dbus.service.Object):

838

"""A D-Bus object with properties.

839

840

Classes inheriting from this can use the dbus_service_property

841

decorator to expose methods as D-Bus properties. It exposes the

842

standard Get(), Set(), and GetAll() methods on the D-Bus.

1250

class DBusObjectWithAnnotations(dbus.service.Object):

1251

"""A D-Bus object with annotations.

1252

1253

Classes inheriting from this can use the dbus_annotations

1254

decorator to add annotations to methods or signals.

843

1255

"""

844

1256

845

1257

@staticmethod

846

1258

def _is_dbus_thing(thing):

847

1259

"""Returns a function testing if an attribute is a D-Bus thing

848

1260

849

1261

If called like _is_dbus_thing("method") it returns a function

850

1262

suitable for use as predicate to inspect.getmembers().

851

1263

"""

852

return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),

1264

return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),

853

1265

False)

854

1266

855

1267

def _get_all_dbus_things(self, thing):

856

1268

"""Returns a generator of (name, attribute) pairs

857

1269

"""

858

return ((getattr(athing.__get__(self), "_dbus_name",

859

name),

1270

return ((getattr(athing.__get__(self), "_dbus_name", name),

860

1271

athing.__get__(self))

861

1272

for cls in self.__class__.__mro__

862

1273

for name, athing in

863

inspect.getmembers(cls,

864

self._is_dbus_thing(thing)))

865

1274

inspect.getmembers(cls, self._is_dbus_thing(thing)))

1275

1276

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1277

out_signature="s",

1278

path_keyword='object_path',

1279

connection_keyword='connection')

1280

def Introspect(self, object_path, connection):

1281

"""Overloading of standard D-Bus method.

1282

1283

Inserts annotation tags on methods and signals.

1284

"""

1285

xmlstring = dbus.service.Object.Introspect(self, object_path,

1286

connection)

1287

try:

1288

document = xml.dom.minidom.parseString(xmlstring)

1289

1290

for if_tag in document.getElementsByTagName("interface"):

1291

# Add annotation tags

1292

for typ in ("method", "signal"):

1293

for tag in if_tag.getElementsByTagName(typ):

1294

annots = dict()

1295

for name, prop in (self.

1296

_get_all_dbus_things(typ)):

1297

if (name == tag.getAttribute("name")

1298

and prop._dbus_interface

1299

== if_tag.getAttribute("name")):

1300

annots.update(getattr(

1301

prop, "_dbus_annotations", {}))

1302

for name, value in annots.items():

1303

ann_tag = document.createElement(

1304

"annotation")

1305

ann_tag.setAttribute("name", name)

1306

ann_tag.setAttribute("value", value)

1307

tag.appendChild(ann_tag)

1308

# Add interface annotation tags

1309

for annotation, value in dict(

1310

itertools.chain.from_iterable(

1311

annotations().items()

1312

for name, annotations

1313

in self._get_all_dbus_things("interface")

1314

if name == if_tag.getAttribute("name")

1315

)).items():

1316

ann_tag = document.createElement("annotation")

1317

ann_tag.setAttribute("name", annotation)

1318

ann_tag.setAttribute("value", value)

1319

if_tag.appendChild(ann_tag)

1320

# Fix argument name for the Introspect method itself

1321

if (if_tag.getAttribute("name")

1322

== dbus.INTROSPECTABLE_IFACE):

1323

for cn in if_tag.getElementsByTagName("method"):

1324

if cn.getAttribute("name") == "Introspect":

1325

for arg in cn.getElementsByTagName("arg"):

1326

if (arg.getAttribute("direction")

1327

== "out"):

1328

arg.setAttribute("name",

1329

"xml_data")

1330

xmlstring = document.toxml("utf-8")

1331

document.unlink()

1332

except (AttributeError, xml.dom.DOMException,

1333

xml.parsers.expat.ExpatError) as error:

1334

logger.error("Failed to override Introspection method",

1335

exc_info=error)

1336

return xmlstring

1337

1338

1339

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1340

"""A D-Bus object with properties.

1341

1342

Classes inheriting from this can use the dbus_service_property

1343

decorator to expose methods as D-Bus properties. It exposes the

1344

standard Get(), Set(), and GetAll() methods on the D-Bus.

1345

"""

1346

866

1347

def _get_dbus_property(self, interface_name, property_name):

867

1348

"""Returns a bound method if one exists which is a D-Bus

868

1349

property with the specified name and interface.

869

1350

"""

870

for cls in self.__class__.__mro__:

871

for name, value in (inspect.getmembers

872

(cls,

873

self._is_dbus_thing("property"))):

1351

for cls in self.__class__.__mro__:

1352

for name, value in inspect.getmembers(

1353

cls, self._is_dbus_thing("property")):

874

1354

if (value._dbus_name == property_name

875

1355

and value._dbus_interface == interface_name):

876

1356

return value.__get__(self)

877

1357

878

1358

# No such property

879

raise DBusPropertyNotFound(self.dbus_object_path + ":"

880

+ interface_name + "."

881

+ property_name)

882

883

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ss",

1359

raise DBusPropertyNotFound("{}:{}.{}".format(

1360

self.dbus_object_path, interface_name, property_name))

1361

1362

@classmethod

1363

def _get_all_interface_names(cls):

1364

"""Get a sequence of all interfaces supported by an object"""

1365

return (name for name in set(getattr(getattr(x, attr),

1366

"_dbus_interface", None)

1367

for x in (inspect.getmro(cls))

1368

for attr in dir(x))

1369

if name is not None)

1370

1371

@dbus.service.method(dbus.PROPERTIES_IFACE,

1372

in_signature="ss",

884

1373

out_signature="v")

885

1374

def Get(self, interface_name, property_name):

886

1375

"""Standard D-Bus property Get() method, see D-Bus standard.

892

1381

if not hasattr(value, "variant_level"):

893

1382

return value

894

1383

return type(value)(value, variant_level=value.variant_level+1)

895

1384

896

1385

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")

897

1386

def Set(self, interface_name, property_name, value):

898

1387

"""Standard D-Bus property Set() method, see D-Bus standard.

904

1393

# The byte_arrays option is not supported yet on

905

1394

# signatures other than "ay".

906

1395

if prop._dbus_signature != "ay":

907

raise ValueError

1396

raise ValueError("Byte arrays not supported for non-"

1397

"'ay' signature {!r}"

1398

.format(prop._dbus_signature))

908

1399

value = dbus.ByteArray(b''.join(chr(byte)

909

1400

for byte in value))

910

1401

prop(value)

911

912

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",

1402

1403

@dbus.service.method(dbus.PROPERTIES_IFACE,

1404

in_signature="s",

913

1405

out_signature="a{sv}")

914

1406

def GetAll(self, interface_name):

915

1407

"""Standard D-Bus property GetAll() method, see D-Bus

916

1408

standard.

917

1409

918

1410

Note: Will not include properties with access="write".

919

1411

"""

920

1412

properties = {}

930

1422

if not hasattr(value, "variant_level"):

931

1423

properties[name] = value

932

1424

continue

933

properties[name] = type(value)(value, variant_level=

934

value.variant_level+1)

1425

properties[name] = type(value)(

1426

value, variant_level=value.variant_level + 1)

935

1427

return dbus.Dictionary(properties, signature="sv")

936

1428

1429

@dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")

1430

def PropertiesChanged(self, interface_name, changed_properties,

1431

invalidated_properties):

1432

"""Standard D-Bus PropertiesChanged() signal, see D-Bus

1433

standard.

1434

"""

1435

pass

1436

937

1437

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

938

1438

out_signature="s",

939

1439

path_keyword='object_path',

940

1440

connection_keyword='connection')

941

1441

def Introspect(self, object_path, connection):

942

1442

"""Overloading of standard D-Bus method.

943

1443

944

1444

Inserts property tags and interface annotation tags.

945

1445

"""

946

xmlstring = dbus.service.Object.Introspect(self, object_path,

947

connection)

1446

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1447

object_path,

1448

connection)

948

1449

try:

949

1450

document = xml.dom.minidom.parseString(xmlstring)

1451

950

1452

def make_tag(document, name, prop):

951

1453

e = document.createElement("property")

952

1454

e.setAttribute("name", name)

953

1455

e.setAttribute("type", prop._dbus_signature)

954

1456

e.setAttribute("access", prop._dbus_access)

955

1457

return e

1458

956

1459

for if_tag in document.getElementsByTagName("interface"):

957

1460

# Add property tags

958

1461

for tag in (make_tag(document, name, prop)

961

1464

if prop._dbus_interface

962

1465

== if_tag.getAttribute("name")):

963

1466

if_tag.appendChild(tag)

964

# Add annotation tags

965

for typ in ("method", "signal", "property"):

966

for tag in if_tag.getElementsByTagName(typ):

967

annots = dict()

968

for name, prop in (self.

969

_get_all_dbus_things(typ)):

970

if (name == tag.getAttribute("name")

971

and prop._dbus_interface

972

== if_tag.getAttribute("name")):

973

annots.update(getattr

974

(prop,

975

"_dbus_annotations",

976

{}))

977

for name, value in annots.iteritems():

978

ann_tag = document.createElement(

979

"annotation")

980

ann_tag.setAttribute("name", name)

981

ann_tag.setAttribute("value", value)

982

tag.appendChild(ann_tag)

983

# Add interface annotation tags

984

for annotation, value in dict(

985

itertools.chain.from_iterable(

986

annotations().iteritems()

987

for name, annotations in

988

self._get_all_dbus_things("interface")

989

if name == if_tag.getAttribute("name")

990

)).iteritems():

991

ann_tag = document.createElement("annotation")

992

ann_tag.setAttribute("name", annotation)

993

ann_tag.setAttribute("value", value)

994

if_tag.appendChild(ann_tag)

1467

# Add annotation tags for properties

1468

for tag in if_tag.getElementsByTagName("property"):

1469

annots = dict()

1470

for name, prop in self._get_all_dbus_things(

1471

"property"):

1472

if (name == tag.getAttribute("name")

1473

and prop._dbus_interface

1474

== if_tag.getAttribute("name")):

1475

annots.update(getattr(

1476

prop, "_dbus_annotations", {}))

1477

for name, value in annots.items():

1478

ann_tag = document.createElement(

1479

"annotation")

1480

ann_tag.setAttribute("name", name)

1481

ann_tag.setAttribute("value", value)

1482

tag.appendChild(ann_tag)

995

1483

# Add the names to the return values for the

996

1484

# "org.freedesktop.DBus.Properties" methods

997

1485

if (if_tag.getAttribute("name")

1016

1504

return xmlstring

1017

1505

1018

1506

1507

try:

1508

dbus.OBJECT_MANAGER_IFACE

1509

except AttributeError:

1510

dbus.OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"

1511

1512

1513

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1514

"""A D-Bus object with an ObjectManager.

1515

1516

Classes inheriting from this exposes the standard

1517

GetManagedObjects call and the InterfacesAdded and

1518

InterfacesRemoved signals on the standard

1519

"org.freedesktop.DBus.ObjectManager" interface.

1520

1521

Note: No signals are sent automatically; they must be sent

1522

manually.

1523

"""

1524

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1525

out_signature="a{oa{sa{sv}}}")

1526

def GetManagedObjects(self):

1527

"""This function must be overridden"""

1528

raise NotImplementedError()

1529

1530

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1531

signature="oa{sa{sv}}")

1532

def InterfacesAdded(self, object_path, interfaces_and_properties):

1533

pass

1534

1535

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE, signature="oas")

1536

def InterfacesRemoved(self, object_path, interfaces):

1537

pass

1538

1539

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1540

out_signature="s",

1541

path_keyword='object_path',

1542

connection_keyword='connection')

1543

def Introspect(self, object_path, connection):

1544

"""Overloading of standard D-Bus method.

1545

1546

Override return argument name of GetManagedObjects to be

1547

"objpath_interfaces_and_properties"

1548

"""

1549

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1550

object_path,

1551

connection)

1552

try:

1553

document = xml.dom.minidom.parseString(xmlstring)

1554

1555

for if_tag in document.getElementsByTagName("interface"):

1556

# Fix argument name for the GetManagedObjects method

1557

if (if_tag.getAttribute("name")

1558

== dbus.OBJECT_MANAGER_IFACE):

1559

for cn in if_tag.getElementsByTagName("method"):

1560

if (cn.getAttribute("name")

1561

== "GetManagedObjects"):

1562

for arg in cn.getElementsByTagName("arg"):

1563

if (arg.getAttribute("direction")

1564

== "out"):

1565

arg.setAttribute(

1566

"name",

1567

"objpath_interfaces"

1568

"_and_properties")

1569

xmlstring = document.toxml("utf-8")

1570

document.unlink()

1571

except (AttributeError, xml.dom.DOMException,

1572

xml.parsers.expat.ExpatError) as error:

1573

logger.error("Failed to override Introspection method",

1574

exc_info=error)

1575

return xmlstring

1576

1577

1019

1578

def datetime_to_dbus(dt, variant_level=0):

1020

1579

"""Convert a UTC datetime.datetime() to a D-Bus type."""

1021

1580

if dt is None:

1022

return dbus.String("", variant_level = variant_level)

1023

return dbus.String(dt.isoformat(),

1024

variant_level=variant_level)

1581

return dbus.String("", variant_level=variant_level)

1582

return dbus.String(dt.isoformat(), variant_level=variant_level)

1025

1583

1026

1584

1027

1585

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1029

1587

dbus.service.Object, it will add alternate D-Bus attributes with

1030

1588

interface names according to the "alt_interface_names" mapping.

1031

1589

Usage:

1032

1590

1033

1591

@alternate_dbus_interfaces({"org.example.Interface":

1034

1592

"net.example.AlternateInterface"})

1035

1593

class SampleDBusObject(dbus.service.Object):

1036

1594

@dbus.service.method("org.example.Interface")

1037

1595

def SampleDBusMethod():

1038

1596

pass

1039

1597

1040

1598

The above "SampleDBusMethod" on "SampleDBusObject" will be

1041

1599

reachable via two interfaces: "org.example.Interface" and

1042

1600

"net.example.AlternateInterface", the latter of which will have

1043

1601

its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to

1044

1602

"true", unless "deprecate" is passed with a False value.

1045

1603

1046

1604

This works for methods and signals, and also for D-Bus properties

1047

1605

(from DBusObjectWithProperties) and interfaces (from the

1048

1606

dbus_interface_annotations decorator).

1049

1607

"""

1608

1050

1609

def wrapper(cls):

1051

1610

for orig_interface_name, alt_interface_name in (

1052

alt_interface_names.iteritems()):

1611

alt_interface_names.items()):

1053

1612

attr = {}

1054

1613

interface_names = set()

1055

1614

# Go though all attributes of the class

1057

1616

# Ignore non-D-Bus attributes, and D-Bus attributes

1058

1617

# with the wrong interface name

1059

1618

if (not hasattr(attribute, "_dbus_interface")

1060

or not attribute._dbus_interface

1061

.startswith(orig_interface_name)):

1619

or not attribute._dbus_interface.startswith(

1620

orig_interface_name)):

1062

1621

continue

1063

1622

# Create an alternate D-Bus interface name based on

1064

1623

# the current name

1065

alt_interface = (attribute._dbus_interface

1066

.replace(orig_interface_name,

1067

alt_interface_name))

1624

alt_interface = attribute._dbus_interface.replace(

1625

orig_interface_name, alt_interface_name)

1068

1626

interface_names.add(alt_interface)

1069

1627

# Is this a D-Bus signal?

1070

1628

if getattr(attribute, "_dbus_is_signal", False):

1071

# Extract the original non-method function by

1072

# black magic

1073

nonmethod_func = (dict(

1629

# Extract the original non-method undecorated

1630

# function by black magic

1631

if sys.version_info.major == 2:

1632

nonmethod_func = (dict(

1074

1633

zip(attribute.func_code.co_freevars,

1075

attribute.__closure__))["func"]

1076

.cell_contents)

1634

attribute.__closure__))

1635

["func"].cell_contents)

1636

else:

1637

nonmethod_func = (dict(

1638

zip(attribute.__code__.co_freevars,

1639

attribute.__closure__))

1640

["func"].cell_contents)

1077

1641

# Create a new, but exactly alike, function

1078

1642

# object, and decorate it to be a new D-Bus signal

1079

1643

# with the alternate D-Bus interface name

1080

new_function = (dbus.service.signal

1081

(alt_interface,

1082

attribute._dbus_signature)

1083

(types.FunctionType(

1084

nonmethod_func.func_code,

1085

nonmethod_func.func_globals,

1086

nonmethod_func.func_name,

1087

nonmethod_func.func_defaults,

1088

nonmethod_func.func_closure)))

1644

new_function = copy_function(nonmethod_func)

1645

new_function = (dbus.service.signal(

1646

alt_interface,

1647

attribute._dbus_signature)(new_function))

1089

1648

# Copy annotations, if any

1090

1649

try:

1091

new_function._dbus_annotations = (

1092

dict(attribute._dbus_annotations))

1650

new_function._dbus_annotations = dict(

1651

attribute._dbus_annotations)

1093

1652

except AttributeError:

1094

1653

pass

1654

1095

1655

# Define a creator of a function to call both the

1096

1656

# original and alternate functions, so both the

1097

1657

# original and alternate signals gets sent when

1100

1660

"""This function is a scope container to pass

1101

1661

func1 and func2 to the "call_both" function

1102

1662

outside of its arguments"""

1663

1664

@functools.wraps(func2)

1103

1665

def call_both(*args, **kwargs):

1104

1666

"""This function will emit two D-Bus

1105

1667

signals by calling func1 and func2"""

1106

1668

func1(*args, **kwargs)

1107

1669

func2(*args, **kwargs)

1670

# Make wrapper function look like a D-Bus

1671

# signal

1672

for name, attr in inspect.getmembers(func2):

1673

if name.startswith("_dbus_"):

1674

setattr(call_both, name, attr)

1675

1108

1676

return call_both

1109

1677

# Create the "call_both" function and add it to

1110

1678

# the class

1115

1683

# object. Decorate it to be a new D-Bus method

1116

1684

# with the alternate D-Bus interface name. Add it

1117

1685

# to the class.

1118

attr[attrname] = (dbus.service.method

1119

(alt_interface,

1120

attribute._dbus_in_signature,

1121

attribute._dbus_out_signature)

1122

(types.FunctionType

1123

(attribute.func_code,

1124

attribute.func_globals,

1125

attribute.func_name,

1126

attribute.func_defaults,

1127

attribute.func_closure)))

1686

attr[attrname] = (

1687

dbus.service.method(

1688

alt_interface,

1689

attribute._dbus_in_signature,

1690

attribute._dbus_out_signature)

1691

(copy_function(attribute)))

1128

1692

# Copy annotations, if any

1129

1693

try:

1130

attr[attrname]._dbus_annotations = (

1131

dict(attribute._dbus_annotations))

1694

attr[attrname]._dbus_annotations = dict(

1695

attribute._dbus_annotations)

1132

1696

except AttributeError:

1133

1697

pass

1134

1698

# Is this a D-Bus property?

1137

1701

# object, and decorate it to be a new D-Bus

1138

1702

# property with the alternate D-Bus interface

1139

1703

# name. Add it to the class.

1140

attr[attrname] = (dbus_service_property

1141

(alt_interface,

1142

attribute._dbus_signature,

1143

attribute._dbus_access,

1144

attribute

1145

._dbus_get_args_options

1146

["byte_arrays"])

1147

(types.FunctionType

1148

(attribute.func_code,

1149

attribute.func_globals,

1150

attribute.func_name,

1151

attribute.func_defaults,

1152

attribute.func_closure)))

1704

attr[attrname] = (dbus_service_property(

1705

alt_interface, attribute._dbus_signature,

1706

attribute._dbus_access,

1707

attribute._dbus_get_args_options

1708

["byte_arrays"])

1709

(copy_function(attribute)))

1153

1710

# Copy annotations, if any

1154

1711

try:

1155

attr[attrname]._dbus_annotations = (

1156

dict(attribute._dbus_annotations))

1712

attr[attrname]._dbus_annotations = dict(

1713

attribute._dbus_annotations)

1157

1714

except AttributeError:

1158

1715

pass

1159

1716

# Is this a D-Bus interface?

1162

1719

# object. Decorate it to be a new D-Bus interface

1163

1720

# with the alternate D-Bus interface name. Add it

1164

1721

# to the class.

1165

attr[attrname] = (dbus_interface_annotations

1166

(alt_interface)

1167

(types.FunctionType

1168

(attribute.func_code,

1169

attribute.func_globals,

1170

attribute.func_name,

1171

attribute.func_defaults,

1172

attribute.func_closure)))

1722

attr[attrname] = (

1723

dbus_interface_annotations(alt_interface)

1724

(copy_function(attribute)))

1173

1725

if deprecate:

1174

1726

# Deprecate all alternate interfaces

1175

iname="_AlternateDBusNames_interface_annotation{0}"

1727

iname = "_AlternateDBusNames_interface_annotation{}"

1176

1728

for interface_name in interface_names:

1729

1177

1730

@dbus_interface_annotations(interface_name)

1178

1731

def func(self):

1179

return { "org.freedesktop.DBus.Deprecated":

1180

"true" }

1732

return {"org.freedesktop.DBus.Deprecated":

1733

"true"}

1181

1734

# Find an unused name

1182

1735

for aname in (iname.format(i)

1183

1736

for i in itertools.count()):

1187

1740

if interface_names:

1188

1741

# Replace the class with a new subclass of it with

1189

1742

# methods, signals, etc. as created above.

1190

cls = type(b"{0}Alternate".format(cls.__name__),

1191

(cls,), attr)

1743

if sys.version_info.major == 2:

1744

cls = type(b"{}Alternate".format(cls.__name__),

1745

(cls, ), attr)

1746

else:

1747

cls = type("{}Alternate".format(cls.__name__),

1748

(cls, ), attr)

1192

1749

return cls

1750

1193

1751

return wrapper

1194

1752

1195

1753

1196

1754

@alternate_dbus_interfaces({"se.recompile.Mandos":

1197

"se.bsnet.fukt.Mandos"})

1755

"se.bsnet.fukt.Mandos"})

1198

1756

class ClientDBus(Client, DBusObjectWithProperties):

1199

1757

"""A Client class using D-Bus

1200

1758

1201

1759

Attributes:

1202

1760

dbus_object_path: dbus.ObjectPath

1203

1761

bus: dbus.SystemBus()

1204

1762

"""

1205

1763

1206

1764

runtime_expansions = (Client.runtime_expansions

1207

+ ("dbus_object_path",))

1208

1765

+ ("dbus_object_path", ))

1766

1767

_interface = "se.recompile.Mandos.Client"

1768

1209

1769

# dbus.service.Object doesn't use super(), so we can't either.

1210

1211

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

1770

1771

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

1212

1772

self.bus = bus

1213

1773

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

1214

1774

# Only now, when this client is initialized, can it show up on

1215

1775

# the D-Bus

1216

client_object_name = unicode(self.name).translate(

1776

client_object_name = str(self.name).translate(

1217

1777

{ord("."): ord("_"),

1218

1778

ord("-"): ord("_")})

1219

self.dbus_object_path = (dbus.ObjectPath

1220

("/clients/" + client_object_name))

1779

self.dbus_object_path = dbus.ObjectPath(

1780

"/clients/" + client_object_name)

1221

1781

DBusObjectWithProperties.__init__(self, self.bus,

1222

1782

self.dbus_object_path)

1223

1224

def notifychangeproperty(transform_func,

1225

dbus_name, type_func=lambda x: x,

1226

variant_level=1):

1783

1784

def notifychangeproperty(transform_func, dbus_name,

1785

type_func=lambda x: x,

1786

variant_level=1,

1787

invalidate_only=False,

1788

_interface=_interface):

1227

1789

""" Modify a variable so that it's a property which announces

1228

1790

its changes to DBus.

1229

1791

1230

1792

transform_fun: Function that takes a value and a variant_level

1231

1793

and transforms it to a D-Bus type.

1232

1794

dbus_name: D-Bus name of the variable

1234

1796

to the D-Bus. Default: no transform

1235

1797

variant_level: D-Bus variant level. Default: 1

1236

1798

"""

1237

attrname = "_{0}".format(dbus_name)

1799

attrname = "_{}".format(dbus_name)

1800

1238

1801

def setter(self, value):

1239

1802

if hasattr(self, "dbus_object_path"):

1240

1803

if (not hasattr(self, attrname) or

1241

1804

type_func(getattr(self, attrname, None))

1242

1805

!= type_func(value)):

1243

dbus_value = transform_func(type_func(value),

1244

variant_level

1245

=variant_level)

1246

self.PropertyChanged(dbus.String(dbus_name),

1247

dbus_value)

1806

if invalidate_only:

1807

self.PropertiesChanged(

1808

_interface, dbus.Dictionary(),

1809

dbus.Array((dbus_name, )))

1810

else:

1811

dbus_value = transform_func(

1812

type_func(value),

1813

variant_level=variant_level)

1814

self.PropertyChanged(dbus.String(dbus_name),

1815

dbus_value)

1816

self.PropertiesChanged(

1817

_interface,

1818

dbus.Dictionary({dbus.String(dbus_name):

1819

dbus_value}),

1820

dbus.Array())

1248

1821

setattr(self, attrname, value)

1249

1822

1250

1823

return property(lambda self: getattr(self, attrname), setter)

1251

1824

1252

1825

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1253

1826

approvals_pending = notifychangeproperty(dbus.Boolean,

1254

1827

"ApprovalPending",

1255

type_func = bool)

1828

type_func=bool)

1256

1829

enabled = notifychangeproperty(dbus.Boolean, "Enabled")

1257

1830

last_enabled = notifychangeproperty(datetime_to_dbus,

1258

1831

"LastEnabled")

1259

checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",

1260

type_func = lambda checker:

1261

checker is not None)

1832

checker = notifychangeproperty(

1833

dbus.Boolean, "CheckerRunning",

1834

type_func=lambda checker: checker is not None)

1262

1835

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1263

1836

"LastCheckedOK")

1264

1837

last_checker_status = notifychangeproperty(dbus.Int16,

1267

1840

datetime_to_dbus, "LastApprovalRequest")

1268

1841

approved_by_default = notifychangeproperty(dbus.Boolean,

1269

1842

"ApprovedByDefault")

1270

approval_delay = notifychangeproperty(dbus.UInt64,

1271

"ApprovalDelay",

1272

type_func =

1273

timedelta_to_milliseconds)

1843

approval_delay = notifychangeproperty(

1844

dbus.UInt64, "ApprovalDelay",

1845

type_func=lambda td: td.total_seconds() * 1000)

1274

1846

approval_duration = notifychangeproperty(

1275

1847

dbus.UInt64, "ApprovalDuration",

1276

type_func = timedelta_to_milliseconds)

1848

type_func=lambda td: td.total_seconds() * 1000)

1277

1849

host = notifychangeproperty(dbus.String, "Host")

1278

timeout = notifychangeproperty(dbus.UInt64, "Timeout",

1279

type_func =

1280

timedelta_to_milliseconds)

1850

timeout = notifychangeproperty(

1851

dbus.UInt64, "Timeout",

1852

type_func=lambda td: td.total_seconds() * 1000)

1281

1853

extended_timeout = notifychangeproperty(

1282

1854

dbus.UInt64, "ExtendedTimeout",

1283

type_func = timedelta_to_milliseconds)

1284

interval = notifychangeproperty(dbus.UInt64,

1285

"Interval",

1286

type_func =

1287

timedelta_to_milliseconds)

1855

type_func=lambda td: td.total_seconds() * 1000)

1856

interval = notifychangeproperty(

1857

dbus.UInt64, "Interval",

1858

type_func=lambda td: td.total_seconds() * 1000)

1288

1859

checker_command = notifychangeproperty(dbus.String, "Checker")

1289

1860

secret = notifychangeproperty(dbus.ByteArray, "Secret",

1861

invalidate_only=True)

1862

1290

1863

del notifychangeproperty

1291

1864

1292

1865

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

1293

1866

try:

1294

1867

self.remove_from_connection()

1297

1870

if hasattr(DBusObjectWithProperties, "__del__"):

1298

1871

DBusObjectWithProperties.__del__(self, *args, **kwargs)

1299

1872

Client.__del__(self, *args, **kwargs)

1300

1301

def checker_callback(self, pid, condition, command,

1302

*args, **kwargs):

1303

self.checker_callback_tag = None

1304

self.checker = None

1305

if os.WIFEXITED(condition):

1306

exitstatus = os.WEXITSTATUS(condition)

1873

1874

def checker_callback(self, source, condition,

1875

connection, command, *args, **kwargs):

1876

ret = Client.checker_callback(self, source, condition,

1877

connection, command, *args,

1878

**kwargs)

1879

exitstatus = self.last_checker_status

1880

if exitstatus >= 0:

1307

1881

# Emit D-Bus signal

1308

1882

self.CheckerCompleted(dbus.Int16(exitstatus),

1309

dbus.Int64(condition),

1883

# This is specific to GNU libC

1884

dbus.Int64(exitstatus << 8),

1310

1885

dbus.String(command))

1311

1886

else:

1312

1887

# Emit D-Bus signal

1313

1888

self.CheckerCompleted(dbus.Int16(-1),

1314

dbus.Int64(condition),

1889

dbus.Int64(

1890

# This is specific to GNU libC

1891

(exitstatus << 8)

1892

| self.last_checker_signal),

1315

1893

dbus.String(command))

1316

1317

return Client.checker_callback(self, pid, condition, command,

1318

*args, **kwargs)

1319

1894

return ret

1895

1320

1896

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

1321

old_checker = self.checker

1322

if self.checker is not None:

1323

old_checker_pid = self.checker.pid

1324

else:

1325

old_checker_pid = None

1897

old_checker_pid = getattr(self.checker, "pid", None)

1326

1898

r = Client.start_checker(self, *args, **kwargs)

1327

1899

# Only if new checker process was started

1328

1900

if (self.checker is not None

1330

1902

# Emit D-Bus signal

1331

1903

self.CheckerStarted(self.current_checker_command)

1332

1904

return r

1333

1905

1334

1906

def _reset_approved(self):

1335

1907

self.approved = None

1336

1908

return False

1337

1909

1338

1910

def approve(self, value=True):

1339

1911

self.approved = value

1340

gobject.timeout_add(timedelta_to_milliseconds

1341

(self.approval_duration),

1342

self._reset_approved)

1912

GLib.timeout_add(int(self.approval_duration.total_seconds()

1913

* 1000), self._reset_approved)

1343

1914

self.send_changedstate()

1344

1345

## D-Bus methods, signals & properties

1346

_interface = "se.recompile.Mandos.Client"

1347

1348

## Interfaces

1349

1350

@dbus_interface_annotations(_interface)

1351

def _foo(self):

1352

return { "org.freedesktop.DBus.Property.EmitsChangedSignal":

1353

"false"}

1354

1355

## Signals

1356

1915

1916

# D-Bus methods, signals & properties

1917

1918

# Interfaces

1919

1920

# Signals

1921

1357

1922

# CheckerCompleted - signal

1358

1923

@dbus.service.signal(_interface, signature="nxs")

1359

1924

def CheckerCompleted(self, exitcode, waitstatus, command):

1360

1925

"D-Bus signal"

1361

1926

pass

1362

1927

1363

1928

# CheckerStarted - signal

1364

1929

@dbus.service.signal(_interface, signature="s")

1365

1930

def CheckerStarted(self, command):

1366

1931

"D-Bus signal"

1367

1932

pass

1368

1933

1369

1934

# PropertyChanged - signal

1935

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})

1370

1936

@dbus.service.signal(_interface, signature="sv")

1371

1937

def PropertyChanged(self, property, value):

1372

1938

"D-Bus signal"

1373

1939

pass

1374

1940

1375

1941

# GotSecret - signal

1376

1942

@dbus.service.signal(_interface)

1377

1943

def GotSecret(self):

1380

1946

server to mandos-client

1381

1947

"""

1382

1948

pass

1383

1949

1384

1950

# Rejected - signal

1385

1951

@dbus.service.signal(_interface, signature="s")

1386

1952

def Rejected(self, reason):

1387

1953

"D-Bus signal"

1388

1954

pass

1389

1955

1390

1956

# NeedApproval - signal

1391

1957

@dbus.service.signal(_interface, signature="tb")

1392

1958

def NeedApproval(self, timeout, default):

1393

1959

"D-Bus signal"

1394

1960

return self.need_approval()

1395

1396

## Methods

1397

1961

1962

# Methods

1963

1398

1964

# Approve - method

1399

1965

@dbus.service.method(_interface, in_signature="b")

1400

1966

def Approve(self, value):

1401

1967

self.approve(value)

1402

1968

1403

1969

# CheckedOK - method

1404

1970

@dbus.service.method(_interface)

1405

1971

def CheckedOK(self):

1406

1972

self.checked_ok()

1407

1973

1408

1974

# Enable - method

1975

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})

1409

1976

@dbus.service.method(_interface)

1410

1977

def Enable(self):

1411

1978

"D-Bus method"

1412

1979

self.enable()

1413

1980

1414

1981

# StartChecker - method

1982

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})

1415

1983

@dbus.service.method(_interface)

1416

1984

def StartChecker(self):

1417

1985

"D-Bus method"

1418

1986

self.start_checker()

1419

1987

1420

1988

# Disable - method

1989

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})

1421

1990

@dbus.service.method(_interface)

1422

1991

def Disable(self):

1423

1992

"D-Bus method"

1424

1993

self.disable()

1425

1994

1426

1995

# StopChecker - method

1996

@dbus_annotations({"org.freedesktop.DBus.Deprecated": "true"})

1427

1997

@dbus.service.method(_interface)

1428

1998

def StopChecker(self):

1429

1999

self.stop_checker()

1430

1431

## Properties

1432

2000

2001

# Properties

2002

1433

2003

# ApprovalPending - property

1434

2004

@dbus_service_property(_interface, signature="b", access="read")

1435

2005

def ApprovalPending_dbus_property(self):

1436

2006

return dbus.Boolean(bool(self.approvals_pending))

1437

2007

1438

2008

# ApprovedByDefault - property

1439

@dbus_service_property(_interface, signature="b",

2009

@dbus_service_property(_interface,

2010

signature="b",

1440

2011

access="readwrite")

1441

2012

def ApprovedByDefault_dbus_property(self, value=None):

1442

2013

if value is None: # get

1443

2014

return dbus.Boolean(self.approved_by_default)

1444

2015

self.approved_by_default = bool(value)

1445

2016

1446

2017

# ApprovalDelay - property

1447

@dbus_service_property(_interface, signature="t",

2018

@dbus_service_property(_interface,

2019

signature="t",

1448

2020

access="readwrite")

1449

2021

def ApprovalDelay_dbus_property(self, value=None):

1450

2022

if value is None: # get

1451

return dbus.UInt64(self.approval_delay_milliseconds())

2023

return dbus.UInt64(self.approval_delay.total_seconds()

2024

* 1000)

1452

2025

self.approval_delay = datetime.timedelta(0, 0, 0, value)

1453

2026

1454

2027

# ApprovalDuration - property

1455

@dbus_service_property(_interface, signature="t",

2028

@dbus_service_property(_interface,

2029

signature="t",

1456

2030

access="readwrite")

1457

2031

def ApprovalDuration_dbus_property(self, value=None):

1458

2032

if value is None: # get

1459

return dbus.UInt64(timedelta_to_milliseconds(

1460

self.approval_duration))

2033

return dbus.UInt64(self.approval_duration.total_seconds()

2034

* 1000)

1461

2035

self.approval_duration = datetime.timedelta(0, 0, 0, value)

1462

2036

1463

2037

# Name - property

2038

@dbus_annotations(

2039

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})

1464

2040

@dbus_service_property(_interface, signature="s", access="read")

1465

2041

def Name_dbus_property(self):

1466

2042

return dbus.String(self.name)

1467

2043

2044

# KeyID - property

2045

@dbus_annotations(

2046

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})

2047

@dbus_service_property(_interface, signature="s", access="read")

2048

def KeyID_dbus_property(self):

2049

return dbus.String(self.key_id)

2050

1468

2051

# Fingerprint - property

2052

@dbus_annotations(

2053

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})

1469

2054

@dbus_service_property(_interface, signature="s", access="read")

1470

2055

def Fingerprint_dbus_property(self):

1471

2056

return dbus.String(self.fingerprint)

1472

2057

1473

2058

# Host - property

1474

@dbus_service_property(_interface, signature="s",

2059

@dbus_service_property(_interface,

2060

signature="s",

1475

2061

access="readwrite")

1476

2062

def Host_dbus_property(self, value=None):

1477

2063

if value is None: # get

1478

2064

return dbus.String(self.host)

1479

self.host = unicode(value)

1480

2065

self.host = str(value)

2066

1481

2067

# Created - property

2068

@dbus_annotations(

2069

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const"})

1482

2070

@dbus_service_property(_interface, signature="s", access="read")

1483

2071

def Created_dbus_property(self):

1484

2072

return datetime_to_dbus(self.created)

1485

2073

1486

2074

# LastEnabled - property

1487

2075

@dbus_service_property(_interface, signature="s", access="read")

1488

2076

def LastEnabled_dbus_property(self):

1489

2077

return datetime_to_dbus(self.last_enabled)

1490

2078

1491

2079

# Enabled - property

1492

@dbus_service_property(_interface, signature="b",

2080

@dbus_service_property(_interface,

2081

signature="b",

1493

2082

access="readwrite")

1494

2083

def Enabled_dbus_property(self, value=None):

1495

2084

if value is None: # get

1498

2087

self.enable()

1499

2088

else:

1500

2089

self.disable()

1501

2090

1502

2091

# LastCheckedOK - property

1503

@dbus_service_property(_interface, signature="s",

2092

@dbus_service_property(_interface,

2093

signature="s",

1504

2094

access="readwrite")

1505

2095

def LastCheckedOK_dbus_property(self, value=None):

1506

2096

if value is not None:

1507

2097

self.checked_ok()

1508

2098

return

1509

2099

return datetime_to_dbus(self.last_checked_ok)

1510

2100

1511

2101

# LastCheckerStatus - property

1512

@dbus_service_property(_interface, signature="n",

1513

access="read")

2102

@dbus_service_property(_interface, signature="n", access="read")

1514

2103

def LastCheckerStatus_dbus_property(self):

1515

2104

return dbus.Int16(self.last_checker_status)

1516

2105

1517

2106

# Expires - property

1518

2107

@dbus_service_property(_interface, signature="s", access="read")

1519

2108

def Expires_dbus_property(self):

1520

2109

return datetime_to_dbus(self.expires)

1521

2110

1522

2111

# LastApprovalRequest - property

1523

2112

@dbus_service_property(_interface, signature="s", access="read")

1524

2113

def LastApprovalRequest_dbus_property(self):

1525

2114

return datetime_to_dbus(self.last_approval_request)

1526

2115

1527

2116

# Timeout - property

1528

@dbus_service_property(_interface, signature="t",

2117

@dbus_service_property(_interface,

2118

signature="t",

1529

2119

access="readwrite")

1530

2120

def Timeout_dbus_property(self, value=None):

1531

2121

if value is None: # get

1532

return dbus.UInt64(self.timeout_milliseconds())

2122

return dbus.UInt64(self.timeout.total_seconds() * 1000)

1533

2123

old_timeout = self.timeout

1534

2124

self.timeout = datetime.timedelta(0, 0, 0, value)

1535

2125

# Reschedule disabling

1543

2133

if (getattr(self, "disable_initiator_tag", None)

1544

2134

is None):

1545

2135

return

1546

gobject.source_remove(self.disable_initiator_tag)

1547

self.disable_initiator_tag = (

1548

gobject.timeout_add(

1549

timedelta_to_milliseconds(self.expires - now),

1550

self.disable))

1551

2136

GLib.source_remove(self.disable_initiator_tag)

2137

self.disable_initiator_tag = GLib.timeout_add(

2138

int((self.expires - now).total_seconds() * 1000),

2139

self.disable)

2140

1552

2141

# ExtendedTimeout - property

1553

@dbus_service_property(_interface, signature="t",

2142

@dbus_service_property(_interface,

2143

signature="t",

1554

2144

access="readwrite")

1555

2145

def ExtendedTimeout_dbus_property(self, value=None):

1556

2146

if value is None: # get

1557

return dbus.UInt64(self.extended_timeout_milliseconds())

2147

return dbus.UInt64(self.extended_timeout.total_seconds()

2148

* 1000)

1558

2149

self.extended_timeout = datetime.timedelta(0, 0, 0, value)

1559

2150

1560

2151

# Interval - property

1561

@dbus_service_property(_interface, signature="t",

2152

@dbus_service_property(_interface,

2153

signature="t",

1562

2154

access="readwrite")

1563

2155

def Interval_dbus_property(self, value=None):

1564

2156

if value is None: # get

1565

return dbus.UInt64(self.interval_milliseconds())

2157

return dbus.UInt64(self.interval.total_seconds() * 1000)

1566

2158

self.interval = datetime.timedelta(0, 0, 0, value)

1567

2159

if getattr(self, "checker_initiator_tag", None) is None:

1568

2160

return

1569

2161

if self.enabled:

1570

2162

# Reschedule checker run

1571

gobject.source_remove(self.checker_initiator_tag)

1572

self.checker_initiator_tag = (gobject.timeout_add

1573

(value, self.start_checker))

1574

self.start_checker() # Start one now, too

1575

2163

GLib.source_remove(self.checker_initiator_tag)

2164

self.checker_initiator_tag = GLib.timeout_add(

2165

value, self.start_checker)

2166

self.start_checker() # Start one now, too

2167

1576

2168

# Checker - property

1577

@dbus_service_property(_interface, signature="s",

2169

@dbus_service_property(_interface,

2170

signature="s",

1578

2171

access="readwrite")

1579

2172

def Checker_dbus_property(self, value=None):

1580

2173

if value is None: # get

1581

2174

return dbus.String(self.checker_command)

1582

self.checker_command = unicode(value)

1583

2175

self.checker_command = str(value)

2176

1584

2177

# CheckerRunning - property

1585

@dbus_service_property(_interface, signature="b",

2178

@dbus_service_property(_interface,

2179

signature="b",

1586

2180

access="readwrite")

1587

2181

def CheckerRunning_dbus_property(self, value=None):

1588

2182

if value is None: # get

1591

2185

self.start_checker()

1592

2186

else:

1593

2187

self.stop_checker()

1594

2188

1595

2189

# ObjectPath - property

2190

@dbus_annotations(

2191

{"org.freedesktop.DBus.Property.EmitsChangedSignal": "const",

2192

"org.freedesktop.DBus.Deprecated": "true"})

1596

2193

@dbus_service_property(_interface, signature="o", access="read")

1597

2194

def ObjectPath_dbus_property(self):

1598

return self.dbus_object_path # is already a dbus.ObjectPath

1599

2195

return self.dbus_object_path # is already a dbus.ObjectPath

2196

1600

2197

# Secret = property

1601

@dbus_service_property(_interface, signature="ay",

1602

access="write", byte_arrays=True)

2198

@dbus_annotations(

2199

{"org.freedesktop.DBus.Property.EmitsChangedSignal":

2200

"invalidates"})

2201

@dbus_service_property(_interface,

2202

signature="ay",

2203

access="write",

2204

byte_arrays=True)

1603

2205

def Secret_dbus_property(self, value):

1604

self.secret = str(value)

1605

2206

self.secret = bytes(value)

2207

1606

2208

del _interface

1607

2209

1608

2210

1609

2211

class ProxyClient(object):

1610

def __init__(self, child_pipe, fpr, address):

2212

def __init__(self, child_pipe, key_id, fpr, address):

1611

2213

self._pipe = child_pipe

1612

self._pipe.send(('init', fpr, address))

2214

self._pipe.send(('init', key_id, fpr, address))

1613

2215

if not self._pipe.recv():

1614

raise KeyError()

1615

2216

raise KeyError(key_id or fpr)

2217

1616

2218

def __getattribute__(self, name):

1617

2219

if name == '_pipe':

1618

2220

return super(ProxyClient, self).__getattribute__(name)

1621

2223

if data[0] == 'data':

1622

2224

return data[1]

1623

2225

if data[0] == 'function':

2226

1624

2227

def func(*args, **kwargs):

1625

2228

self._pipe.send(('funcall', name, args, kwargs))

1626

2229

return self._pipe.recv()[1]

2230

1627

2231

return func

1628

2232

1629

2233

def __setattr__(self, name, value):

1630

2234

if name == '_pipe':

1631

2235

return super(ProxyClient, self).__setattr__(name, value)

1634

2238

1635

2239

class ClientHandler(socketserver.BaseRequestHandler, object):

1636

2240

"""A class to handle client connections.

1637

2241

1638

2242

Instantiated once for each connection to handle it.

1639

2243

Note: This will run in its own forked process."""

1640

2244

1641

2245

def handle(self):

1642

2246

with contextlib.closing(self.server.child_pipe) as child_pipe:

1643

2247

logger.info("TCP connection from: %s",

1644

unicode(self.client_address))

2248

str(self.client_address))

1645

2249

logger.debug("Pipe FD: %d",

1646

2250

self.server.child_pipe.fileno())

1647

1648

session = (gnutls.connection

1649

.ClientSession(self.request,

1650

gnutls.connection

1651

.X509Credentials()))

1652

1653

# Note: gnutls.connection.X509Credentials is really a

1654

# generic GnuTLS certificate credentials object so long as

1655

# no X.509 keys are added to it. Therefore, we can use it

1656

# here despite using OpenPGP certificates.

1657

1658

#priority = ':'.join(("NONE", "+VERS-TLS1.1",

1659

# "+AES-256-CBC", "+SHA1",

1660

# "+COMP-NULL", "+CTYPE-OPENPGP",

1661

# "+DHE-DSS"))

2251

2252

session = gnutls.ClientSession(self.request)

2253

2254

# priority = ':'.join(("NONE", "+VERS-TLS1.1",

2255

# "+AES-256-CBC", "+SHA1",

2256

# "+COMP-NULL", "+CTYPE-OPENPGP",

2257

# "+DHE-DSS"))

1662

2258

# Use a fallback default, since this MUST be set.

1663

2259

priority = self.server.gnutls_priority

1664

2260

if priority is None:

1665

2261

priority = "NORMAL"

1666

(gnutls.library.functions

1667

.gnutls_priority_set_direct(session._c_object,

1668

priority, None))

1669

2262

gnutls.priority_set_direct(session._c_object,

2263

priority.encode("utf-8"),

2264

None)

2265

1670

2266

# Start communication using the Mandos protocol

1671

2267

# Get protocol number

1672

2268

line = self.request.makefile().readline()

1673

2269

logger.debug("Protocol version: %r", line)

1674

2270

try:

1675

2271

if int(line.strip().split()[0]) > 1:

1676

raise RuntimeError

2272

raise RuntimeError(line)

1677

2273

except (ValueError, IndexError, RuntimeError) as error:

1678

2274

logger.error("Unknown protocol version: %s", error)

1679

2275

return

1680

2276

1681

2277

# Start GnuTLS connection

1682

2278

try:

1683

2279

session.handshake()

1684

except gnutls.errors.GNUTLSError as error:

2280

except gnutls.Error as error:

1685

2281

logger.warning("Handshake failed: %s", error)

1686

2282

# Do not run session.bye() here: the session is not

1687

2283

# established. Just abandon the request.

1688

2284

return

1689

2285

logger.debug("Handshake succeeded")

1690

2286

1691

2287

approval_required = False

1692

2288

try:

1693

try:

1694

fpr = self.fingerprint(self.peer_certificate

1695

(session))

1696

except (TypeError,

1697

gnutls.errors.GNUTLSError) as error:

1698

logger.warning("Bad certificate: %s", error)

1699

return

1700

logger.debug("Fingerprint: %s", fpr)

1701

1702

try:

1703

client = ProxyClient(child_pipe, fpr,

2289

if gnutls.has_rawpk:

2290

fpr = ""

2291

try:

2292

key_id = self.key_id(

2293

self.peer_certificate(session))

2294

except (TypeError, gnutls.Error) as error:

2295

logger.warning("Bad certificate: %s", error)

2296

return

2297

logger.debug("Key ID: %s", key_id)

2298

2299

else:

2300

key_id = ""

2301

try:

2302

fpr = self.fingerprint(

2303

self.peer_certificate(session))

2304

except (TypeError, gnutls.Error) as error:

2305

logger.warning("Bad certificate: %s", error)

2306

return

2307

logger.debug("Fingerprint: %s", fpr)

2308

2309

try:

2310

client = ProxyClient(child_pipe, key_id, fpr,

1704

2311

self.client_address)

1705

2312

except KeyError:

1706

2313

return

1707

2314

1708

2315

if client.approval_delay:

1709

2316

delay = client.approval_delay

1710

2317

client.approvals_pending += 1

1711

2318

approval_required = True

1712

2319

1713

2320

while True:

1714

2321

if not client.enabled:

1715

2322

logger.info("Client %s is disabled",

1716

client.name)

2323

client.name)

1717

2324

if self.server.use_dbus:

1718

2325

# Emit D-Bus signal

1719

2326

client.Rejected("Disabled")

1720

2327

return

1721

2328

1722

2329

if client.approved or not client.approval_delay:

1723

#We are approved or approval is disabled

2330

# We are approved or approval is disabled

1724

2331

break

1725

2332

elif client.approved is None:

1726

2333

logger.info("Client %s needs approval",

1728

2335

if self.server.use_dbus:

1729

2336

# Emit D-Bus signal

1730

2337

client.NeedApproval(

1731

client.approval_delay_milliseconds(),

1732

client.approved_by_default)

2338

client.approval_delay.total_seconds()

2339

* 1000, client.approved_by_default)

1733

2340

else:

1734

2341

logger.warning("Client %s was not approved",

1735

2342

client.name)

1737

2344

# Emit D-Bus signal

1738

2345

client.Rejected("Denied")

1739

2346

return

1740

1741

#wait until timeout or approved

2347

2348

# wait until timeout or approved

1742

2349

time = datetime.datetime.now()

1743

2350

client.changedstate.acquire()

1744

client.changedstate.wait(

1745

float(timedelta_to_milliseconds(delay)

1746

/ 1000))

2351

client.changedstate.wait(delay.total_seconds())

1747

2352

client.changedstate.release()

1748

2353

time2 = datetime.datetime.now()

1749

2354

if (time2 - time) >= delay:

1759

2364

break

1760

2365

else:

1761

2366

delay -= time2 - time

1762

1763

sent_size = 0

1764

while sent_size < len(client.secret):

1765

try:

1766

sent = session.send(client.secret[sent_size:])

1767

except gnutls.errors.GNUTLSError as error:

1768

logger.warning("gnutls send failed",

1769

exc_info=error)

1770

return

1771

logger.debug("Sent: %d, remaining: %d",

1772

sent, len(client.secret)

1773

- (sent_size + sent))

1774

sent_size += sent

1775

2367

2368

try:

2369

session.send(client.secret)

2370

except gnutls.Error as error:

2371

logger.warning("gnutls send failed",

2372

exc_info=error)

2373

return

2374

1776

2375

logger.info("Sending secret to %s", client.name)

1777

2376

# bump the timeout using extended_timeout

1778

2377

client.bump_timeout(client.extended_timeout)

1779

2378

if self.server.use_dbus:

1780

2379

# Emit D-Bus signal

1781

2380

client.GotSecret()

1782

2381

1783

2382

finally:

1784

2383

if approval_required:

1785

2384

client.approvals_pending -= 1

1786

2385

try:

1787

2386

session.bye()

1788

except gnutls.errors.GNUTLSError as error:

2387

except gnutls.Error as error:

1789

2388

logger.warning("GnuTLS bye failed",

1790

2389

exc_info=error)

1791

2390

1792

2391

@staticmethod

1793

2392

def peer_certificate(session):

1794

"Return the peer's OpenPGP certificate as a bytestring"

1795

# If not an OpenPGP certificate...

1796

if (gnutls.library.functions

1797

.gnutls_certificate_type_get(session._c_object)

1798

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1799

# ...do the normal thing

1800

return session.peer_certificate

2393

"Return the peer's certificate as a bytestring"

2394

try:

2395

cert_type = gnutls.certificate_type_get2(session._c_object,

2396

gnutls.CTYPE_PEERS)

2397

except AttributeError:

2398

cert_type = gnutls.certificate_type_get(session._c_object)

2399

if gnutls.has_rawpk:

2400

valid_cert_types = frozenset((gnutls.CRT_RAWPK,))

2401

else:

2402

valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))

2403

# If not a valid certificate type...

2404

if cert_type not in valid_cert_types:

2405

logger.info("Cert type %r not in %r", cert_type,

2406

valid_cert_types)

2407

# ...return invalid data

2408

return b""

1801

2409

list_size = ctypes.c_uint(1)

1802

cert_list = (gnutls.library.functions

1803

.gnutls_certificate_get_peers

2410

cert_list = (gnutls.certificate_get_peers

1804

2411

(session._c_object, ctypes.byref(list_size)))

1805

2412

if not bool(cert_list) and list_size.value != 0:

1806

raise gnutls.errors.GNUTLSError("error getting peer"

1807

" certificate")

2413

raise gnutls.Error("error getting peer certificate")

1808

2414

if list_size.value == 0:

1809

2415

return None

1810

2416

cert = cert_list[0]

1811

2417

return ctypes.string_at(cert.data, cert.size)

1812

2418

2419

@staticmethod

2420

def key_id(certificate):

2421

"Convert a certificate bytestring to a hexdigit key ID"

2422

# New GnuTLS "datum" with the public key

2423

datum = gnutls.datum_t(

2424

ctypes.cast(ctypes.c_char_p(certificate),

2425

ctypes.POINTER(ctypes.c_ubyte)),

2426

ctypes.c_uint(len(certificate)))

2427

# XXX all these need to be created in the gnutls "module"

2428

# New empty GnuTLS certificate

2429

pubkey = gnutls.pubkey_t()

2430

gnutls.pubkey_init(ctypes.byref(pubkey))

2431

# Import the raw public key into the certificate

2432

gnutls.pubkey_import(pubkey,

2433

ctypes.byref(datum),

2434

gnutls.X509_FMT_DER)

2435

# New buffer for the key ID

2436

buf = ctypes.create_string_buffer(32)

2437

buf_len = ctypes.c_size_t(len(buf))

2438

# Get the key ID from the raw public key into the buffer

2439

gnutls.pubkey_get_key_id(pubkey,

2440

gnutls.KEYID_USE_SHA256,

2441

ctypes.cast(ctypes.byref(buf),

2442

ctypes.POINTER(ctypes.c_ubyte)),

2443

ctypes.byref(buf_len))

2444

# Deinit the certificate

2445

gnutls.pubkey_deinit(pubkey)

2446

2447

# Convert the buffer to a Python bytestring

2448

key_id = ctypes.string_at(buf, buf_len.value)

2449

# Convert the bytestring to hexadecimal notation

2450

hex_key_id = binascii.hexlify(key_id).upper()

2451

return hex_key_id

2452

1813

2453

@staticmethod

1814

2454

def fingerprint(openpgp):

1815

2455

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

1816

2456

# New GnuTLS "datum" with the OpenPGP public key

1817

datum = (gnutls.library.types

1818

.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),

1819

ctypes.POINTER

1820

(ctypes.c_ubyte)),

1821

ctypes.c_uint(len(openpgp))))

2457

datum = gnutls.datum_t(

2458

ctypes.cast(ctypes.c_char_p(openpgp),

2459

ctypes.POINTER(ctypes.c_ubyte)),

2460

ctypes.c_uint(len(openpgp)))

1822

2461

# New empty GnuTLS certificate

1823

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1824

(gnutls.library.functions

1825

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

2462

crt = gnutls.openpgp_crt_t()

2463

gnutls.openpgp_crt_init(ctypes.byref(crt))

1826

2464

# Import the OpenPGP public key into the certificate

1827

(gnutls.library.functions

1828

.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),

1829

gnutls.library.constants

1830

.GNUTLS_OPENPGP_FMT_RAW))

2465

gnutls.openpgp_crt_import(crt, ctypes.byref(datum),

2466

gnutls.OPENPGP_FMT_RAW)

1831

2467

# Verify the self signature in the key

1832

2468

crtverify = ctypes.c_uint()

1833

(gnutls.library.functions

1834

.gnutls_openpgp_crt_verify_self(crt, 0,

1835

ctypes.byref(crtverify)))

2469

gnutls.openpgp_crt_verify_self(crt, 0,

2470

ctypes.byref(crtverify))

1836

2471

if crtverify.value != 0:

1837

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1838

raise (gnutls.errors.CertificateSecurityError

1839

("Verify failed"))

2472

gnutls.openpgp_crt_deinit(crt)

2473

raise gnutls.CertificateSecurityError(code

2474

=crtverify.value)

1840

2475

# New buffer for the fingerprint

1841

2476

buf = ctypes.create_string_buffer(20)

1842

2477

buf_len = ctypes.c_size_t()

1843

2478

# Get the fingerprint from the certificate into the buffer

1844

(gnutls.library.functions

1845

.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),

1846

ctypes.byref(buf_len)))

2479

gnutls.openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),

2480

ctypes.byref(buf_len))

1847

2481

# Deinit the certificate

1848

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2482

gnutls.openpgp_crt_deinit(crt)

1849

2483

# Convert the buffer to a Python bytestring

1850

2484

fpr = ctypes.string_at(buf, buf_len.value)

1851

2485

# Convert the bytestring to hexadecimal notation

1855

2489

1856

2490

class MultiprocessingMixIn(object):

1857

2491

"""Like socketserver.ThreadingMixIn, but with multiprocessing"""

2492

1858

2493

def sub_process_main(self, request, address):

1859

2494

try:

1860

2495

self.finish_request(request, address)

1861

2496

except Exception:

1862

2497

self.handle_error(request, address)

1863

2498

self.close_request(request)

1864

2499

1865

2500

def process_request(self, request, address):

1866

2501

"""Start a new process to process the request."""

1867

proc = multiprocessing.Process(target = self.sub_process_main,

1868

args = (request, address))

2502

proc = multiprocessing.Process(target=self.sub_process_main,

2503

args=(request, address))

1869

2504

proc.start()

1870

2505

return proc

1871

2506

1872

2507

1873

2508

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1874

2509

""" adds a pipe to the MixIn """

2510

1875

2511

def process_request(self, request, client_address):

1876

2512

"""Overrides and wraps the original process_request().

1877

2513

1878

2514

This function creates a new pipe in self.pipe

1879

2515

"""

1880

2516

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1881

2517

1882

2518

proc = MultiprocessingMixIn.process_request(self, request,

1883

2519

client_address)

1884

2520

self.child_pipe.close()

1885

2521

self.add_pipe(parent_pipe, proc)

1886

2522

1887

2523

def add_pipe(self, parent_pipe, proc):

1888

2524

"""Dummy function; override as necessary"""

1889

raise NotImplementedError

2525

raise NotImplementedError()

1890

2526

1891

2527

1892

2528

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1893

2529

socketserver.TCPServer, object):

1894

2530

"""IPv6-capable TCP server. Accepts 'None' as address and/or port

1895

2531

1896

2532

Attributes:

1897

2533

enabled: Boolean; whether this server is activated yet

1898

2534

interface: None or a network interface name (string)

1899

2535

use_ipv6: Boolean; to use IPv6 or not

1900

2536

"""

2537

1901

2538

def __init__(self, server_address, RequestHandlerClass,

1902

interface=None, use_ipv6=True, socketfd=None):

2539

interface=None,

2540

use_ipv6=True,

2541

socketfd=None):

1903

2542

"""If socketfd is set, use that file descriptor instead of

1904

2543

creating a new one with socket.socket().

1905

2544

"""

1911

2550

self.socketfd = socketfd

1912

2551

# Save the original socket.socket() function

1913

2552

self.socket_socket = socket.socket

2553

1914

2554

# To implement --socket, we monkey patch socket.socket.

1915

#

2555

#

1916

2556

# (When socketserver.TCPServer is a new-style class, we

1917

2557

# could make self.socket into a property instead of monkey

1918

2558

# patching socket.socket.)

1919

#

2559

#

1920

2560

# Create a one-time-only replacement for socket.socket()

1921

2561

@functools.wraps(socket.socket)

1922

2562

def socket_wrapper(*args, **kwargs):

1934

2574

# socket_wrapper(), if socketfd was set.

1935

2575

socketserver.TCPServer.__init__(self, server_address,

1936

2576

RequestHandlerClass)

1937

2577

1938

2578

def server_bind(self):

1939

2579

"""This overrides the normal server_bind() function

1940

2580

to bind to an interface if one was specified, and also NOT to

1941

2581

bind to an address or port if they were not specified."""

2582

global SO_BINDTODEVICE

1942

2583

if self.interface is not None:

1943

2584

if SO_BINDTODEVICE is None:

1944

logger.error("SO_BINDTODEVICE does not exist;"

1945

" cannot bind to interface %s",

1946

self.interface)

1947

else:

1948

try:

1949

self.socket.setsockopt(socket.SOL_SOCKET,

1950

SO_BINDTODEVICE,

1951

str(self.interface + '\0'))

1952

except socket.error as error:

1953

if error.errno == errno.EPERM:

1954

logger.error("No permission to bind to"

1955

" interface %s", self.interface)

1956

elif error.errno == errno.ENOPROTOOPT:

1957

logger.error("SO_BINDTODEVICE not available;"

1958

" cannot bind to interface %s",

1959

self.interface)

1960

elif error.errno == errno.ENODEV:

1961

logger.error("Interface %s does not exist,"

1962

" cannot bind", self.interface)

1963

else:

1964

raise

2585

# Fall back to a hard-coded value which seems to be

2586

# common enough.

2587

logger.warning("SO_BINDTODEVICE not found, trying 25")

2588

SO_BINDTODEVICE = 25

2589

try:

2590

self.socket.setsockopt(

2591

socket.SOL_SOCKET, SO_BINDTODEVICE,

2592

(self.interface + "\0").encode("utf-8"))

2593

except socket.error as error:

2594

if error.errno == errno.EPERM:

2595

logger.error("No permission to bind to"

2596

" interface %s", self.interface)

2597

elif error.errno == errno.ENOPROTOOPT:

2598

logger.error("SO_BINDTODEVICE not available;"

2599

" cannot bind to interface %s",

2600

self.interface)

2601

elif error.errno == errno.ENODEV:

2602

logger.error("Interface %s does not exist,"

2603

" cannot bind", self.interface)

2604

else:

2605

raise

1965

2606

# Only bind(2) the socket if we really need to.

1966

2607

if self.server_address[0] or self.server_address[1]:

2608

if self.server_address[1]:

2609

self.allow_reuse_address = True

1967

2610

if not self.server_address[0]:

1968

2611

if self.address_family == socket.AF_INET6:

1969

any_address = "::" # in6addr_any

2612

any_address = "::" # in6addr_any

1970

2613

else:

1971

any_address = socket.INADDR_ANY

2614

any_address = "0.0.0.0" # INADDR_ANY

1972

2615

self.server_address = (any_address,

1973

2616

self.server_address[1])

1974

2617

elif not self.server_address[1]:

1975

self.server_address = (self.server_address[0],

1976

0)

2618

self.server_address = (self.server_address[0], 0)

1977

2619

# if self.interface:

1978

2620

# self.server_address = (self.server_address[0],

1979

2621

# 0, # port

1985

2627

1986

2628

class MandosServer(IPv6_TCPServer):

1987

2629

"""Mandos server.

1988

2630

1989

2631

Attributes:

1990

2632

clients: set of Client objects

1991

2633

gnutls_priority GnuTLS priority string

1992

2634

use_dbus: Boolean; to emit D-Bus signals or not

1993

1994

Assumes a gobject.MainLoop event loop.

2635

2636

Assumes a GLib.MainLoop event loop.

1995

2637

"""

2638

1996

2639

def __init__(self, server_address, RequestHandlerClass,

1997

interface=None, use_ipv6=True, clients=None,

1998

gnutls_priority=None, use_dbus=True, socketfd=None):

2640

interface=None,

2641

use_ipv6=True,

2642

clients=None,

2643

gnutls_priority=None,

2644

use_dbus=True,

2645

socketfd=None):

1999

2646

self.enabled = False

2000

2647

self.clients = clients

2001

2648

if self.clients is None:

2004

2651

self.gnutls_priority = gnutls_priority

2005

2652

IPv6_TCPServer.__init__(self, server_address,

2006

2653

RequestHandlerClass,

2007

interface = interface,

2008

use_ipv6 = use_ipv6,

2009

socketfd = socketfd)

2654

interface=interface,

2655

use_ipv6=use_ipv6,

2656

socketfd=socketfd)

2657

2010

2658

def server_activate(self):

2011

2659

if self.enabled:

2012

2660

return socketserver.TCPServer.server_activate(self)

2013

2661

2014

2662

def enable(self):

2015

2663

self.enabled = True

2016

2664

2017

2665

def add_pipe(self, parent_pipe, proc):

2018

2666

# Call "handle_ipc" for both data and EOF events

2019

gobject.io_add_watch(parent_pipe.fileno(),

2020

gobject.IO_IN | gobject.IO_HUP,

2021

functools.partial(self.handle_ipc,

2022

parent_pipe =

2023

parent_pipe,

2024

proc = proc))

2025

2026

def handle_ipc(self, source, condition, parent_pipe=None,

2027

proc = None, client_object=None):

2667

GLib.io_add_watch(

2668

parent_pipe.fileno(),

2669

GLib.IO_IN | GLib.IO_HUP,

2670

functools.partial(self.handle_ipc,

2671

parent_pipe=parent_pipe,

2672

proc=proc))

2673

2674

def handle_ipc(self, source, condition,

2675

parent_pipe=None,

2676

proc=None,

2677

client_object=None):

2028

2678

# error, or the other end of multiprocessing.Pipe has closed

2029

if condition & (gobject.IO_ERR | gobject.IO_HUP):

2679

if condition & (GLib.IO_ERR | GLib.IO_HUP):

2030

2680

# Wait for other process to exit

2031

2681

proc.join()

2032

2682

return False

2033

2683

2034

2684

# Read a request from the child

2035

2685

request = parent_pipe.recv()

2036

2686

command = request[0]

2037

2687

2038

2688

if command == 'init':

2039

fpr = request[1]

2040

address = request[2]

2041

2042

for c in self.clients.itervalues():

2043

if c.fingerprint == fpr:

2689

key_id = request[1].decode("ascii")

2690

fpr = request[2].decode("ascii")

2691

address = request[3]

2692

2693

for c in self.clients.values():

2694

if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":

2695

continue

2696

if key_id and c.key_id == key_id:

2697

client = c

2698

break

2699

if fpr and c.fingerprint == fpr:

2044

2700

client = c

2045

2701

break

2046

2702

else:

2047

logger.info("Client not found for fingerprint: %s, ad"

2048

"dress: %s", fpr, address)

2703

logger.info("Client not found for key ID: %s, address"

2704

": %s", key_id or fpr, address)

2049

2705

if self.use_dbus:

2050

2706

# Emit D-Bus signal

2051

mandos_dbus_service.ClientNotFound(fpr,

2707

mandos_dbus_service.ClientNotFound(key_id or fpr,

2052

2708

address[0])

2053

2709

parent_pipe.send(False)

2054

2710

return False

2055

2056

gobject.io_add_watch(parent_pipe.fileno(),

2057

gobject.IO_IN | gobject.IO_HUP,

2058

functools.partial(self.handle_ipc,

2059

parent_pipe =

2060

parent_pipe,

2061

proc = proc,

2062

client_object =

2063

client))

2711

2712

GLib.io_add_watch(

2713

parent_pipe.fileno(),

2714

GLib.IO_IN | GLib.IO_HUP,

2715

functools.partial(self.handle_ipc,

2716

parent_pipe=parent_pipe,

2717

proc=proc,

2718

client_object=client))

2064

2719

parent_pipe.send(True)

2065

2720

# remove the old hook in favor of the new above hook on

2066

2721

# same fileno

2069

2724

funcname = request[1]

2070

2725

args = request[2]

2071

2726

kwargs = request[3]

2072

2727

2073

2728

parent_pipe.send(('data', getattr(client_object,

2074

2729

funcname)(*args,

2075

**kwargs)))

2076

2730

**kwargs)))

2731

2077

2732

if command == 'getattr':

2078

2733

attrname = request[1]

2079

if callable(client_object.__getattribute__(attrname)):

2080

parent_pipe.send(('function',))

2734

if isinstance(client_object.__getattribute__(attrname),

2735

collections.Callable):

2736

parent_pipe.send(('function', ))

2081

2737

else:

2082

parent_pipe.send(('data', client_object

2083

.__getattribute__(attrname)))

2084

2738

parent_pipe.send((

2739

'data', client_object.__getattribute__(attrname)))

2740

2085

2741

if command == 'setattr':

2086

2742

attrname = request[1]

2087

2743

value = request[2]

2088

2744

setattr(client_object, attrname, value)

2089

2745

2090

2746

return True

2091

2747

2092

2748

2749

def rfc3339_duration_to_delta(duration):

2750

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

2751

2752

>>> rfc3339_duration_to_delta("P7D")

2753

datetime.timedelta(7)

2754

>>> rfc3339_duration_to_delta("PT60S")

2755

datetime.timedelta(0, 60)

2756

>>> rfc3339_duration_to_delta("PT60M")

2757

datetime.timedelta(0, 3600)

2758

>>> rfc3339_duration_to_delta("PT24H")

2759

datetime.timedelta(1)

2760

>>> rfc3339_duration_to_delta("P1W")

2761

datetime.timedelta(7)

2762

>>> rfc3339_duration_to_delta("PT5M30S")

2763

datetime.timedelta(0, 330)

2764

>>> rfc3339_duration_to_delta("P1DT3M20S")

2765

datetime.timedelta(1, 200)

2766

"""

2767

2768

# Parsing an RFC 3339 duration with regular expressions is not

2769

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

2770

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

2771

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

2772

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

2773

# avoid excessive use of external libraries.

2774

2775

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

2776

Token = collections.namedtuple("Token", (

2777

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

2778

# a "group" containing digits

2779

"value", # datetime.timedelta or None

2780

"followers")) # Tokens valid after this token

2781

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

2782

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

2783

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

2784

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

2785

datetime.timedelta(seconds=1),

2786

frozenset((token_end, )))

2787

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

2788

datetime.timedelta(minutes=1),

2789

frozenset((token_second, token_end)))

2790

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

2791

datetime.timedelta(hours=1),

2792

frozenset((token_minute, token_end)))

2793

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

2794

None,

2795

frozenset((token_hour, token_minute,

2796

token_second)))

2797

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

2798

datetime.timedelta(days=1),

2799

frozenset((token_time, token_end)))

2800

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

2801

datetime.timedelta(weeks=4),

2802

frozenset((token_day, token_end)))

2803

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

2804

datetime.timedelta(weeks=52),

2805

frozenset((token_month, token_end)))

2806

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

2807

datetime.timedelta(weeks=1),

2808

frozenset((token_end, )))

2809

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

2810

frozenset((token_year, token_month,

2811

token_day, token_time,

2812

token_week)))

2813

# Define starting values:

2814

# Value so far

2815

value = datetime.timedelta()

2816

found_token = None

2817

# Following valid tokens

2818

followers = frozenset((token_duration, ))

2819

# String left to parse

2820

s = duration

2821

# Loop until end token is found

2822

while found_token is not token_end:

2823

# Search for any currently valid tokens

2824

for token in followers:

2825

match = token.regexp.match(s)

2826

if match is not None:

2827

# Token found

2828

if token.value is not None:

2829

# Value found, parse digits

2830

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

2831

# Add to value so far

2832

value += factor * token.value

2833

# Strip token from string

2834

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

2835

# Go to found token

2836

found_token = token

2837

# Set valid next tokens

2838

followers = found_token.followers

2839

break

2840

else:

2841

# No currently valid tokens were found

2842

raise ValueError("Invalid RFC 3339 duration: {!r}"

2843

.format(duration))

2844

# End token found

2845

return value

2846

2847

2093

2848

def string_to_delta(interval):

2094

2849

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

2095

2850

2096

2851

>>> string_to_delta('7d')

2097

2852

datetime.timedelta(7)

2098

2853

>>> string_to_delta('60s')

2106

2861

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

2107

2862

datetime.timedelta(0, 330)

2108

2863

"""

2864

2865

try:

2866

return rfc3339_duration_to_delta(interval)

2867

except ValueError:

2868

pass

2869

2109

2870

timevalue = datetime.timedelta(0)

2110

2871

for s in interval.split():

2111

2872

try:

2112

suffix = unicode(s[-1])

2873

suffix = s[-1]

2113

2874

value = int(s[:-1])

2114

2875

if suffix == "d":

2115

2876

delta = datetime.timedelta(value)

2122

2883

elif suffix == "w":

2123

2884

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

2124

2885

else:

2125

raise ValueError("Unknown suffix {0!r}"

2126

.format(suffix))

2127

except (ValueError, IndexError) as e:

2886

raise ValueError("Unknown suffix {!r}".format(suffix))

2887

except IndexError as e:

2128

2888

raise ValueError(*(e.args))

2129

2889

timevalue += delta

2130

2890

return timevalue

2131

2891

2132

2892

2133

def daemon(nochdir = False, noclose = False):

2893

def daemon(nochdir=False, noclose=False):

2134

2894

"""See daemon(3). Standard BSD Unix function.

2135

2895

2136

2896

This should really exist as os.daemon, but it doesn't (yet)."""

2137

2897

if os.fork():

2138

2898

sys.exit()

2146

2906

null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)

2147

2907

if not stat.S_ISCHR(os.fstat(null).st_mode):

2148

2908

raise OSError(errno.ENODEV,

2149

"{0} not a character device"

2909

"{} not a character device"

2150

2910

.format(os.devnull))

2151

2911

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

2152

2912

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

2156

2916

2157

2917

2158

2918

def main():

2159

2919

2160

2920

##################################################################

2161

2921

# Parsing of options, both command line and config file

2162

2922

2163

2923

parser = argparse.ArgumentParser()

2164

2924

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

2165

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

2925

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

2166

2926

help="show version number and exit")

2167

2927

parser.add_argument("-i", "--interface", metavar="IF",

2168

2928

help="Bind to interface IF")

2174

2934

help="Run self-test")

2175

2935

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

2176

2936

help="Debug mode; run in foreground and log"

2177

" to terminal")

2937

" to terminal", default=None)

2178

2938

parser.add_argument("--debuglevel", metavar="LEVEL",

2179

2939

help="Debug level for stdout output")

2180

2940

parser.add_argument("--priority", help="GnuTLS"

2187

2947

" files")

2188

2948

parser.add_argument("--no-dbus", action="store_false",

2189

2949

dest="use_dbus", help="Do not provide D-Bus"

2190

" system bus interface")

2950

" system bus interface", default=None)

2191

2951

parser.add_argument("--no-ipv6", action="store_false",

2192

dest="use_ipv6", help="Do not use IPv6")

2952

dest="use_ipv6", help="Do not use IPv6",

2953

default=None)

2193

2954

parser.add_argument("--no-restore", action="store_false",

2194

2955

dest="restore", help="Do not restore stored"

2195

" state")

2956

" state", default=None)

2196

2957

parser.add_argument("--socket", type=int,

2197

2958

help="Specify a file descriptor to a network"

2198

2959

" socket to use instead of creating one")

2199

2960

parser.add_argument("--statedir", metavar="DIR",

2200

2961

help="Directory to save/restore state in")

2201

2962

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

2202

help="Run in foreground")

2203

2963

help="Run in foreground", default=None)

2964

parser.add_argument("--no-zeroconf", action="store_false",

2965

dest="zeroconf", help="Do not use Zeroconf",

2966

default=None)

2967

2204

2968

options = parser.parse_args()

2205

2969

2206

2970

if options.check:

2207

2971

import doctest

2208

doctest.testmod()

2209

sys.exit()

2210

2972

fail_count, test_count = doctest.testmod()

2973

sys.exit(os.EX_OK if fail_count == 0 else 1)

2974

2211

2975

# Default values for config file for server-global settings

2212

server_defaults = { "interface": "",

2213

"address": "",

2214

"port": "",

2215

"debug": "False",

2216

"priority":

2217

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",

2218

"servicename": "Mandos",

2219

"use_dbus": "True",

2220

"use_ipv6": "True",

2221

"debuglevel": "",

2222

"restore": "True",

2223

"socket": "",

2224

"statedir": "/var/lib/mandos",

2225

"foreground": "False",

2226

}

2227

2976

if gnutls.has_rawpk:

2977

priority = ("SECURE128:!CTYPE-X.509:+CTYPE-RAWPK:!RSA"

2978

":!VERS-ALL:+VERS-TLS1.3:%PROFILE_ULTRA")

2979

else:

2980

priority = ("SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA"

2981

":+SIGN-DSA-SHA256")

2982

server_defaults = {"interface": "",

2983

"address": "",

2984

"port": "",

2985

"debug": "False",

2986

"priority": priority,

2987

"servicename": "Mandos",

2988

"use_dbus": "True",

2989

"use_ipv6": "True",

2990

"debuglevel": "",

2991

"restore": "True",

2992

"socket": "",

2993

"statedir": "/var/lib/mandos",

2994

"foreground": "False",

2995

"zeroconf": "True",

2996

}

2997

del priority

2998

2228

2999

# Parse config file for server-global settings

2229

3000

server_config = configparser.SafeConfigParser(server_defaults)

2230

3001

del server_defaults

2231

server_config.read(os.path.join(options.configdir,

2232

"mandos.conf"))

3002

server_config.read(os.path.join(options.configdir, "mandos.conf"))

2233

3003

# Convert the SafeConfigParser object to a dict

2234

3004

server_settings = server_config.defaults()

2235

3005

# Use the appropriate methods on the non-string config options

2236

for option in ("debug", "use_dbus", "use_ipv6", "foreground"):

3006

for option in ("debug", "use_dbus", "use_ipv6", "restore",

3007

"foreground", "zeroconf"):

2237

3008

server_settings[option] = server_config.getboolean("DEFAULT",

2238

3009

option)

2239

3010

if server_settings["port"]:

2249

3020

server_settings["socket"] = os.dup(server_settings

2250

3021

["socket"])

2251

3022

del server_config

2252

3023

2253

3024

# Override the settings from the config file with command line

2254

3025

# options, if set.

2255

3026

for option in ("interface", "address", "port", "debug",

2256

"priority", "servicename", "configdir",

2257

"use_dbus", "use_ipv6", "debuglevel", "restore",

2258

"statedir", "socket", "foreground"):

3027

"priority", "servicename", "configdir", "use_dbus",

3028

"use_ipv6", "debuglevel", "restore", "statedir",

3029

"socket", "foreground", "zeroconf"):

2259

3030

value = getattr(options, option)

2260

3031

if value is not None:

2261

3032

server_settings[option] = value

2262

3033

del options

2263

3034

# Force all strings to be unicode

2264

3035

for option in server_settings.keys():

2265

if type(server_settings[option]) is str:

2266

server_settings[option] = unicode(server_settings[option])

3036

if isinstance(server_settings[option], bytes):

3037

server_settings[option] = (server_settings[option]

3038

.decode("utf-8"))

3039

# Force all boolean options to be boolean

3040

for option in ("debug", "use_dbus", "use_ipv6", "restore",

3041

"foreground", "zeroconf"):

3042

server_settings[option] = bool(server_settings[option])

2267

3043

# Debug implies foreground

2268

3044

if server_settings["debug"]:

2269

3045

server_settings["foreground"] = True

2270

3046

# Now we have our good server settings in "server_settings"

2271

3047

2272

3048

##################################################################

2273

3049

3050

if (not server_settings["zeroconf"]

3051

and not (server_settings["port"]

3052

or server_settings["socket"] != "")):

3053

parser.error("Needs port or socket to work without Zeroconf")

3054

2274

3055

# For convenience

2275

3056

debug = server_settings["debug"]

2276

3057

debuglevel = server_settings["debuglevel"]

2279

3060

stored_state_path = os.path.join(server_settings["statedir"],

2280

3061

stored_state_file)

2281

3062

foreground = server_settings["foreground"]

2282

3063

zeroconf = server_settings["zeroconf"]

3064

2283

3065

if debug:

2284

3066

initlogger(debug, logging.DEBUG)

2285

3067

else:

2288

3070

else:

2289

3071

level = getattr(logging, debuglevel.upper())

2290

3072

initlogger(debug, level)

2291

3073

2292

3074

if server_settings["servicename"] != "Mandos":

2293

syslogger.setFormatter(logging.Formatter

2294

('Mandos ({0}) [%(process)d]:'

2295

' %(levelname)s: %(message)s'

2296

.format(server_settings

2297

["servicename"])))

2298

3075

syslogger.setFormatter(

3076

logging.Formatter('Mandos ({}) [%(process)d]:'

3077

' %(levelname)s: %(message)s'.format(

3078

server_settings["servicename"])))

3079

2299

3080

# Parse config file with clients

2300

3081

client_config = configparser.SafeConfigParser(Client

2301

3082

.client_defaults)

2302

3083

client_config.read(os.path.join(server_settings["configdir"],

2303

3084

"clients.conf"))

2304

3085

2305

3086

global mandos_dbus_service

2306

3087

mandos_dbus_service = None

2307

2308

tcp_server = MandosServer((server_settings["address"],

2309

server_settings["port"]),

2310

ClientHandler,

2311

interface=(server_settings["interface"]

2312

or None),

2313

use_ipv6=use_ipv6,

2314

gnutls_priority=

2315

server_settings["priority"],

2316

use_dbus=use_dbus,

2317

socketfd=(server_settings["socket"]

2318

or None))

3088

3089

socketfd = None

3090

if server_settings["socket"] != "":

3091

socketfd = server_settings["socket"]

3092

tcp_server = MandosServer(

3093

(server_settings["address"], server_settings["port"]),

3094

ClientHandler,

3095

interface=(server_settings["interface"] or None),

3096

use_ipv6=use_ipv6,

3097

gnutls_priority=server_settings["priority"],

3098

use_dbus=use_dbus,

3099

socketfd=socketfd)

2319

3100

if not foreground:

2320

pidfilename = "/var/run/mandos.pid"

3101

pidfilename = "/run/mandos.pid"

3102

if not os.path.isdir("/run/."):

3103

pidfilename = "/var/run/mandos.pid"

2321

3104

pidfile = None

2322

3105

try:

2323

pidfile = open(pidfilename, "w")

3106

pidfile = codecs.open(pidfilename, "w", encoding="utf-8")

2324

3107

except IOError as e:

2325

3108

logger.error("Could not open file %r", pidfilename,

2326

3109

exc_info=e)

2327

2328

for name in ("_mandos", "mandos", "nobody"):

3110

3111

for name, group in (("_mandos", "_mandos"),

3112

("mandos", "mandos"),

3113

("nobody", "nogroup")):

2329

3114

try:

2330

3115

uid = pwd.getpwnam(name).pw_uid

2331

gid = pwd.getpwnam(name).pw_gid

3116

gid = pwd.getpwnam(group).pw_gid

2332

3117

break

2333

3118

except KeyError:

2334

3119

continue

2338

3123

try:

2339

3124

os.setgid(gid)

2340

3125

os.setuid(uid)

3126

if debug:

3127

logger.debug("Did setuid/setgid to {}:{}".format(uid,

3128

gid))

2341

3129

except OSError as error:

3130

logger.warning("Failed to setuid/setgid to {}:{}: {}"

3131

.format(uid, gid, os.strerror(error.errno)))

2342

3132

if error.errno != errno.EPERM:

2343

raise error

2344

3133

raise

3134

2345

3135

if debug:

2346

3136

# Enable all possible GnuTLS debugging

2347

3137

2348

3138

# "Use a log level over 10 to enable all debugging options."

2349

3139

# - GnuTLS manual

2350

gnutls.library.functions.gnutls_global_set_log_level(11)

2351

2352

@gnutls.library.types.gnutls_log_func

3140

gnutls.global_set_log_level(11)

3141

3142

@gnutls.log_func

2353

3143

def debug_gnutls(level, string):

2354

3144

logger.debug("GnuTLS: %s", string[:-1])

2355

2356

(gnutls.library.functions

2357

.gnutls_global_set_log_function(debug_gnutls))

2358

3145

3146

gnutls.global_set_log_function(debug_gnutls)

3147

2359

3148

# Redirect stdin so all checkers get /dev/null

2360

3149

null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)

2361

3150

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

2362

3151

if null > 2:

2363

3152

os.close(null)

2364

3153

2365

3154

# Need to fork before connecting to D-Bus

2366

3155

if not foreground:

2367

3156

# Close all input and output, do double fork, etc.

2368

3157

daemon()

2369

2370

# multiprocessing will use threads, so before we use gobject we

2371

# need to inform gobject that threads will be used.

2372

gobject.threads_init()

2373

3158

3159

# multiprocessing will use threads, so before we use GLib we need

3160

# to inform GLib that threads will be used.

3161

GLib.threads_init()

3162

2374

3163

global main_loop

2375

3164

# From the Avahi example code

2376

3165

DBusGMainLoop(set_as_default=True)

2377

main_loop = gobject.MainLoop()

3166

main_loop = GLib.MainLoop()

2378

3167

bus = dbus.SystemBus()

2379

3168

# End of Avahi example code

2380

3169

if use_dbus:

2381

3170

try:

2382

3171

bus_name = dbus.service.BusName("se.recompile.Mandos",

2383

bus, do_not_queue=True)

2384

old_bus_name = (dbus.service.BusName

2385

("se.bsnet.fukt.Mandos", bus,

2386

do_not_queue=True))

2387

except dbus.exceptions.NameExistsException as e:

3172

bus,

3173

do_not_queue=True)

3174

old_bus_name = dbus.service.BusName(

3175

"se.bsnet.fukt.Mandos", bus,

3176

do_not_queue=True)

3177

except dbus.exceptions.DBusException as e:

2388

3178

logger.error("Disabling D-Bus:", exc_info=e)

2389

3179

use_dbus = False

2390

3180

server_settings["use_dbus"] = False

2391

3181

tcp_server.use_dbus = False

2392

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2393

service = AvahiServiceToSyslog(name =

2394

server_settings["servicename"],

2395

servicetype = "_mandos._tcp",

2396

protocol = protocol, bus = bus)

2397

if server_settings["interface"]:

2398

service.interface = (if_nametoindex

2399

(str(server_settings["interface"])))

2400

3182

if zeroconf:

3183

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3184

service = AvahiServiceToSyslog(

3185

name=server_settings["servicename"],

3186

servicetype="_mandos._tcp",

3187

protocol=protocol,

3188

bus=bus)

3189

if server_settings["interface"]:

3190

service.interface = if_nametoindex(

3191

server_settings["interface"].encode("utf-8"))

3192

2401

3193

global multiprocessing_manager

2402

3194

multiprocessing_manager = multiprocessing.Manager()

2403

3195

2404

3196

client_class = Client

2405

3197

if use_dbus:

2406

client_class = functools.partial(ClientDBus, bus = bus)

2407

3198

client_class = functools.partial(ClientDBus, bus=bus)

3199

2408

3200

client_settings = Client.config_parser(client_config)

2409

3201

old_client_settings = {}

2410

3202

clients_data = {}

2411

3203

3204

# This is used to redirect stdout and stderr for checker processes

3205

global wnull

3206

wnull = open(os.devnull, "w") # A writable /dev/null

3207

# Only used if server is running in foreground but not in debug

3208

# mode

3209

if debug or not foreground:

3210

wnull.close()

3211

2412

3212

# Get client data and settings from last running state.

2413

3213

if server_settings["restore"]:

2414

3214

try:

2415

3215

with open(stored_state_path, "rb") as stored_state:

2416

clients_data, old_client_settings = (pickle.load

2417

(stored_state))

3216

if sys.version_info.major == 2:

3217

clients_data, old_client_settings = pickle.load(

3218

stored_state)

3219

else:

3220

bytes_clients_data, bytes_old_client_settings = (

3221

pickle.load(stored_state, encoding="bytes"))

3222

# Fix bytes to strings

3223

# clients_data

3224

# .keys()

3225

clients_data = {(key.decode("utf-8")

3226

if isinstance(key, bytes)

3227

else key): value

3228

for key, value in

3229

bytes_clients_data.items()}

3230

del bytes_clients_data

3231

for key in clients_data:

3232

value = {(k.decode("utf-8")

3233

if isinstance(k, bytes) else k): v

3234

for k, v in

3235

clients_data[key].items()}

3236

clients_data[key] = value

3237

# .client_structure

3238

value["client_structure"] = [

3239

(s.decode("utf-8")

3240

if isinstance(s, bytes)

3241

else s) for s in

3242

value["client_structure"]]

3243

# .name & .host

3244

for k in ("name", "host"):

3245

if isinstance(value[k], bytes):

3246

value[k] = value[k].decode("utf-8")

3247

if not value.has_key("key_id"):

3248

value["key_id"] = ""

3249

elif not value.has_key("fingerprint"):

3250

value["fingerprint"] = ""

3251

# old_client_settings

3252

# .keys()

3253

old_client_settings = {

3254

(key.decode("utf-8")

3255

if isinstance(key, bytes)

3256

else key): value

3257

for key, value in

3258

bytes_old_client_settings.items()}

3259

del bytes_old_client_settings

3260

# .host

3261

for value in old_client_settings.values():

3262

if isinstance(value["host"], bytes):

3263

value["host"] = (value["host"]

3264

.decode("utf-8"))

2418

3265

os.remove(stored_state_path)

2419

3266

except IOError as e:

2420

3267

if e.errno == errno.ENOENT:

2421

logger.warning("Could not load persistent state: {0}"

2422

.format(os.strerror(e.errno)))

3268

logger.warning("Could not load persistent state:"

3269

" {}".format(os.strerror(e.errno)))

2423

3270

else:

2424

3271

logger.critical("Could not load persistent state:",

2425

3272

exc_info=e)

2426

3273

raise

2427

3274

except EOFError as e:

2428

3275

logger.warning("Could not load persistent state: "

2429

"EOFError:", exc_info=e)

2430

3276

"EOFError:",

3277

exc_info=e)

3278

2431

3279

with PGPEngine() as pgp:

2432

for client_name, client in clients_data.iteritems():

3280

for client_name, client in clients_data.items():

3281

# Skip removed clients

3282

if client_name not in client_settings:

3283

continue

3284

2433

3285

# Decide which value to use after restoring saved state.

2434

3286

# We have three different values: Old config file,

2435

3287

# new config file, and saved state.

2440

3292

# For each value in new config, check if it

2441

3293

# differs from the old config value (Except for

2442

3294

# the "secret" attribute)

2443

if (name != "secret" and

2444

value != old_client_settings[client_name]

2445

[name]):

3295

if (name != "secret"

3296

and (value !=

3297

old_client_settings[client_name][name])):

2446

3298

client[name] = value

2447

3299

except KeyError:

2448

3300

pass

2449

3301

2450

3302

# Clients who has passed its expire date can still be

2451

# enabled if its last checker was successful. Clients

3303

# enabled if its last checker was successful. A Client

2452

3304

# whose checker succeeded before we stored its state is

2453

3305

# assumed to have successfully run all checkers during

2454

3306

# downtime.

2456

3308

if datetime.datetime.utcnow() >= client["expires"]:

2457

3309

if not client["last_checked_ok"]:

2458

3310

logger.warning(

2459

"disabling client {0} - Client never "

2460

"performed a successful checker"

2461

.format(client_name))

3311

"disabling client {} - Client never "

3312

"performed a successful checker".format(

3313

client_name))

2462

3314

client["enabled"] = False

2463

3315

elif client["last_checker_status"] != 0:

2464

3316

logger.warning(

2465

"disabling client {0} - Client "

2466

"last checker failed with error code {1}"

2467

.format(client_name,

2468

client["last_checker_status"]))

3317

"disabling client {} - Client last"

3318

" checker failed with error code"

3319

" {}".format(

3320

client_name,

3321

client["last_checker_status"]))

2469

3322

client["enabled"] = False

2470

3323

else:

2471

client["expires"] = (datetime.datetime

2472

.utcnow()

2473

+ client["timeout"])

3324

client["expires"] = (

3325

datetime.datetime.utcnow()

3326

+ client["timeout"])

2474

3327

logger.debug("Last checker succeeded,"

2475

" keeping {0} enabled"

2476

.format(client_name))

3328

" keeping {} enabled".format(

3329

client_name))

2477

3330

try:

2478

client["secret"] = (

2479

pgp.decrypt(client["encrypted_secret"],

2480

client_settings[client_name]

2481

["secret"]))

3331

client["secret"] = pgp.decrypt(

3332

client["encrypted_secret"],

3333

client_settings[client_name]["secret"])

2482

3334

except PGPError:

2483

3335

# If decryption fails, we use secret from new settings

2484

logger.debug("Failed to decrypt {0} old secret"

2485

.format(client_name))

2486

client["secret"] = (

2487

client_settings[client_name]["secret"])

2488

3336

logger.debug("Failed to decrypt {} old secret".format(

3337

client_name))

3338

client["secret"] = (client_settings[client_name]

3339

["secret"])

3340

2489

3341

# Add/remove clients based on new changes made to config

2490

3342

for client_name in (set(old_client_settings)

2491

3343

- set(client_settings)):

2493

3345

for client_name in (set(client_settings)

2494

3346

- set(old_client_settings)):

2495

3347

clients_data[client_name] = client_settings[client_name]

2496

3348

2497

3349

# Create all client objects

2498

for client_name, client in clients_data.iteritems():

3350

for client_name, client in clients_data.items():

2499

3351

tcp_server.clients[client_name] = client_class(

2500

name = client_name, settings = client)

2501

3352

name=client_name,

3353

settings=client,

3354

server_settings=server_settings)

3355

2502

3356

if not tcp_server.clients:

2503

3357

logger.warning("No clients defined")

2504

3358

2505

3359

if not foreground:

2506

3360

if pidfile is not None:

3361

pid = os.getpid()

2507

3362

try:

2508

3363

with pidfile:

2509

pid = os.getpid()

2510

pidfile.write(str(pid) + "\n".encode("utf-8"))

3364

print(pid, file=pidfile)

2511

3365

except IOError:

2512

3366

logger.error("Could not write to file %r with PID %d",

2513

3367

pidfilename, pid)

2514

3368

del pidfile

2515

3369

del pidfilename

2516

2517

signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())

2518

signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())

2519

3370

3371

for termsig in (signal.SIGHUP, signal.SIGTERM):

3372

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3373

lambda: main_loop.quit() and False)

3374

2520

3375

if use_dbus:

2521

@alternate_dbus_interfaces({"se.recompile.Mandos":

2522

"se.bsnet.fukt.Mandos"})

2523

class MandosDBusService(DBusObjectWithProperties):

3376

3377

@alternate_dbus_interfaces(

3378

{"se.recompile.Mandos": "se.bsnet.fukt.Mandos"})

3379

class MandosDBusService(DBusObjectWithObjectManager):

2524

3380

"""A D-Bus proxy object"""

3381

2525

3382

def __init__(self):

2526

3383

dbus.service.Object.__init__(self, bus, "/")

3384

2527

3385

_interface = "se.recompile.Mandos"

2528

2529

@dbus_interface_annotations(_interface)

2530

def _foo(self):

2531

return { "org.freedesktop.DBus.Property"

2532

".EmitsChangedSignal":

2533

"false"}

2534

3386

2535

3387

@dbus.service.signal(_interface, signature="o")

2536

3388

def ClientAdded(self, objpath):

2537

3389

"D-Bus signal"

2538

3390

pass

2539

3391

2540

3392

@dbus.service.signal(_interface, signature="ss")

2541

def ClientNotFound(self, fingerprint, address):

3393

def ClientNotFound(self, key_id, address):

2542

3394

"D-Bus signal"

2543

3395

pass

2544

3396

3397

@dbus_annotations({"org.freedesktop.DBus.Deprecated":

3398

"true"})

2545

3399

@dbus.service.signal(_interface, signature="os")

2546

3400

def ClientRemoved(self, objpath, name):

2547

3401

"D-Bus signal"

2548

3402

pass

2549

3403

3404

@dbus_annotations({"org.freedesktop.DBus.Deprecated":

3405

"true"})

2550

3406

@dbus.service.method(_interface, out_signature="ao")

2551

3407

def GetAllClients(self):

2552

3408

"D-Bus method"

2553

return dbus.Array(c.dbus_object_path

2554

for c in

2555

tcp_server.clients.itervalues())

2556

3409

return dbus.Array(c.dbus_object_path for c in

3410

tcp_server.clients.values())

3411

3412

@dbus_annotations({"org.freedesktop.DBus.Deprecated":

3413

"true"})

2557

3414

@dbus.service.method(_interface,

2558

3415

out_signature="a{oa{sv}}")

2559

3416

def GetAllClientsWithProperties(self):

2560

3417

"D-Bus method"

2561

3418

return dbus.Dictionary(

2562

((c.dbus_object_path, c.GetAll(""))

2563

for c in tcp_server.clients.itervalues()),

3419

{c.dbus_object_path: c.GetAll(

3420

"se.recompile.Mandos.Client")

3421

for c in tcp_server.clients.values()},

2564

3422

signature="oa{sv}")

2565

3423

2566

3424

@dbus.service.method(_interface, in_signature="o")

2567

3425

def RemoveClient(self, object_path):

2568

3426

"D-Bus method"

2569

for c in tcp_server.clients.itervalues():

3427

for c in tcp_server.clients.values():

2570

3428

if c.dbus_object_path == object_path:

2571

3429

del tcp_server.clients[c.name]

2572

3430

c.remove_from_connection()

2573

# Don't signal anything except ClientRemoved

3431

# Don't signal the disabling

2574

3432

c.disable(quiet=True)

2575

# Emit D-Bus signal

2576

self.ClientRemoved(object_path, c.name)

3433

# Emit D-Bus signal for removal

3434

self.client_removed_signal(c)

2577

3435

return

2578

3436

raise KeyError(object_path)

2579

3437

2580

3438

del _interface

2581

3439

3440

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3441

out_signature="a{oa{sa{sv}}}")

3442

def GetManagedObjects(self):

3443

"""D-Bus method"""

3444

return dbus.Dictionary(

3445

{client.dbus_object_path:

3446

dbus.Dictionary(

3447

{interface: client.GetAll(interface)

3448

for interface in

3449

client._get_all_interface_names()})

3450

for client in tcp_server.clients.values()})

3451

3452

def client_added_signal(self, client):

3453

"""Send the new standard signal and the old signal"""

3454

if use_dbus:

3455

# New standard signal

3456

self.InterfacesAdded(

3457

client.dbus_object_path,

3458

dbus.Dictionary(

3459

{interface: client.GetAll(interface)

3460

for interface in

3461

client._get_all_interface_names()}))

3462

# Old signal

3463

self.ClientAdded(client.dbus_object_path)

3464

3465

def client_removed_signal(self, client):

3466

"""Send the new standard signal and the old signal"""

3467

if use_dbus:

3468

# New standard signal

3469

self.InterfacesRemoved(

3470

client.dbus_object_path,

3471

client._get_all_interface_names())

3472

# Old signal

3473

self.ClientRemoved(client.dbus_object_path,

3474

client.name)

3475

2582

3476

mandos_dbus_service = MandosDBusService()

2583

3477

3478

# Save modules to variables to exempt the modules from being

3479

# unloaded before the function registered with atexit() is run.

3480

mp = multiprocessing

3481

wn = wnull

3482

2584

3483

def cleanup():

2585

3484

"Cleanup function; run on exit"

2586

service.cleanup()

2587

2588

multiprocessing.active_children()

3485

if zeroconf:

3486

service.cleanup()

3487

3488

mp.active_children()

3489

wn.close()

2589

3490

if not (tcp_server.clients or client_settings):

2590

3491

return

2591

3492

2592

3493

# Store client before exiting. Secrets are encrypted with key

2593

3494

# based on what config file has. If config file is

2594

3495

# removed/edited, old secret will thus be unrecovable.

2595

3496

clients = {}

2596

3497

with PGPEngine() as pgp:

2597

for client in tcp_server.clients.itervalues():

3498

for client in tcp_server.clients.values():

2598

3499

key = client_settings[client.name]["secret"]

2599

3500

client.encrypted_secret = pgp.encrypt(client.secret,

2600

3501

key)

2601

3502

client_dict = {}

2602

3503

2603

3504

# A list of attributes that can not be pickled

2604

3505

# + secret.

2605

exclude = set(("bus", "changedstate", "secret",

2606

"checker"))

2607

for name, typ in (inspect.getmembers

2608

(dbus.service.Object)):

3506

exclude = {"bus", "changedstate", "secret",

3507

"checker", "server_settings"}

3508

for name, typ in inspect.getmembers(dbus.service

3509

.Object):

2609

3510

exclude.add(name)

2610

3511

2611

3512

client_dict["encrypted_secret"] = (client

2612

3513

.encrypted_secret)

2613

3514

for attr in client.client_structure:

2614

3515

if attr not in exclude:

2615

3516

client_dict[attr] = getattr(client, attr)

2616

3517

2617

3518

clients[client.name] = client_dict

2618

3519

del client_settings[client.name]["secret"]

2619

3520

2620

3521

try:

2621

with (tempfile.NamedTemporaryFile

2622

(mode='wb', suffix=".pickle", prefix='clients-',

2623

dir=os.path.dirname(stored_state_path),

2624

delete=False)) as stored_state:

2625

pickle.dump((clients, client_settings), stored_state)

2626

tempname=stored_state.name

3522

with tempfile.NamedTemporaryFile(

3523

mode='wb',

3524

suffix=".pickle",

3525

prefix='clients-',

3526

dir=os.path.dirname(stored_state_path),

3527

delete=False) as stored_state:

3528

pickle.dump((clients, client_settings), stored_state,

3529

protocol=2)

3530

tempname = stored_state.name

2627

3531

os.rename(tempname, stored_state_path)

2628

3532

except (IOError, OSError) as e:

2629

3533

if not debug:

2632

3536

except NameError:

2633

3537

pass

2634

3538

if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):

2635

logger.warning("Could not save persistent state: {0}"

3539

logger.warning("Could not save persistent state: {}"

2636

3540

.format(os.strerror(e.errno)))

2637

3541

else:

2638

3542

logger.warning("Could not save persistent state:",

2639

3543

exc_info=e)

2640

raise e

2641

3544

raise

3545

2642

3546

# Delete all clients, and settings from config

2643

3547

while tcp_server.clients:

2644

3548

name, client = tcp_server.clients.popitem()

2645

3549

if use_dbus:

2646

3550

client.remove_from_connection()

2647

# Don't signal anything except ClientRemoved

3551

# Don't signal the disabling

2648

3552

client.disable(quiet=True)

3553

# Emit D-Bus signal for removal

2649

3554

if use_dbus:

2650

# Emit D-Bus signal

2651

mandos_dbus_service.ClientRemoved(client

2652

.dbus_object_path,

2653

client.name)

3555

mandos_dbus_service.client_removed_signal(client)

2654

3556

client_settings.clear()

2655

3557

2656

3558

atexit.register(cleanup)

2657

2658

for client in tcp_server.clients.itervalues():

3559

3560

for client in tcp_server.clients.values():

2659

3561

if use_dbus:

2660

# Emit D-Bus signal

2661

mandos_dbus_service.ClientAdded(client.dbus_object_path)

3562

# Emit D-Bus signal for adding

3563

mandos_dbus_service.client_added_signal(client)

2662

3564

# Need to initiate checking of clients

2663

3565

if client.enabled:

2664

3566

client.init_checker()

2665

3567

2666

3568

tcp_server.enable()

2667

3569

tcp_server.server_activate()

2668

3570

2669

3571

# Find out what port we got

2670

service.port = tcp_server.socket.getsockname()[1]

3572

if zeroconf:

3573

service.port = tcp_server.socket.getsockname()[1]

2671

3574

if use_ipv6:

2672

3575

logger.info("Now listening on address %r, port %d,"

2673

3576

" flowinfo %d, scope_id %d",

2675

3578

else: # IPv4

2676

3579

logger.info("Now listening on address %r, port %d",

2677

3580

*tcp_server.socket.getsockname())

2678

2679

#service.interface = tcp_server.socket.getsockname()[3]

2680

3581

3582

# service.interface = tcp_server.socket.getsockname()[3]

3583

2681

3584

try:

2682

# From the Avahi example code

2683

try:

2684

service.activate()

2685

except dbus.exceptions.DBusException as error:

2686

logger.critical("D-Bus Exception", exc_info=error)

2687

cleanup()

2688

sys.exit(1)

2689

# End of Avahi example code

2690

2691

gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,

2692

lambda *args, **kwargs:

2693

(tcp_server.handle_request

2694

(*args[2:], **kwargs) or True))

2695

3585

if zeroconf:

3586

# From the Avahi example code

3587

try:

3588

service.activate()

3589

except dbus.exceptions.DBusException as error:

3590

logger.critical("D-Bus Exception", exc_info=error)

3591

cleanup()

3592

sys.exit(1)

3593

# End of Avahi example code

3594

3595

GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,

3596

lambda *args, **kwargs:

3597

(tcp_server.handle_request

3598

(*args[2:], **kwargs) or True))

3599

2696

3600

logger.debug("Starting main loop")

2697

3601

main_loop.run()

2698

3602

except AvahiError as error:

2707

3611

# Must run before the D-Bus bus name gets deregistered

2708

3612

cleanup()

2709

3613

3614

2710

3615

if __name__ == '__main__':

2711

3616

main()