/mandos/trunk : revision 713

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

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

21

19

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

22

20

# (at your option) any later version.

23

21

#

24

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

25

# WITHOUT ANY WARRANTY; without even the implied warranty of

22

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

23

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

26

24

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

27

25

# GNU General Public License for more details.

28

#

26

#

29

27

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

30

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

31

#

28

# along with this program. If not, see

29

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

30

#

32

31

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

33

#

32

#

34

33

35

34

from __future__ import (division, absolute_import, print_function,

36

35

unicode_literals)

37

36

38

try:

39

from future_builtins import *

40

except ImportError:

41

pass

37

from future_builtins import *

42

38

43

try:

44

import SocketServer as socketserver

45

except ImportError:

46

import socketserver

39

import SocketServer as socketserver

47

40

import socket

48

41

import argparse

49

42

import datetime

50

43

import errno

51

try:

52

import ConfigParser as configparser

53

except ImportError:

54

import configparser

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

55

51

import sys

56

52

import re

57

53

import os

66

62

import struct

67

63

import fcntl

68

64

import functools

69

try:

70

import cPickle as pickle

71

except ImportError:

72

import pickle

65

import cPickle as pickle

73

66

import multiprocessing

74

67

import types

75

68

import binascii

76

69

import tempfile

77

70

import itertools

78

71

import collections

79

import codecs

80

72

81

73

import dbus

82

74

import dbus.service

83

from gi.repository import GLib

75

import gobject

76

import avahi

84

77

from dbus.mainloop.glib import DBusGMainLoop

85

78

import ctypes

86

79

import ctypes.util

87

80

import xml.dom.minidom

88

81

import inspect

89

82

90

# Try to find the value of SO_BINDTODEVICE:

91

83

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:

94

84

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

95

85

except AttributeError:

96

86

try:

97

# This is where SO_BINDTODEVICE was up to and including Python

98

# 2.6, and also 3.2:

99

87

from IN import SO_BINDTODEVICE

100

88

except ImportError:

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"

89

SO_BINDTODEVICE = None

90

91

version = "1.6.6"

119

92

stored_state_file = "clients.pickle"

120

93

121

94

logger = logging.getLogger()

122

95

syslogger = None

123

96

124

97

try:

125

if_nametoindex = ctypes.cdll.LoadLibrary(

126

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

98

if_nametoindex = (ctypes.cdll.LoadLibrary

99

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

100

.if_nametoindex)

127

101

except (OSError, AttributeError):

128

129

102

def if_nametoindex(interface):

130

103

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

131

104

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

132

105

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

133

106

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

134

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

135

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

107

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

108

interface))

109

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

110

ifreq[16:20])[0]

136

111

return interface_index

137

112

138

113

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

155

114

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

156

115

"""init logger and add loglevel"""

157

116

158

117

global syslogger

159

syslogger = (logging.handlers.SysLogHandler(

160

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

161

address="/dev/log"))

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

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

162

122

syslogger.setFormatter(logging.Formatter

163

123

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

164

124

' %(message)s'))

165

125

logger.addHandler(syslogger)

166

126

167

127

if debug:

168

128

console = logging.StreamHandler()

169

129

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

181

141

182

142

class PGPEngine(object):

183

143

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

184

185

144

def __init__(self):

186

145

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

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

146

self.gnupgargs = ['--batch',

199

'--homedir', self.tempdir,

147

'--home', self.tempdir,

200

148

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

149

'--quiet',

150

'--no-use-agent']

151

206

152

def __enter__(self):

207

153

return self

208

154

209

155

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

210

156

self._cleanup()

211

157

return False

212

158

213

159

def __del__(self):

214

160

self._cleanup()

215

161

216

162

def _cleanup(self):

217

163

if self.tempdir is not None:

218

164

# Delete contents of tempdir

219

165

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

220

topdown=False):

166

topdown = False):

221

167

for filename in files:

222

168

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

223

169

for dirname in dirs:

225

171

# Remove tempdir

226

172

os.rmdir(self.tempdir)

227

173

self.tempdir = None

228

174

229

175

def password_encode(self, password):

230

176

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

231

177

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

236

182

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

237

183

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

238

184

return encoded

239

185

240

186

def encrypt(self, data, password):

241

187

passphrase = self.password_encode(password)

242

with tempfile.NamedTemporaryFile(

243

dir=self.tempdir) as passfile:

188

with tempfile.NamedTemporaryFile(dir=self.tempdir

189

) as passfile:

244

190

passfile.write(passphrase)

245

191

passfile.flush()

246

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

192

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

247

193

'--passphrase-file',

248

194

passfile.name]

249

195

+ self.gnupgargs,

250

stdin=subprocess.PIPE,

251

stdout=subprocess.PIPE,

252

stderr=subprocess.PIPE)

253

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

196

stdin = subprocess.PIPE,

197

stdout = subprocess.PIPE,

198

stderr = subprocess.PIPE)

199

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

254

200

if proc.returncode != 0:

255

201

raise PGPError(err)

256

202

return ciphertext

257

203

258

204

def decrypt(self, data, password):

259

205

passphrase = self.password_encode(password)

260

with tempfile.NamedTemporaryFile(

261

dir=self.tempdir) as passfile:

206

with tempfile.NamedTemporaryFile(dir = self.tempdir

207

) as passfile:

262

208

passfile.write(passphrase)

263

209

passfile.flush()

264

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

210

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

265

211

'--passphrase-file',

266

212

passfile.name]

267

213

+ self.gnupgargs,

268

stdin=subprocess.PIPE,

269

stdout=subprocess.PIPE,

270

stderr=subprocess.PIPE)

271

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

214

stdin = subprocess.PIPE,

215

stdout = subprocess.PIPE,

216

stderr = subprocess.PIPE)

217

decrypted_plaintext, err = proc.communicate(input

218

= data)

272

219

if proc.returncode != 0:

273

220

raise PGPError(err)

274

221

return decrypted_plaintext

275

222

276

223

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

303

224

class AvahiError(Exception):

304

225

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

305

226

self.value = value

306

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

307

**kwargs)

308

227

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

228

def __unicode__(self):

229

return unicode(repr(self.value))

309

230

310

231

class AvahiServiceError(AvahiError):

311

232

pass

312

233

313

314

234

class AvahiGroupError(AvahiError):

315

235

pass

316

236

317

237

318

238

class AvahiService(object):

319

239

"""An Avahi (Zeroconf) service.

320

240

321

241

Attributes:

322

242

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

323

243

Used to optionally bind to the specified interface.

335

255

server: D-Bus Server

336

256

bus: dbus.SystemBus()

337

257

"""

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

258

259

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

260

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

261

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

262

protocol = avahi.PROTO_UNSPEC, bus = None):

350

263

self.interface = interface

351

264

self.name = name

352

265

self.type = servicetype

361

274

self.server = None

362

275

self.bus = bus

363

276

self.entry_group_state_changed_match = None

364

365

def rename(self, remove=True):

277

278

def rename(self):

366

279

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

367

280

if self.rename_count >= self.max_renames:

368

281

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

369

282

" after %i retries, exiting.",

370

283

self.rename_count)

371

284

raise AvahiServiceError("Too many renames")

372

self.name = str(

373

self.server.GetAlternativeServiceName(self.name))

374

self.rename_count += 1

285

self.name = unicode(self.server

286

.GetAlternativeServiceName(self.name))

375

287

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

376

288

self.name)

377

if remove:

378

self.remove()

289

self.remove()

379

290

try:

380

291

self.add()

381

292

except dbus.exceptions.DBusException as error:

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

293

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

294

self.cleanup()

295

os._exit(1)

296

self.rename_count += 1

297

391

298

def remove(self):

392

299

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

393

300

if self.entry_group_state_changed_match is not None:

395

302

self.entry_group_state_changed_match = None

396

303

if self.group is not None:

397

304

self.group.Reset()

398

305

399

306

def add(self):

400

307

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

401

308

self.remove()

418

325

dbus.UInt16(self.port),

419

326

avahi.string_array_to_txt_array(self.TXT))

420

327

self.group.Commit()

421

328

422

329

def entry_group_state_changed(self, state, error):

423

330

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

424

331

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

425

332

426

333

if state == avahi.ENTRY_GROUP_ESTABLISHED:

427

334

logger.debug("Zeroconf service established.")

428

335

elif state == avahi.ENTRY_GROUP_COLLISION:

430

337

self.rename()

431

338

elif state == avahi.ENTRY_GROUP_FAILURE:

432

339

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

433

str(error))

434

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

435

340

unicode(error))

341

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

342

.format(error))

343

436

344

def cleanup(self):

437

345

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

438

346

if self.group is not None:

443

351

pass

444

352

self.group = None

445

353

self.remove()

446

354

447

355

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

448

356

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

449

357

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

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

}

358

bad_states = { avahi.SERVER_INVALID:

359

"Zeroconf server invalid",

360

avahi.SERVER_REGISTERING: None,

361

avahi.SERVER_COLLISION:

362

"Zeroconf server name collision",

363

avahi.SERVER_FAILURE:

364

"Zeroconf server failure" }

456

365

if state in bad_states:

457

366

if bad_states[state] is not None:

458

367

if error is None:

461

370

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

462

371

self.cleanup()

463

372

elif state == avahi.SERVER_RUNNING:

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)

373

self.add()

476

374

else:

477

375

if error is None:

478

376

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

479

377

else:

480

378

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

481

379

482

380

def activate(self):

483

381

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

484

382

if self.server is None:

488

386

follow_name_owner_changes=True),

489

387

avahi.DBUS_INTERFACE_SERVER)

490

388

self.server.connect_to_signal("StateChanged",

491

self.server_state_changed)

389

self.server_state_changed)

492

390

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

493

391

494

392

495

393

class AvahiServiceToSyslog(AvahiService):

496

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

394

def rename(self):

497

395

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

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

396

ret = AvahiService.rename(self)

397

syslogger.setFormatter(logging.Formatter

398

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

399

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

400

.format(self.name)))

502

401

return ret

503

402

504

403

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

404

def timedelta_to_milliseconds(td):

405

"Convert a datetime.timedelta() to milliseconds"

406

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

407

+ (td.seconds * 1000)

408

+ (td.microseconds // 1000))

815

409

816

410

817

411

class Client(object):

818

412

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

819

413

820

414

Attributes:

821

415

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

822

416

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

824

418

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

825

419

to see if the client lives.

826

420

'None' if no process is running.

827

checker_callback_tag: a GLib event source tag, or None

421

checker_callback_tag: a gobject event source tag, or None

828

422

checker_command: string; External command which is run to check

829

423

if client lives. %() expansions are done at

830

424

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

831

425

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

832

checker_initiator_tag: a GLib event source tag, or None

426

checker_initiator_tag: a gobject event source tag, or None

833

427

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

834

428

client_structure: Object describing what attributes a client has

835

429

and is used for storing the client at exit

836

430

current_checker_command: string; current running checker_command

837

disable_initiator_tag: a GLib event source tag, or None

431

disable_initiator_tag: a gobject event source tag, or None

838

432

enabled: bool()

839

433

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

840

uniquely identify an OpenPGP client

841

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

842

a client using raw public keys

434

uniquely identify the client

843

435

host: string; available for use by the checker command

844

436

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

845

437

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

847

439

last_checker_status: integer between 0 and 255 reflecting exit

848

440

status of last checker. -1 reflects crashed

849

441

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

852

442

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

853

443

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

854

444

D-Bus identifiers

861

451

disabled, or None

862

452

server_settings: The server_settings dict from main()

863

453

"""

864

454

865

455

runtime_expansions = ("approval_delay", "approval_duration",

866

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

456

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

867

457

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

868

458

"last_approval_request", "last_checked_ok",

869

459

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

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

460

client_defaults = { "timeout": "PT5M",

461

"extended_timeout": "PT15M",

462

"interval": "PT2M",

463

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

464

"host": "",

465

"approval_delay": "PT0S",

466

"approval_duration": "PT1S",

467

"approved_by_default": "True",

468

"enabled": "True",

469

}

470

471

def timeout_milliseconds(self):

472

"Return the 'timeout' attribute in milliseconds"

473

return timedelta_to_milliseconds(self.timeout)

474

475

def extended_timeout_milliseconds(self):

476

"Return the 'extended_timeout' attribute in milliseconds"

477

return timedelta_to_milliseconds(self.extended_timeout)

478

479

def interval_milliseconds(self):

480

"Return the 'interval' attribute in milliseconds"

481

return timedelta_to_milliseconds(self.interval)

482

483

def approval_delay_milliseconds(self):

484

return timedelta_to_milliseconds(self.approval_delay)

485

882

486

@staticmethod

883

487

def config_parser(config):

884

488

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

891

495

for client_name in config.sections():

892

496

section = dict(config.items(client_name))

893

497

client = settings[client_name] = {}

894

498

895

499

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

896

500

# Reformat values from string types to Python types

897

501

client["approved_by_default"] = config.getboolean(

898

502

client_name, "approved_by_default")

899

503

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

900

504

"enabled")

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

505

907

506

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

908

507

.replace(" ", ""))

909

508

if "secret" in section:

910

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

911

.encode("utf-8"),

912

"base64")

509

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

913

510

elif "secfile" in section:

914

511

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

915

512

(section["secfile"])),

916

513

"rb") as secfile:

917

514

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

918

515

else:

919

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

516

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

920

517

.format(section))

921

518

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

922

519

client["extended_timeout"] = string_to_delta(

930

527

client["last_approval_request"] = None

931

528

client["last_checked_ok"] = None

932

529

client["last_checker_status"] = -2

933

530

934

531

return settings

935

936

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

532

533

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

937

534

self.name = name

938

535

if server_settings is None:

939

536

server_settings = {}

940

537

self.server_settings = server_settings

941

538

# adding all client settings

942

for setting, value in settings.items():

539

for setting, value in settings.iteritems():

943

540

setattr(self, setting, value)

944

541

945

542

if self.enabled:

946

543

if not hasattr(self, "last_enabled"):

947

544

self.last_enabled = datetime.datetime.utcnow()

951

548

else:

952

549

self.last_enabled = None

953

550

self.expires = None

954

551

955

552

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

956

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

553

# Uppercase and remove spaces from fingerprint for later

554

# comparison purposes with return value from the fingerprint()

555

# function

957

556

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

958

557

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

959

558

datetime.datetime.utcnow())

960

559

961

560

# attributes specific for this server instance

962

561

self.checker = None

963

562

self.checker_initiator_tag = None

966

565

self.current_checker_command = None

967

566

self.approved = None

968

567

self.approvals_pending = 0

969

self.changedstate = multiprocessing_manager.Condition(

970

multiprocessing_manager.Lock())

971

self.client_structure = [attr

972

for attr in self.__dict__.keys()

568

self.changedstate = (multiprocessing_manager

569

.Condition(multiprocessing_manager

570

.Lock()))

571

self.client_structure = [attr for attr in

572

self.__dict__.iterkeys()

973

573

if not attr.startswith("_")]

974

574

self.client_structure.append("client_structure")

975

976

for name, t in inspect.getmembers(

977

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

575

576

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

577

lambda obj:

578

isinstance(obj,

579

property)):

978

580

if not name.startswith("_"):

979

581

self.client_structure.append(name)

980

582

981

583

# Send notice to process children that client state has changed

982

584

def send_changedstate(self):

983

585

with self.changedstate:

984

586

self.changedstate.notify_all()

985

587

986

588

def enable(self):

987

589

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

988

590

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

993

595

self.last_enabled = datetime.datetime.utcnow()

994

596

self.init_checker()

995

597

self.send_changedstate()

996

598

997

599

def disable(self, quiet=True):

998

600

"""Disable this client."""

999

601

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

1001

603

if not quiet:

1002

604

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

1003

605

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

1004

GLib.source_remove(self.disable_initiator_tag)

606

gobject.source_remove(self.disable_initiator_tag)

1005

607

self.disable_initiator_tag = None

1006

608

self.expires = None

1007

609

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

1008

GLib.source_remove(self.checker_initiator_tag)

610

gobject.source_remove(self.checker_initiator_tag)

1009

611

self.checker_initiator_tag = None

1010

612

self.stop_checker()

1011

613

self.enabled = False

1012

614

if not quiet:

1013

615

self.send_changedstate()

1014

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

616

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

1015

617

return False

1016

618

1017

619

def __del__(self):

1018

620

self.disable()

1019

621

1020

622

def init_checker(self):

1021

623

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

1022

624

# and every interval from then on.

1023

625

if self.checker_initiator_tag is not None:

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)

626

gobject.source_remove(self.checker_initiator_tag)

627

self.checker_initiator_tag = (gobject.timeout_add

628

(self.interval_milliseconds(),

629

self.start_checker))

1028

630

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

1029

631

if self.disable_initiator_tag is not None:

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)

632

gobject.source_remove(self.disable_initiator_tag)

633

self.disable_initiator_tag = (gobject.timeout_add

634

(self.timeout_milliseconds(),

635

self.disable))

1033

636

# Also start a new checker *right now*.

1034

637

self.start_checker()

1035

1036

def checker_callback(self, source, condition, connection,

1037

command):

638

639

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

1038

640

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

1039

641

self.checker_callback_tag = None

1040

642

self.checker = None

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

643

if os.WIFEXITED(condition):

644

self.last_checker_status = os.WEXITSTATUS(condition)

1048

645

if self.last_checker_status == 0:

1049

646

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

1050

647

vars(self))

1051

648

self.checked_ok()

1052

649

else:

1053

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

650

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

651

vars(self))

1054

652

else:

1055

653

self.last_checker_status = -1

1056

self.last_checker_signal = -returncode

1057

654

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

1058

655

vars(self))

1059

return False

1060

656

1061

657

def checked_ok(self):

1062

658

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

1063

659

self.last_checked_ok = datetime.datetime.utcnow()

1064

660

self.last_checker_status = 0

1065

self.last_checker_signal = None

1066

661

self.bump_timeout()

1067

662

1068

663

def bump_timeout(self, timeout=None):

1069

664

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

1070

665

if timeout is None:

1071

666

timeout = self.timeout

1072

667

if self.disable_initiator_tag is not None:

1073

GLib.source_remove(self.disable_initiator_tag)

668

gobject.source_remove(self.disable_initiator_tag)

1074

669

self.disable_initiator_tag = None

1075

670

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

1076

self.disable_initiator_tag = GLib.timeout_add(

1077

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

671

self.disable_initiator_tag = (gobject.timeout_add

672

(timedelta_to_milliseconds

673

(timeout), self.disable))

1078

674

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

1079

675

1080

676

def need_approval(self):

1081

677

self.last_approval_request = datetime.datetime.utcnow()

1082

678

1083

679

def start_checker(self):

1084

680

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

1085

681

1086

682

If a checker already exists, leave it running and do

1087

683

nothing."""

1088

684

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

1093

689

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

1094

690

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

1095

691

# should be.

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

693

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

694

try:

695

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

696

except AttributeError:

697

pass

698

except OSError as error:

699

if error.errno != errno.ECHILD:

700

raise

701

else:

702

if pid:

703

logger.warning("Checker was a zombie")

704

gobject.source_remove(self.checker_callback_tag)

705

self.checker_callback(pid, status,

706

self.current_checker_command)

1101

707

# Start a new checker if needed

1102

708

if self.checker is None:

1103

709

# Escape attributes for the shell

1104

escaped_attrs = {

1105

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

1106

for attr in self.runtime_expansions}

710

escaped_attrs = dict(

711

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

712

for attr in

713

self.runtime_expansions)

1107

714

try:

1108

715

command = self.checker_command % escaped_attrs

1109

716

except TypeError as error:

1110

717

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

1111

self.checker_command,

718

self.checker_command, exc_info=error)

719

return True # Try again later

720

self.current_checker_command = command

721

try:

722

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

723

command, self.name)

724

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

725

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

726

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

727

# always replaced by /dev/null.)

728

# The exception is when not debugging but nevertheless

729

# running in the foreground; use the previously

730

# created wnull.

731

popen_args = {}

732

if (not self.server_settings["debug"]

733

and self.server_settings["foreground"]):

734

popen_args.update({"stdout": wnull,

735

"stderr": wnull })

736

self.checker = subprocess.Popen(command,

737

close_fds=True,

738

shell=True, cwd="/",

739

**popen_args)

740

except OSError as error:

741

logger.error("Failed to start subprocess",

1112

742

exc_info=error)

1113

return True # Try again later

1114

self.current_checker_command = command

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

743

return True

744

self.checker_callback_tag = (gobject.child_watch_add

745

(self.checker.pid,

746

self.checker_callback,

747

data=command))

748

# The checker may have completed before the gobject

749

# watch was added. Check for this.

750

try:

751

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

752

except OSError as error:

753

if error.errno == errno.ECHILD:

754

# This should never happen

755

logger.error("Child process vanished",

756

exc_info=error)

757

return True

758

raise

759

if pid:

760

gobject.source_remove(self.checker_callback_tag)

761

self.checker_callback(pid, status, command)

762

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

1141

763

return True

1142

764

1143

765

def stop_checker(self):

1144

766

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

1145

767

if self.checker_callback_tag:

1146

GLib.source_remove(self.checker_callback_tag)

768

gobject.source_remove(self.checker_callback_tag)

1147

769

self.checker_callback_tag = None

1148

770

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

1149

771

return

1150

772

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

1151

self.checker.terminate()

773

try:

774

self.checker.terminate()

775

#time.sleep(0.5)

776

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

777

# self.checker.kill()

778

except OSError as error:

779

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

780

raise

1152

781

self.checker = None

1153

782

1154

783

1155

def dbus_service_property(dbus_interface,

1156

signature="v",

1157

access="readwrite",

1158

byte_arrays=False):

784

def dbus_service_property(dbus_interface, signature="v",

785

access="readwrite", byte_arrays=False):

1159

786

"""Decorators for marking methods of a DBusObjectWithProperties to

1160

787

become properties on the D-Bus.

1161

788

1162

789

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

1163

790

and with one argument by "Set".

1164

791

1165

792

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

1166

793

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

1167

794

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

1170

797

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

1171

798

if byte_arrays and signature != "ay":

1172

799

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

1173

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

1174

800

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

1175

801

def decorator(func):

1176

802

func._dbus_is_property = True

1177

803

func._dbus_interface = dbus_interface

1180

806

func._dbus_name = func.__name__

1181

807

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

1182

808

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

1183

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

809

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1184

810

return func

1185

1186

811

return decorator

1187

812

1188

813

1189

814

def dbus_interface_annotations(dbus_interface):

1190

815

"""Decorator for marking functions returning interface annotations

1191

816

1192

817

Usage:

1193

818

1194

819

@dbus_interface_annotations("org.example.Interface")

1195

820

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

1196

821

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

1197

822

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

1198

823

"false"}

1199

824

"""

1200

1201

825

def decorator(func):

1202

826

func._dbus_is_interface = True

1203

827

func._dbus_interface = dbus_interface

1204

828

func._dbus_name = dbus_interface

1205

829

return func

1206

1207

830

return decorator

1208

831

1209

832

1210

833

def dbus_annotations(annotations):

1211

834

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

1212

835

Usage:

1213

1214

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

1215

"org.freedesktop.DBus.Property."

1216

"EmitsChangedSignal": "false"})

836

1217

837

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

1218

838

access="r")

839

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

840

"org.freedesktop.DBus.Property."

841

"EmitsChangedSignal": "false"})

1219

842

def Property_dbus_property(self):

1220

843

return dbus.Boolean(False)

1221

1222

See also the DBusObjectWithAnnotations class.

1223

844

"""

1224

1225

845

def decorator(func):

1226

846

func._dbus_annotations = annotations

1227

847

return func

1228

1229

848

return decorator

1230

849

1231

850

1232

851

class DBusPropertyException(dbus.exceptions.DBusException):

1233

852

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

1234

853

"""

1235

pass

854

def __unicode__(self):

855

return unicode(str(self))

1236

856

1237

857

1238

858

class DBusPropertyAccessException(DBusPropertyException):

1247

867

pass

1248

868

1249

869

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.

870

class DBusObjectWithProperties(dbus.service.Object):

871

"""A D-Bus object with properties.

872

873

Classes inheriting from this can use the dbus_service_property

874

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

875

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

1255

876

"""

1256

877

1257

878

@staticmethod

1258

879

def _is_dbus_thing(thing):

1259

880

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

1260

881

1261

882

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

1262

883

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

1263

884

"""

1264

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

885

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

1265

886

False)

1266

887

1267

888

def _get_all_dbus_things(self, thing):

1268

889

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

1269

890

"""

1270

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

891

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

892

name),

1271

893

athing.__get__(self))

1272

894

for cls in self.__class__.__mro__

1273

895

for name, athing in

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

896

inspect.getmembers(cls,

897

self._is_dbus_thing(thing)))

898

1347

899

def _get_dbus_property(self, interface_name, property_name):

1348

900

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

1349

901

property with the specified name and interface.

1350

902

"""

1351

for cls in self.__class__.__mro__:

1352

for name, value in inspect.getmembers(

1353

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

903

for cls in self.__class__.__mro__:

904

for name, value in (inspect.getmembers

905

(cls,

906

self._is_dbus_thing("property"))):

1354

907

if (value._dbus_name == property_name

1355

908

and value._dbus_interface == interface_name):

1356

909

return value.__get__(self)

1357

910

1358

911

# No such property

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

912

raise DBusPropertyNotFound(self.dbus_object_path + ":"

913

+ interface_name + "."

914

+ property_name)

915

916

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

1373

917

out_signature="v")

1374

918

def Get(self, interface_name, property_name):

1375

919

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

1381

925

if not hasattr(value, "variant_level"):

1382

926

return value

1383

927

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

1384

928

1385

929

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

1386

930

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

1387

931

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

1394

938

# signatures other than "ay".

1395

939

if prop._dbus_signature != "ay":

1396

940

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

1397

"'ay' signature {!r}"

941

"'ay' signature {0!r}"

1398

942

.format(prop._dbus_signature))

1399

943

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

1400

944

for byte in value))

1401

945

prop(value)

1402

1403

@dbus.service.method(dbus.PROPERTIES_IFACE,

1404

in_signature="s",

946

947

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

1405

948

out_signature="a{sv}")

1406

949

def GetAll(self, interface_name):

1407

950

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

1408

951

standard.

1409

952

1410

953

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

1411

954

"""

1412

955

properties = {}

1422

965

if not hasattr(value, "variant_level"):

1423

966

properties[name] = value

1424

967

continue

1425

properties[name] = type(value)(

1426

value, variant_level=value.variant_level + 1)

968

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

969

value.variant_level+1)

1427

970

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

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

971

1437

972

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1438

973

out_signature="s",

1439

974

path_keyword='object_path',

1440

975

connection_keyword='connection')

1441

976

def Introspect(self, object_path, connection):

1442

977

"""Overloading of standard D-Bus method.

1443

978

1444

979

Inserts property tags and interface annotation tags.

1445

980

"""

1446

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1447

object_path,

1448

connection)

981

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

982

connection)

1449

983

try:

1450

984

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

1451

1452

985

def make_tag(document, name, prop):

1453

986

e = document.createElement("property")

1454

987

e.setAttribute("name", name)

1455

988

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

1456

989

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

1457

990

return e

1458

1459

991

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

1460

992

# Add property tags

1461

993

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

1464

996

if prop._dbus_interface

1465

997

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

1466

998

if_tag.appendChild(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)

999

# Add annotation tags

1000

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

1001

for tag in if_tag.getElementsByTagName(typ):

1002

annots = dict()

1003

for name, prop in (self.

1004

_get_all_dbus_things(typ)):

1005

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

1006

and prop._dbus_interface

1007

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

1008

annots.update(getattr

1009

(prop,

1010

"_dbus_annotations",

1011

{}))

1012

for name, value in annots.iteritems():

1013

ann_tag = document.createElement(

1014

"annotation")

1015

ann_tag.setAttribute("name", name)

1016

ann_tag.setAttribute("value", value)

1017

tag.appendChild(ann_tag)

1018

# Add interface annotation tags

1019

for annotation, value in dict(

1020

itertools.chain.from_iterable(

1021

annotations().iteritems()

1022

for name, annotations in

1023

self._get_all_dbus_things("interface")

1024

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

1025

)).iteritems():

1026

ann_tag = document.createElement("annotation")

1027

ann_tag.setAttribute("name", annotation)

1028

ann_tag.setAttribute("value", value)

1029

if_tag.appendChild(ann_tag)

1483

1030

# Add the names to the return values for the

1484

1031

# "org.freedesktop.DBus.Properties" methods

1485

1032

if (if_tag.getAttribute("name")

1504

1051

return xmlstring

1505

1052

1506

1053

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

1578

1054

def datetime_to_dbus(dt, variant_level=0):

1579

1055

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

1580

1056

if dt is None:

1581

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

1582

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

1057

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

1058

return dbus.String(dt.isoformat(),

1059

variant_level=variant_level)

1583

1060

1584

1061

1585

1062

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1587

1064

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

1588

1065

interface names according to the "alt_interface_names" mapping.

1589

1066

Usage:

1590

1067

1591

1068

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

1592

1069

"net.example.AlternateInterface"})

1593

1070

class SampleDBusObject(dbus.service.Object):

1594

1071

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

1595

1072

def SampleDBusMethod():

1596

1073

pass

1597

1074

1598

1075

The above "SampleDBusMethod" on "SampleDBusObject" will be

1599

1076

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

1600

1077

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

1601

1078

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

1602

1079

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

1603

1080

1604

1081

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

1605

1082

(from DBusObjectWithProperties) and interfaces (from the

1606

1083

dbus_interface_annotations decorator).

1607

1084

"""

1608

1609

1085

def wrapper(cls):

1610

1086

for orig_interface_name, alt_interface_name in (

1611

alt_interface_names.items()):

1087

alt_interface_names.iteritems()):

1612

1088

attr = {}

1613

1089

interface_names = set()

1614

1090

# Go though all attributes of the class

1616

1092

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

1617

1093

# with the wrong interface name

1618

1094

if (not hasattr(attribute, "_dbus_interface")

1619

or not attribute._dbus_interface.startswith(

1620

orig_interface_name)):

1095

or not attribute._dbus_interface

1096

.startswith(orig_interface_name)):

1621

1097

continue

1622

1098

# Create an alternate D-Bus interface name based on

1623

1099

# the current name

1624

alt_interface = attribute._dbus_interface.replace(

1625

orig_interface_name, alt_interface_name)

1100

alt_interface = (attribute._dbus_interface

1101

.replace(orig_interface_name,

1102

alt_interface_name))

1626

1103

interface_names.add(alt_interface)

1627

1104

# Is this a D-Bus signal?

1628

1105

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

1629

1106

# Extract the original non-method undecorated

1630

1107

# function by black magic

1631

if sys.version_info.major == 2:

1632

nonmethod_func = (dict(

1108

nonmethod_func = (dict(

1633

1109

zip(attribute.func_code.co_freevars,

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)

1110

attribute.__closure__))["func"]

1111

.cell_contents)

1641

1112

# Create a new, but exactly alike, function

1642

1113

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

1643

1114

# with the alternate D-Bus interface name

1644

new_function = copy_function(nonmethod_func)

1645

new_function = (dbus.service.signal(

1646

alt_interface,

1647

attribute._dbus_signature)(new_function))

1115

new_function = (dbus.service.signal

1116

(alt_interface,

1117

attribute._dbus_signature)

1118

(types.FunctionType(

1119

nonmethod_func.func_code,

1120

nonmethod_func.func_globals,

1121

nonmethod_func.func_name,

1122

nonmethod_func.func_defaults,

1123

nonmethod_func.func_closure)))

1648

1124

# Copy annotations, if any

1649

1125

try:

1650

new_function._dbus_annotations = dict(

1651

attribute._dbus_annotations)

1126

new_function._dbus_annotations = (

1127

dict(attribute._dbus_annotations))

1652

1128

except AttributeError:

1653

1129

pass

1654

1655

1130

# Define a creator of a function to call both the

1656

1131

# original and alternate functions, so both the

1657

1132

# original and alternate signals gets sent when

1660

1135

"""This function is a scope container to pass

1661

1136

func1 and func2 to the "call_both" function

1662

1137

outside of its arguments"""

1663

1664

@functools.wraps(func2)

1665

1138

def call_both(*args, **kwargs):

1666

1139

"""This function will emit two D-Bus

1667

1140

signals by calling func1 and func2"""

1668

1141

func1(*args, **kwargs)

1669

1142

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

1676

1143

return call_both

1677

1144

# Create the "call_both" function and add it to

1678

1145

# the class

1683

1150

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

1684

1151

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

1685

1152

# to the class.

1686

attr[attrname] = (

1687

dbus.service.method(

1688

alt_interface,

1689

attribute._dbus_in_signature,

1690

attribute._dbus_out_signature)

1691

(copy_function(attribute)))

1153

attr[attrname] = (dbus.service.method

1154

(alt_interface,

1155

attribute._dbus_in_signature,

1156

attribute._dbus_out_signature)

1157

(types.FunctionType

1158

(attribute.func_code,

1159

attribute.func_globals,

1160

attribute.func_name,

1161

attribute.func_defaults,

1162

attribute.func_closure)))

1692

1163

# Copy annotations, if any

1693

1164

try:

1694

attr[attrname]._dbus_annotations = dict(

1695

attribute._dbus_annotations)

1165

attr[attrname]._dbus_annotations = (

1166

dict(attribute._dbus_annotations))

1696

1167

except AttributeError:

1697

1168

pass

1698

1169

# Is this a D-Bus property?

1701

1172

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

1702

1173

# property with the alternate D-Bus interface

1703

1174

# name. Add it to the class.

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

1175

attr[attrname] = (dbus_service_property

1176

(alt_interface,

1177

attribute._dbus_signature,

1178

attribute._dbus_access,

1179

attribute

1180

._dbus_get_args_options

1181

["byte_arrays"])

1182

(types.FunctionType

1183

(attribute.func_code,

1184

attribute.func_globals,

1185

attribute.func_name,

1186

attribute.func_defaults,

1187

attribute.func_closure)))

1710

1188

# Copy annotations, if any

1711

1189

try:

1712

attr[attrname]._dbus_annotations = dict(

1713

attribute._dbus_annotations)

1190

attr[attrname]._dbus_annotations = (

1191

dict(attribute._dbus_annotations))

1714

1192

except AttributeError:

1715

1193

pass

1716

1194

# Is this a D-Bus interface?

1719

1197

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

1720

1198

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

1721

1199

# to the class.

1722

attr[attrname] = (

1723

dbus_interface_annotations(alt_interface)

1724

(copy_function(attribute)))

1200

attr[attrname] = (dbus_interface_annotations

1201

(alt_interface)

1202

(types.FunctionType

1203

(attribute.func_code,

1204

attribute.func_globals,

1205

attribute.func_name,

1206

attribute.func_defaults,

1207

attribute.func_closure)))

1725

1208

if deprecate:

1726

1209

# Deprecate all alternate interfaces

1727

iname = "_AlternateDBusNames_interface_annotation{}"

1210

iname="_AlternateDBusNames_interface_annotation{0}"

1728

1211

for interface_name in interface_names:

1729

1730

1212

@dbus_interface_annotations(interface_name)

1731

1213

def func(self):

1732

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

1733

"true"}

1214

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

1215

"true" }

1734

1216

# Find an unused name

1735

1217

for aname in (iname.format(i)

1736

1218

for i in itertools.count()):

1740

1222

if interface_names:

1741

1223

# Replace the class with a new subclass of it with

1742

1224

# methods, signals, etc. as created above.

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)

1225

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

1226

(cls,), attr)

1749

1227

return cls

1750

1751

1228

return wrapper

1752

1229

1753

1230

1754

1231

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

1755

"se.bsnet.fukt.Mandos"})

1232

"se.bsnet.fukt.Mandos"})

1756

1233

class ClientDBus(Client, DBusObjectWithProperties):

1757

1234

"""A Client class using D-Bus

1758

1235

1759

1236

Attributes:

1760

1237

dbus_object_path: dbus.ObjectPath

1761

1238

bus: dbus.SystemBus()

1762

1239

"""

1763

1240

1764

1241

runtime_expansions = (Client.runtime_expansions

1765

+ ("dbus_object_path", ))

1766

1767

_interface = "se.recompile.Mandos.Client"

1768

1242

+ ("dbus_object_path",))

1243

1769

1244

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

1770

1771

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

1245

1246

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

1772

1247

self.bus = bus

1773

1248

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

1774

1249

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

1775

1250

# the D-Bus

1776

client_object_name = str(self.name).translate(

1251

client_object_name = unicode(self.name).translate(

1777

1252

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

1778

1253

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

1779

self.dbus_object_path = dbus.ObjectPath(

1780

"/clients/" + client_object_name)

1254

self.dbus_object_path = (dbus.ObjectPath

1255

("/clients/" + client_object_name))

1781

1256

DBusObjectWithProperties.__init__(self, self.bus,

1782

1257

self.dbus_object_path)

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

1258

1259

def notifychangeproperty(transform_func,

1260

dbus_name, type_func=lambda x: x,

1261

variant_level=1):

1789

1262

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

1790

1263

its changes to DBus.

1791

1264

1792

1265

transform_fun: Function that takes a value and a variant_level

1793

1266

and transforms it to a D-Bus type.

1794

1267

dbus_name: D-Bus name of the variable

1796

1269

to the D-Bus. Default: no transform

1797

1270

variant_level: D-Bus variant level. Default: 1

1798

1271

"""

1799

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

1800

1272

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

1801

1273

def setter(self, value):

1802

1274

if hasattr(self, "dbus_object_path"):

1803

1275

if (not hasattr(self, attrname) or

1804

1276

type_func(getattr(self, attrname, None))

1805

1277

!= type_func(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())

1278

dbus_value = transform_func(type_func(value),

1279

variant_level

1280

=variant_level)

1281

self.PropertyChanged(dbus.String(dbus_name),

1282

dbus_value)

1821

1283

setattr(self, attrname, value)

1822

1284

1823

1285

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

1824

1286

1825

1287

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1826

1288

approvals_pending = notifychangeproperty(dbus.Boolean,

1827

1289

"ApprovalPending",

1828

type_func=bool)

1290

type_func = bool)

1829

1291

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

1830

1292

last_enabled = notifychangeproperty(datetime_to_dbus,

1831

1293

"LastEnabled")

1832

checker = notifychangeproperty(

1833

dbus.Boolean, "CheckerRunning",

1834

type_func=lambda checker: checker is not None)

1294

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

1295

type_func = lambda checker:

1296

checker is not None)

1835

1297

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1836

1298

"LastCheckedOK")

1837

1299

last_checker_status = notifychangeproperty(dbus.Int16,

1840

1302

datetime_to_dbus, "LastApprovalRequest")

1841

1303

approved_by_default = notifychangeproperty(dbus.Boolean,

1842

1304

"ApprovedByDefault")

1843

approval_delay = notifychangeproperty(

1844

dbus.UInt64, "ApprovalDelay",

1845

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

1305

approval_delay = notifychangeproperty(dbus.UInt64,

1306

"ApprovalDelay",

1307

type_func =

1308

timedelta_to_milliseconds)

1846

1309

approval_duration = notifychangeproperty(

1847

1310

dbus.UInt64, "ApprovalDuration",

1848

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

1311

type_func = timedelta_to_milliseconds)

1849

1312

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

1850

timeout = notifychangeproperty(

1851

dbus.UInt64, "Timeout",

1852

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

1313

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

1314

type_func =

1315

timedelta_to_milliseconds)

1853

1316

extended_timeout = notifychangeproperty(

1854

1317

dbus.UInt64, "ExtendedTimeout",

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)

1318

type_func = timedelta_to_milliseconds)

1319

interval = notifychangeproperty(dbus.UInt64,

1320

"Interval",

1321

type_func =

1322

timedelta_to_milliseconds)

1859

1323

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

1860

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

1861

invalidate_only=True)

1862

1324

1863

1325

del notifychangeproperty

1864

1326

1865

1327

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

1866

1328

try:

1867

1329

self.remove_from_connection()

1870

1332

if hasattr(DBusObjectWithProperties, "__del__"):

1871

1333

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

1872

1334

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

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:

1335

1336

def checker_callback(self, pid, condition, command,

1337

*args, **kwargs):

1338

self.checker_callback_tag = None

1339

self.checker = None

1340

if os.WIFEXITED(condition):

1341

exitstatus = os.WEXITSTATUS(condition)

1881

1342

# Emit D-Bus signal

1882

1343

self.CheckerCompleted(dbus.Int16(exitstatus),

1883

# This is specific to GNU libC

1884

dbus.Int64(exitstatus << 8),

1344

dbus.Int64(condition),

1885

1345

dbus.String(command))

1886

1346

else:

1887

1347

# Emit D-Bus signal

1888

1348

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

1889

dbus.Int64(

1890

# This is specific to GNU libC

1891

(exitstatus << 8)

1892

| self.last_checker_signal),

1349

dbus.Int64(condition),

1893

1350

dbus.String(command))

1894

return ret

1895

1351

1352

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

1353

*args, **kwargs)

1354

1896

1355

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

1897

1356

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

1898

1357

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

1902

1361

# Emit D-Bus signal

1903

1362

self.CheckerStarted(self.current_checker_command)

1904

1363

return r

1905

1364

1906

1365

def _reset_approved(self):

1907

1366

self.approved = None

1908

1367

return False

1909

1368

1910

1369

def approve(self, value=True):

1911

1370

self.approved = value

1912

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

1913

* 1000), self._reset_approved)

1371

gobject.timeout_add(timedelta_to_milliseconds

1372

(self.approval_duration),

1373

self._reset_approved)

1914

1374

self.send_changedstate()

1915

1916

# D-Bus methods, signals & properties

1917

1918

# Interfaces

1919

1920

# Signals

1921

1375

1376

## D-Bus methods, signals & properties

1377

_interface = "se.recompile.Mandos.Client"

1378

1379

## Interfaces

1380

1381

@dbus_interface_annotations(_interface)

1382

def _foo(self):

1383

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

1384

"false"}

1385

1386

## Signals

1387

1922

1388

# CheckerCompleted - signal

1923

1389

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

1924

1390

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

1925

1391

"D-Bus signal"

1926

1392

pass

1927

1393

1928

1394

# CheckerStarted - signal

1929

1395

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

1930

1396

def CheckerStarted(self, command):

1931

1397

"D-Bus signal"

1932

1398

pass

1933

1399

1934

1400

# PropertyChanged - signal

1935

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

1936

1401

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

1937

1402

def PropertyChanged(self, property, value):

1938

1403

"D-Bus signal"

1939

1404

pass

1940

1405

1941

1406

# GotSecret - signal

1942

1407

@dbus.service.signal(_interface)

1943

1408

def GotSecret(self):

1946

1411

server to mandos-client

1947

1412

"""

1948

1413

pass

1949

1414

1950

1415

# Rejected - signal

1951

1416

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

1952

1417

def Rejected(self, reason):

1953

1418

"D-Bus signal"

1954

1419

pass

1955

1420

1956

1421

# NeedApproval - signal

1957

1422

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

1958

1423

def NeedApproval(self, timeout, default):

1959

1424

"D-Bus signal"

1960

1425

return self.need_approval()

1961

1962

# Methods

1963

1426

1427

## Methods

1428

1964

1429

# Approve - method

1965

1430

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

1966

1431

def Approve(self, value):

1967

1432

self.approve(value)

1968

1433

1969

1434

# CheckedOK - method

1970

1435

@dbus.service.method(_interface)

1971

1436

def CheckedOK(self):

1972

1437

self.checked_ok()

1973

1438

1974

1439

# Enable - method

1975

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

1976

1440

@dbus.service.method(_interface)

1977

1441

def Enable(self):

1978

1442

"D-Bus method"

1979

1443

self.enable()

1980

1444

1981

1445

# StartChecker - method

1982

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

1983

1446

@dbus.service.method(_interface)

1984

1447

def StartChecker(self):

1985

1448

"D-Bus method"

1986

1449

self.start_checker()

1987

1450

1988

1451

# Disable - method

1989

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

1990

1452

@dbus.service.method(_interface)

1991

1453

def Disable(self):

1992

1454

"D-Bus method"

1993

1455

self.disable()

1994

1456

1995

1457

# StopChecker - method

1996

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

1997

1458

@dbus.service.method(_interface)

1998

1459

def StopChecker(self):

1999

1460

self.stop_checker()

2000

2001

# Properties

2002

1461

1462

## Properties

1463

2003

1464

# ApprovalPending - property

2004

1465

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

2005

1466

def ApprovalPending_dbus_property(self):

2006

1467

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

2007

1468

2008

1469

# ApprovedByDefault - property

2009

@dbus_service_property(_interface,

2010

signature="b",

1470

@dbus_service_property(_interface, signature="b",

2011

1471

access="readwrite")

2012

1472

def ApprovedByDefault_dbus_property(self, value=None):

2013

1473

if value is None: # get

2014

1474

return dbus.Boolean(self.approved_by_default)

2015

1475

self.approved_by_default = bool(value)

2016

1476

2017

1477

# ApprovalDelay - property

2018

@dbus_service_property(_interface,

2019

signature="t",

1478

@dbus_service_property(_interface, signature="t",

2020

1479

access="readwrite")

2021

1480

def ApprovalDelay_dbus_property(self, value=None):

2022

1481

if value is None: # get

2023

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

2024

* 1000)

1482

return dbus.UInt64(self.approval_delay_milliseconds())

2025

1483

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

2026

1484

2027

1485

# ApprovalDuration - property

2028

@dbus_service_property(_interface,

2029

signature="t",

1486

@dbus_service_property(_interface, signature="t",

2030

1487

access="readwrite")

2031

1488

def ApprovalDuration_dbus_property(self, value=None):

2032

1489

if value is None: # get

2033

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

2034

* 1000)

1490

return dbus.UInt64(timedelta_to_milliseconds(

1491

self.approval_duration))

2035

1492

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

2036

1493

2037

1494

# Name - property

2038

@dbus_annotations(

2039

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

2040

1495

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

2041

1496

def Name_dbus_property(self):

2042

1497

return dbus.String(self.name)

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

1498

2051

1499

# Fingerprint - property

2052

@dbus_annotations(

2053

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

2054

1500

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

2055

1501

def Fingerprint_dbus_property(self):

2056

1502

return dbus.String(self.fingerprint)

2057

1503

2058

1504

# Host - property

2059

@dbus_service_property(_interface,

2060

signature="s",

1505

@dbus_service_property(_interface, signature="s",

2061

1506

access="readwrite")

2062

1507

def Host_dbus_property(self, value=None):

2063

1508

if value is None: # get

2064

1509

return dbus.String(self.host)

2065

self.host = str(value)

2066

1510

self.host = unicode(value)

1511

2067

1512

# Created - property

2068

@dbus_annotations(

2069

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

2070

1513

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

2071

1514

def Created_dbus_property(self):

2072

1515

return datetime_to_dbus(self.created)

2073

1516

2074

1517

# LastEnabled - property

2075

1518

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

2076

1519

def LastEnabled_dbus_property(self):

2077

1520

return datetime_to_dbus(self.last_enabled)

2078

1521

2079

1522

# Enabled - property

2080

@dbus_service_property(_interface,

2081

signature="b",

1523

@dbus_service_property(_interface, signature="b",

2082

1524

access="readwrite")

2083

1525

def Enabled_dbus_property(self, value=None):

2084

1526

if value is None: # get

2087

1529

self.enable()

2088

1530

else:

2089

1531

self.disable()

2090

1532

2091

1533

# LastCheckedOK - property

2092

@dbus_service_property(_interface,

2093

signature="s",

1534

@dbus_service_property(_interface, signature="s",

2094

1535

access="readwrite")

2095

1536

def LastCheckedOK_dbus_property(self, value=None):

2096

1537

if value is not None:

2097

1538

self.checked_ok()

2098

1539

return

2099

1540

return datetime_to_dbus(self.last_checked_ok)

2100

1541

2101

1542

# LastCheckerStatus - property

2102

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

1543

@dbus_service_property(_interface, signature="n",

1544

access="read")

2103

1545

def LastCheckerStatus_dbus_property(self):

2104

1546

return dbus.Int16(self.last_checker_status)

2105

1547

2106

1548

# Expires - property

2107

1549

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

2108

1550

def Expires_dbus_property(self):

2109

1551

return datetime_to_dbus(self.expires)

2110

1552

2111

1553

# LastApprovalRequest - property

2112

1554

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

2113

1555

def LastApprovalRequest_dbus_property(self):

2114

1556

return datetime_to_dbus(self.last_approval_request)

2115

1557

2116

1558

# Timeout - property

2117

@dbus_service_property(_interface,

2118

signature="t",

1559

@dbus_service_property(_interface, signature="t",

2119

1560

access="readwrite")

2120

1561

def Timeout_dbus_property(self, value=None):

2121

1562

if value is None: # get

2122

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

1563

return dbus.UInt64(self.timeout_milliseconds())

2123

1564

old_timeout = self.timeout

2124

1565

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

2125

1566

# Reschedule disabling

2133

1574

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

2134

1575

is None):

2135

1576

return

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

1577

gobject.source_remove(self.disable_initiator_tag)

1578

self.disable_initiator_tag = (

1579

gobject.timeout_add(

1580

timedelta_to_milliseconds(self.expires - now),

1581

self.disable))

1582

2141

1583

# ExtendedTimeout - property

2142

@dbus_service_property(_interface,

2143

signature="t",

1584

@dbus_service_property(_interface, signature="t",

2144

1585

access="readwrite")

2145

1586

def ExtendedTimeout_dbus_property(self, value=None):

2146

1587

if value is None: # get

2147

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

2148

* 1000)

1588

return dbus.UInt64(self.extended_timeout_milliseconds())

2149

1589

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

2150

1590

2151

1591

# Interval - property

2152

@dbus_service_property(_interface,

2153

signature="t",

1592

@dbus_service_property(_interface, signature="t",

2154

1593

access="readwrite")

2155

1594

def Interval_dbus_property(self, value=None):

2156

1595

if value is None: # get

2157

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

1596

return dbus.UInt64(self.interval_milliseconds())

2158

1597

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

2159

1598

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

2160

1599

return

2161

1600

if self.enabled:

2162

1601

# Reschedule checker run

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

1602

gobject.source_remove(self.checker_initiator_tag)

1603

self.checker_initiator_tag = (gobject.timeout_add

1604

(value, self.start_checker))

1605

self.start_checker() # Start one now, too

1606

2168

1607

# Checker - property

2169

@dbus_service_property(_interface,

2170

signature="s",

1608

@dbus_service_property(_interface, signature="s",

2171

1609

access="readwrite")

2172

1610

def Checker_dbus_property(self, value=None):

2173

1611

if value is None: # get

2174

1612

return dbus.String(self.checker_command)

2175

self.checker_command = str(value)

2176

1613

self.checker_command = unicode(value)

1614

2177

1615

# CheckerRunning - property

2178

@dbus_service_property(_interface,

2179

signature="b",

1616

@dbus_service_property(_interface, signature="b",

2180

1617

access="readwrite")

2181

1618

def CheckerRunning_dbus_property(self, value=None):

2182

1619

if value is None: # get

2185

1622

self.start_checker()

2186

1623

else:

2187

1624

self.stop_checker()

2188

1625

2189

1626

# ObjectPath - property

2190

@dbus_annotations(

2191

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

2192

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

2193

1627

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

2194

1628

def ObjectPath_dbus_property(self):

2195

return self.dbus_object_path # is already a dbus.ObjectPath

2196

1629

return self.dbus_object_path # is already a dbus.ObjectPath

1630

2197

1631

# Secret = property

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)

1632

@dbus_service_property(_interface, signature="ay",

1633

access="write", byte_arrays=True)

2205

1634

def Secret_dbus_property(self, value):

2206

self.secret = bytes(value)

2207

1635

self.secret = str(value)

1636

2208

1637

del _interface

2209

1638

2210

1639

2211

1640

class ProxyClient(object):

2212

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

1641

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

2213

1642

self._pipe = child_pipe

2214

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

1643

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

2215

1644

if not self._pipe.recv():

2216

raise KeyError(key_id or fpr)

2217

1645

raise KeyError()

1646

2218

1647

def __getattribute__(self, name):

2219

1648

if name == '_pipe':

2220

1649

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

2223

1652

if data[0] == 'data':

2224

1653

return data[1]

2225

1654

if data[0] == 'function':

2226

2227

1655

def func(*args, **kwargs):

2228

1656

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

2229

1657

return self._pipe.recv()[1]

2230

2231

1658

return func

2232

1659

2233

1660

def __setattr__(self, name, value):

2234

1661

if name == '_pipe':

2235

1662

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

2238

1665

2239

1666

class ClientHandler(socketserver.BaseRequestHandler, object):

2240

1667

"""A class to handle client connections.

2241

1668

2242

1669

Instantiated once for each connection to handle it.

2243

1670

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

2244

1671

2245

1672

def handle(self):

2246

1673

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

2247

1674

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

2248

str(self.client_address))

1675

unicode(self.client_address))

2249

1676

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

2250

1677

self.server.child_pipe.fileno())

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

1678

1679

session = (gnutls.connection

1680

.ClientSession(self.request,

1681

gnutls.connection

1682

.X509Credentials()))

1683

1684

# Note: gnutls.connection.X509Credentials is really a

1685

# generic GnuTLS certificate credentials object so long as

1686

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

1687

# here despite using OpenPGP certificates.

1688

1689

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

1690

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

1691

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

1692

# "+DHE-DSS"))

2258

1693

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

2259

1694

priority = self.server.gnutls_priority

2260

1695

if priority is None:

2261

1696

priority = "NORMAL"

2262

gnutls.priority_set_direct(session._c_object,

2263

priority.encode("utf-8"),

2264

None)

2265

1697

(gnutls.library.functions

1698

.gnutls_priority_set_direct(session._c_object,

1699

priority, None))

1700

2266

1701

# Start communication using the Mandos protocol

2267

1702

# Get protocol number

2268

1703

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

2273

1708

except (ValueError, IndexError, RuntimeError) as error:

2274

1709

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

2275

1710

return

2276

1711

2277

1712

# Start GnuTLS connection

2278

1713

try:

2279

1714

session.handshake()

2280

except gnutls.Error as error:

1715

except gnutls.errors.GNUTLSError as error:

2281

1716

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

2282

1717

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

2283

1718

# established. Just abandon the request.

2284

1719

return

2285

1720

logger.debug("Handshake succeeded")

2286

1721

2287

1722

approval_required = False

2288

1723

try:

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,

1724

try:

1725

fpr = self.fingerprint(self.peer_certificate

1726

(session))

1727

except (TypeError,

1728

gnutls.errors.GNUTLSError) as error:

1729

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

1730

return

1731

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

1732

1733

try:

1734

client = ProxyClient(child_pipe, fpr,

2311

1735

self.client_address)

2312

1736

except KeyError:

2313

1737

return

2314

1738

2315

1739

if client.approval_delay:

2316

1740

delay = client.approval_delay

2317

1741

client.approvals_pending += 1

2318

1742

approval_required = True

2319

1743

2320

1744

while True:

2321

1745

if not client.enabled:

2322

1746

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

2323

client.name)

1747

client.name)

2324

1748

if self.server.use_dbus:

2325

1749

# Emit D-Bus signal

2326

1750

client.Rejected("Disabled")

2327

1751

return

2328

1752

2329

1753

if client.approved or not client.approval_delay:

2330

# We are approved or approval is disabled

1754

#We are approved or approval is disabled

2331

1755

break

2332

1756

elif client.approved is None:

2333

1757

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

2335

1759

if self.server.use_dbus:

2336

1760

# Emit D-Bus signal

2337

1761

client.NeedApproval(

2338

client.approval_delay.total_seconds()

2339

* 1000, client.approved_by_default)

1762

client.approval_delay_milliseconds(),

1763

client.approved_by_default)

2340

1764

else:

2341

1765

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

2342

1766

client.name)

2344

1768

# Emit D-Bus signal

2345

1769

client.Rejected("Denied")

2346

1770

return

2347

2348

# wait until timeout or approved

1771

1772

#wait until timeout or approved

2349

1773

time = datetime.datetime.now()

2350

1774

client.changedstate.acquire()

2351

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

1775

client.changedstate.wait(

1776

float(timedelta_to_milliseconds(delay)

1777

/ 1000))

2352

1778

client.changedstate.release()

2353

1779

time2 = datetime.datetime.now()

2354

1780

if (time2 - time) >= delay:

2364

1790

break

2365

1791

else:

2366

1792

delay -= time2 - time

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

1793

1794

sent_size = 0

1795

while sent_size < len(client.secret):

1796

try:

1797

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

1798

except gnutls.errors.GNUTLSError as error:

1799

logger.warning("gnutls send failed",

1800

exc_info=error)

1801

return

1802

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

1803

sent, len(client.secret)

1804

- (sent_size + sent))

1805

sent_size += sent

1806

2375

1807

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

2376

1808

# bump the timeout using extended_timeout

2377

1809

client.bump_timeout(client.extended_timeout)

2378

1810

if self.server.use_dbus:

2379

1811

# Emit D-Bus signal

2380

1812

client.GotSecret()

2381

1813

2382

1814

finally:

2383

1815

if approval_required:

2384

1816

client.approvals_pending -= 1

2385

1817

try:

2386

1818

session.bye()

2387

except gnutls.Error as error:

1819

except gnutls.errors.GNUTLSError as error:

2388

1820

logger.warning("GnuTLS bye failed",

2389

1821

exc_info=error)

2390

1822

2391

1823

@staticmethod

2392

1824

def peer_certificate(session):

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

1825

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

1826

# If not an OpenPGP certificate...

1827

if (gnutls.library.functions

1828

.gnutls_certificate_type_get(session._c_object)

1829

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1830

# ...do the normal thing

1831

return session.peer_certificate

2409

1832

list_size = ctypes.c_uint(1)

2410

cert_list = (gnutls.certificate_get_peers

1833

cert_list = (gnutls.library.functions

1834

.gnutls_certificate_get_peers

2411

1835

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

2412

1836

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

2413

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

1837

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

1838

" certificate")

2414

1839

if list_size.value == 0:

2415

1840

return None

2416

1841

cert = cert_list[0]

2417

1842

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

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

1843

2453

1844

@staticmethod

2454

1845

def fingerprint(openpgp):

2455

1846

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2456

1847

# New GnuTLS "datum" with the OpenPGP public key

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

1848

datum = (gnutls.library.types

1849

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

1850

ctypes.POINTER

1851

(ctypes.c_ubyte)),

1852

ctypes.c_uint(len(openpgp))))

2461

1853

# New empty GnuTLS certificate

2462

crt = gnutls.openpgp_crt_t()

2463

gnutls.openpgp_crt_init(ctypes.byref(crt))

1854

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1855

(gnutls.library.functions

1856

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

2464

1857

# Import the OpenPGP public key into the certificate

2465

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

2466

gnutls.OPENPGP_FMT_RAW)

1858

(gnutls.library.functions

1859

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

1860

gnutls.library.constants

1861

.GNUTLS_OPENPGP_FMT_RAW))

2467

1862

# Verify the self signature in the key

2468

1863

crtverify = ctypes.c_uint()

2469

gnutls.openpgp_crt_verify_self(crt, 0,

2470

ctypes.byref(crtverify))

1864

(gnutls.library.functions

1865

.gnutls_openpgp_crt_verify_self(crt, 0,

1866

ctypes.byref(crtverify)))

2471

1867

if crtverify.value != 0:

2472

gnutls.openpgp_crt_deinit(crt)

2473

raise gnutls.CertificateSecurityError(code

2474

=crtverify.value)

1868

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1869

raise (gnutls.errors.CertificateSecurityError

1870

("Verify failed"))

2475

1871

# New buffer for the fingerprint

2476

1872

buf = ctypes.create_string_buffer(20)

2477

1873

buf_len = ctypes.c_size_t()

2478

1874

# Get the fingerprint from the certificate into the buffer

2479

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

2480

ctypes.byref(buf_len))

1875

(gnutls.library.functions

1876

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

1877

ctypes.byref(buf_len)))

2481

1878

# Deinit the certificate

2482

gnutls.openpgp_crt_deinit(crt)

1879

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2483

1880

# Convert the buffer to a Python bytestring

2484

1881

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

2485

1882

# Convert the bytestring to hexadecimal notation

2489

1886

2490

1887

class MultiprocessingMixIn(object):

2491

1888

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

2492

2493

1889

def sub_process_main(self, request, address):

2494

1890

try:

2495

1891

self.finish_request(request, address)

2496

1892

except Exception:

2497

1893

self.handle_error(request, address)

2498

1894

self.close_request(request)

2499

1895

2500

1896

def process_request(self, request, address):

2501

1897

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

2502

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

2503

args=(request, address))

1898

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

1899

args = (request, address))

2504

1900

proc.start()

2505

1901

return proc

2506

1902

2507

1903

2508

1904

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2509

1905

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

2510

2511

1906

def process_request(self, request, client_address):

2512

1907

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

2513

1908

2514

1909

This function creates a new pipe in self.pipe

2515

1910

"""

2516

1911

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2517

1912

2518

1913

proc = MultiprocessingMixIn.process_request(self, request,

2519

1914

client_address)

2520

1915

self.child_pipe.close()

2521

1916

self.add_pipe(parent_pipe, proc)

2522

1917

2523

1918

def add_pipe(self, parent_pipe, proc):

2524

1919

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

2525

1920

raise NotImplementedError()

2528

1923

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2529

1924

socketserver.TCPServer, object):

2530

1925

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

2531

1926

2532

1927

Attributes:

2533

1928

enabled: Boolean; whether this server is activated yet

2534

1929

interface: None or a network interface name (string)

2535

1930

use_ipv6: Boolean; to use IPv6 or not

2536

1931

"""

2537

2538

1932

def __init__(self, server_address, RequestHandlerClass,

2539

interface=None,

2540

use_ipv6=True,

2541

socketfd=None):

1933

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

2542

1934

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

2543

1935

creating a new one with socket.socket().

2544

1936

"""

2550

1942

self.socketfd = socketfd

2551

1943

# Save the original socket.socket() function

2552

1944

self.socket_socket = socket.socket

2553

2554

1945

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

2555

#

1946

#

2556

1947

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

2557

1948

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

2558

1949

# patching socket.socket.)

2559

#

1950

#

2560

1951

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

2561

1952

@functools.wraps(socket.socket)

2562

1953

def socket_wrapper(*args, **kwargs):

2574

1965

# socket_wrapper(), if socketfd was set.

2575

1966

socketserver.TCPServer.__init__(self, server_address,

2576

1967

RequestHandlerClass)

2577

1968

2578

1969

def server_bind(self):

2579

1970

"""This overrides the normal server_bind() function

2580

1971

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

2581

1972

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

2582

global SO_BINDTODEVICE

2583

1973

if self.interface is not None:

2584

1974

if SO_BINDTODEVICE is None:

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

1975

logger.error("SO_BINDTODEVICE does not exist;"

1976

" cannot bind to interface %s",

1977

self.interface)

1978

else:

1979

try:

1980

self.socket.setsockopt(socket.SOL_SOCKET,

1981

SO_BINDTODEVICE,

1982

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

1983

except socket.error as error:

1984

if error.errno == errno.EPERM:

1985

logger.error("No permission to bind to"

1986

" interface %s", self.interface)

1987

elif error.errno == errno.ENOPROTOOPT:

1988

logger.error("SO_BINDTODEVICE not available;"

1989

" cannot bind to interface %s",

1990

self.interface)

1991

elif error.errno == errno.ENODEV:

1992

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

1993

" cannot bind", self.interface)

1994

else:

1995

raise

2606

1996

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

2607

1997

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

2608

1998

if not self.server_address[0]:

2609

1999

if self.address_family == socket.AF_INET6:

2610

any_address = "::" # in6addr_any

2000

any_address = "::" # in6addr_any

2611

2001

else:

2612

any_address = "0.0.0.0" # INADDR_ANY

2002

any_address = "0.0.0.0" # INADDR_ANY

2613

2003

self.server_address = (any_address,

2614

2004

self.server_address[1])

2615

2005

elif not self.server_address[1]:

2616

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

2006

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

2007

0)

2617

2008

# if self.interface:

2618

2009

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

2619

2010

# 0, # port

2625

2016

2626

2017

class MandosServer(IPv6_TCPServer):

2627

2018

"""Mandos server.

2628

2019

2629

2020

Attributes:

2630

2021

clients: set of Client objects

2631

2022

gnutls_priority GnuTLS priority string

2632

2023

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

2633

2634

Assumes a GLib.MainLoop event loop.

2024

2025

Assumes a gobject.MainLoop event loop.

2635

2026

"""

2636

2637

2027

def __init__(self, server_address, RequestHandlerClass,

2638

interface=None,

2639

use_ipv6=True,

2640

clients=None,

2641

gnutls_priority=None,

2642

use_dbus=True,

2643

socketfd=None):

2028

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

2029

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

2644

2030

self.enabled = False

2645

2031

self.clients = clients

2646

2032

if self.clients is None:

2649

2035

self.gnutls_priority = gnutls_priority

2650

2036

IPv6_TCPServer.__init__(self, server_address,

2651

2037

RequestHandlerClass,

2652

interface=interface,

2653

use_ipv6=use_ipv6,

2654

socketfd=socketfd)

2655

2038

interface = interface,

2039

use_ipv6 = use_ipv6,

2040

socketfd = socketfd)

2656

2041

def server_activate(self):

2657

2042

if self.enabled:

2658

2043

return socketserver.TCPServer.server_activate(self)

2659

2044

2660

2045

def enable(self):

2661

2046

self.enabled = True

2662

2047

2663

2048

def add_pipe(self, parent_pipe, proc):

2664

2049

# Call "handle_ipc" for both data and EOF events

2665

GLib.io_add_watch(

2666

parent_pipe.fileno(),

2667

GLib.IO_IN | GLib.IO_HUP,

2668

functools.partial(self.handle_ipc,

2669

parent_pipe=parent_pipe,

2670

proc=proc))

2671

2672

def handle_ipc(self, source, condition,

2673

parent_pipe=None,

2674

proc=None,

2675

client_object=None):

2050

gobject.io_add_watch(parent_pipe.fileno(),

2051

gobject.IO_IN | gobject.IO_HUP,

2052

functools.partial(self.handle_ipc,

2053

parent_pipe =

2054

parent_pipe,

2055

proc = proc))

2056

2057

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

2058

proc = None, client_object=None):

2676

2059

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

2677

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

2060

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

2678

2061

# Wait for other process to exit

2679

2062

proc.join()

2680

2063

return False

2681

2064

2682

2065

# Read a request from the child

2683

2066

request = parent_pipe.recv()

2684

2067

command = request[0]

2685

2068

2686

2069

if command == 'init':

2687

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

2688

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

2689

address = request[3]

2690

2691

for c in self.clients.values():

2692

if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":

2693

continue

2694

if key_id and c.key_id == key_id:

2695

client = c

2696

break

2697

if fpr and c.fingerprint == fpr:

2070

fpr = request[1]

2071

address = request[2]

2072

2073

for c in self.clients.itervalues():

2074

if c.fingerprint == fpr:

2698

2075

client = c

2699

2076

break

2700

2077

else:

2701

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

2702

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

2078

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

2079

"dress: %s", fpr, address)

2703

2080

if self.use_dbus:

2704

2081

# Emit D-Bus signal

2705

mandos_dbus_service.ClientNotFound(key_id or fpr,

2082

mandos_dbus_service.ClientNotFound(fpr,

2706

2083

address[0])

2707

2084

parent_pipe.send(False)

2708

2085

return False

2709

2710

GLib.io_add_watch(

2711

parent_pipe.fileno(),

2712

GLib.IO_IN | GLib.IO_HUP,

2713

functools.partial(self.handle_ipc,

2714

parent_pipe=parent_pipe,

2715

proc=proc,

2716

client_object=client))

2086

2087

gobject.io_add_watch(parent_pipe.fileno(),

2088

gobject.IO_IN | gobject.IO_HUP,

2089

functools.partial(self.handle_ipc,

2090

parent_pipe =

2091

parent_pipe,

2092

proc = proc,

2093

client_object =

2094

client))

2717

2095

parent_pipe.send(True)

2718

2096

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

2719

2097

# same fileno

2722

2100

funcname = request[1]

2723

2101

args = request[2]

2724

2102

kwargs = request[3]

2725

2103

2726

2104

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

2727

2105

funcname)(*args,

2728

**kwargs)))

2729

2106

**kwargs)))

2107

2730

2108

if command == 'getattr':

2731

2109

attrname = request[1]

2732

if isinstance(client_object.__getattribute__(attrname),

2733

collections.Callable):

2734

parent_pipe.send(('function', ))

2110

if callable(client_object.__getattribute__(attrname)):

2111

parent_pipe.send(('function',))

2735

2112

else:

2736

parent_pipe.send((

2737

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

2738

2113

parent_pipe.send(('data', client_object

2114

.__getattribute__(attrname)))

2115

2739

2116

if command == 'setattr':

2740

2117

attrname = request[1]

2741

2118

value = request[2]

2742

2119

setattr(client_object, attrname, value)

2743

2120

2744

2121

return True

2745

2122

2746

2123

2747

2124

def rfc3339_duration_to_delta(duration):

2748

2125

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

2749

2126

2750

2127

>>> rfc3339_duration_to_delta("P7D")

2751

2128

datetime.timedelta(7)

2752

2129

>>> rfc3339_duration_to_delta("PT60S")

2762

2139

>>> rfc3339_duration_to_delta("P1DT3M20S")

2763

2140

datetime.timedelta(1, 200)

2764

2141

"""

2765

2142

2766

2143

# Parsing an RFC 3339 duration with regular expressions is not

2767

2144

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

2768

2145

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

2769

2146

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

2770

2147

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

2771

2148

# avoid excessive use of external libraries.

2772

2149

2773

2150

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

2774

Token = collections.namedtuple("Token", (

2775

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

2776

# a "group" containing digits

2777

"value", # datetime.timedelta or None

2778

"followers")) # Tokens valid after this token

2151

Token = collections.namedtuple("Token",

2152

("regexp", # To match token; if

2153

# "value" is not None,

2154

# must have a "group"

2155

# containing digits

2156

"value", # datetime.timedelta or

2157

# None

2158

"followers")) # Tokens valid after

2159

# this token

2779

2160

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

2780

2161

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

2781

2162

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

2782

2163

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

2783

2164

datetime.timedelta(seconds=1),

2784

frozenset((token_end, )))

2165

frozenset((token_end,)))

2785

2166

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

2786

2167

datetime.timedelta(minutes=1),

2787

2168

frozenset((token_second, token_end)))

2803

2184

frozenset((token_month, token_end)))

2804

2185

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

2805

2186

datetime.timedelta(weeks=1),

2806

frozenset((token_end, )))

2187

frozenset((token_end,)))

2807

2188

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

2808

2189

frozenset((token_year, token_month,

2809

2190

token_day, token_time,

2810

token_week)))

2811

# Define starting values:

2812

# Value so far

2813

value = datetime.timedelta()

2191

token_week))),

2192

# Define starting values

2193

value = datetime.timedelta() # Value so far

2814

2194

found_token = None

2815

# Following valid tokens

2816

followers = frozenset((token_duration, ))

2817

# String left to parse

2818

s = duration

2195

followers = frozenset(token_duration,) # Following valid tokens

2196

s = duration # String left to parse

2819

2197

# Loop until end token is found

2820

2198

while found_token is not token_end:

2821

2199

# Search for any currently valid tokens

2837

2215

break

2838

2216

else:

2839

2217

# No currently valid tokens were found

2840

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

2841

.format(duration))

2218

raise ValueError("Invalid RFC 3339 duration")

2842

2219

# End token found

2843

2220

return value

2844

2221

2845

2222

2846

2223

def string_to_delta(interval):

2847

2224

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

2848

2225

2849

2226

>>> string_to_delta('7d')

2850

2227

datetime.timedelta(7)

2851

2228

>>> string_to_delta('60s')

2859

2236

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

2860

2237

datetime.timedelta(0, 330)

2861

2238

"""

2862

2239

2863

2240

try:

2864

2241

return rfc3339_duration_to_delta(interval)

2865

2242

except ValueError:

2866

2243

pass

2867

2244

2868

2245

timevalue = datetime.timedelta(0)

2869

2246

for s in interval.split():

2870

2247

try:

2871

suffix = s[-1]

2248

suffix = unicode(s[-1])

2872

2249

value = int(s[:-1])

2873

2250

if suffix == "d":

2874

2251

delta = datetime.timedelta(value)

2881

2258

elif suffix == "w":

2882

2259

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

2883

2260

else:

2884

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

2261

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

2262

.format(suffix))

2885

2263

except IndexError as e:

2886

2264

raise ValueError(*(e.args))

2887

2265

timevalue += delta

2888

2266

return timevalue

2889

2267

2890

2268

2891

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

2269

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

2892

2270

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

2893

2271

2894

2272

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

2895

2273

if os.fork():

2896

2274

sys.exit()

2904

2282

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

2905

2283

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

2906

2284

raise OSError(errno.ENODEV,

2907

"{} not a character device"

2285

"{0} not a character device"

2908

2286

.format(os.devnull))

2909

2287

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

2910

2288

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

2914

2292

2915

2293

2916

2294

def main():

2917

2295

2918

2296

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

2919

2297

# Parsing of options, both command line and config file

2920

2298

2921

2299

parser = argparse.ArgumentParser()

2922

2300

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

2923

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

2301

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

2924

2302

help="show version number and exit")

2925

2303

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

2926

2304

help="Bind to interface IF")

2962

2340

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

2963

2341

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

2964

2342

default=None)

2965

2343

2966

2344

options = parser.parse_args()

2967

2345

2968

2346

if options.check:

2969

2347

import doctest

2970

2348

fail_count, test_count = doctest.testmod()

2971

2349

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

2972

2350

2973

2351

# Default values for config file for server-global settings

2974

if gnutls.has_rawpk:

2975

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

2976

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

2977

else:

2978

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

2979

":+SIGN-DSA-SHA256")

2980

server_defaults = {"interface": "",

2981

"address": "",

2982

"port": "",

2983

"debug": "False",

2984

"priority": priority,

2985

"servicename": "Mandos",

2986

"use_dbus": "True",

2987

"use_ipv6": "True",

2988

"debuglevel": "",

2989

"restore": "True",

2990

"socket": "",

2991

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

2992

"foreground": "False",

2993

"zeroconf": "True",

2994

}

2995

del priority

2996

2352

server_defaults = { "interface": "",

2353

"address": "",

2354

"port": "",

2355

"debug": "False",

2356

"priority":

2357

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

2358

"servicename": "Mandos",

2359

"use_dbus": "True",

2360

"use_ipv6": "True",

2361

"debuglevel": "",

2362

"restore": "True",

2363

"socket": "",

2364

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

2365

"foreground": "False",

2366

"zeroconf": "True",

2367

}

2368

2997

2369

# Parse config file for server-global settings

2998

2370

server_config = configparser.SafeConfigParser(server_defaults)

2999

2371

del server_defaults

3000

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

2372

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

2373

"mandos.conf"))

3001

2374

# Convert the SafeConfigParser object to a dict

3002

2375

server_settings = server_config.defaults()

3003

2376

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

3004

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

3005

"foreground", "zeroconf"):

2377

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

3006

2378

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

3007

2379

option)

3008

2380

if server_settings["port"]:

3018

2390

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

3019

2391

["socket"])

3020

2392

del server_config

3021

2393

3022

2394

# Override the settings from the config file with command line

3023

2395

# options, if set.

3024

2396

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

3025

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

3026

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

3027

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

2397

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

2398

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

2399

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

3028

2400

value = getattr(options, option)

3029

2401

if value is not None:

3030

2402

server_settings[option] = value

3031

2403

del options

3032

2404

# Force all strings to be unicode

3033

2405

for option in server_settings.keys():

3034

if isinstance(server_settings[option], bytes):

3035

server_settings[option] = (server_settings[option]

3036

.decode("utf-8"))

2406

if type(server_settings[option]) is str:

2407

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

3037

2408

# Force all boolean options to be boolean

3038

2409

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

3039

2410

"foreground", "zeroconf"):

3042

2413

if server_settings["debug"]:

3043

2414

server_settings["foreground"] = True

3044

2415

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

3045

2416

3046

2417

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

3047

3048

if (not server_settings["zeroconf"]

3049

and not (server_settings["port"]

3050

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

3051

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

3052

2418

2419

if (not server_settings["zeroconf"] and

2420

not (server_settings["port"]

2421

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

2422

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

2423

" Zeroconf")

2424

3053

2425

# For convenience

3054

2426

debug = server_settings["debug"]

3055

2427

debuglevel = server_settings["debuglevel"]

3059

2431

stored_state_file)

3060

2432

foreground = server_settings["foreground"]

3061

2433

zeroconf = server_settings["zeroconf"]

3062

2434

3063

2435

if debug:

3064

2436

initlogger(debug, logging.DEBUG)

3065

2437

else:

3068

2440

else:

3069

2441

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

3070

2442

initlogger(debug, level)

3071

2443

3072

2444

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

3073

syslogger.setFormatter(

3074

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

3075

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

3076

server_settings["servicename"])))

3077

2445

syslogger.setFormatter(logging.Formatter

2446

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

2447

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

2448

.format(server_settings

2449

["servicename"])))

2450

3078

2451

# Parse config file with clients

3079

2452

client_config = configparser.SafeConfigParser(Client

3080

2453

.client_defaults)

3081

2454

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

3082

2455

"clients.conf"))

3083

2456

3084

2457

global mandos_dbus_service

3085

2458

mandos_dbus_service = None

3086

2459

3087

2460

socketfd = None

3088

2461

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

3089

2462

socketfd = server_settings["socket"]

3090

tcp_server = MandosServer(

3091

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

3092

ClientHandler,

3093

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

3094

use_ipv6=use_ipv6,

3095

gnutls_priority=server_settings["priority"],

3096

use_dbus=use_dbus,

3097

socketfd=socketfd)

2463

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

2464

server_settings["port"]),

2465

ClientHandler,

2466

interface=(server_settings["interface"]

2467

or None),

2468

use_ipv6=use_ipv6,

2469

gnutls_priority=

2470

server_settings["priority"],

2471

use_dbus=use_dbus,

2472

socketfd=socketfd)

3098

2473

if not foreground:

3099

2474

pidfilename = "/run/mandos.pid"

3100

2475

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

3101

2476

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

3102

2477

pidfile = None

3103

2478

try:

3104

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

2479

pidfile = open(pidfilename, "w")

3105

2480

except IOError as e:

3106

2481

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

3107

2482

exc_info=e)

3108

3109

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

3110

("mandos", "mandos"),

3111

("nobody", "nogroup")):

2483

2484

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

3112

2485

try:

3113

2486

uid = pwd.getpwnam(name).pw_uid

3114

gid = pwd.getpwnam(group).pw_gid

2487

gid = pwd.getpwnam(name).pw_gid

3115

2488

break

3116

2489

except KeyError:

3117

2490

continue

3121

2494

try:

3122

2495

os.setgid(gid)

3123

2496

os.setuid(uid)

3124

if debug:

3125

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

3126

gid))

3127

2497

except OSError as error:

3128

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

3129

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

3130

2498

if error.errno != errno.EPERM:

3131

2499

raise

3132

2500

3133

2501

if debug:

3134

2502

# Enable all possible GnuTLS debugging

3135

2503

3136

2504

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

3137

2505

# - GnuTLS manual

3138

gnutls.global_set_log_level(11)

3139

3140

@gnutls.log_func

2506

gnutls.library.functions.gnutls_global_set_log_level(11)

2507

2508

@gnutls.library.types.gnutls_log_func

3141

2509

def debug_gnutls(level, string):

3142

2510

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

3143

3144

gnutls.global_set_log_function(debug_gnutls)

3145

2511

2512

(gnutls.library.functions

2513

.gnutls_global_set_log_function(debug_gnutls))

2514

3146

2515

# Redirect stdin so all checkers get /dev/null

3147

2516

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

3148

2517

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

3149

2518

if null > 2:

3150

2519

os.close(null)

3151

2520

3152

2521

# Need to fork before connecting to D-Bus

3153

2522

if not foreground:

3154

2523

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

3155

2524

daemon()

3156

3157

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

3158

# to inform GLib that threads will be used.

3159

GLib.threads_init()

3160

2525

2526

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

2527

# need to inform gobject that threads will be used.

2528

gobject.threads_init()

2529

3161

2530

global main_loop

3162

2531

# From the Avahi example code

3163

2532

DBusGMainLoop(set_as_default=True)

3164

main_loop = GLib.MainLoop()

2533

main_loop = gobject.MainLoop()

3165

2534

bus = dbus.SystemBus()

3166

2535

# End of Avahi example code

3167

2536

if use_dbus:

3168

2537

try:

3169

2538

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

3170

bus,

3171

do_not_queue=True)

3172

old_bus_name = dbus.service.BusName(

3173

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

3174

do_not_queue=True)

3175

except dbus.exceptions.DBusException as e:

2539

bus, do_not_queue=True)

2540

old_bus_name = (dbus.service.BusName

2541

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

2542

do_not_queue=True))

2543

except dbus.exceptions.NameExistsException as e:

3176

2544

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

3177

2545

use_dbus = False

3178

2546

server_settings["use_dbus"] = False

3179

2547

tcp_server.use_dbus = False

3180

2548

if zeroconf:

3181

2549

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3182

service = AvahiServiceToSyslog(

3183

name=server_settings["servicename"],

3184

servicetype="_mandos._tcp",

3185

protocol=protocol,

3186

bus=bus)

2550

service = AvahiServiceToSyslog(name =

2551

server_settings["servicename"],

2552

servicetype = "_mandos._tcp",

2553

protocol = protocol, bus = bus)

3187

2554

if server_settings["interface"]:

3188

service.interface = if_nametoindex(

3189

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

3190

2555

service.interface = (if_nametoindex

2556

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

2557

3191

2558

global multiprocessing_manager

3192

2559

multiprocessing_manager = multiprocessing.Manager()

3193

2560

3194

2561

client_class = Client

3195

2562

if use_dbus:

3196

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

3197

2563

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

2564

3198

2565

client_settings = Client.config_parser(client_config)

3199

2566

old_client_settings = {}

3200

2567

clients_data = {}

3201

2568

3202

2569

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

3203

2570

global wnull

3204

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

2571

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

3205

2572

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

3206

2573

# mode

3207

2574

if debug or not foreground:

3208

2575

wnull.close()

3209

2576

3210

2577

# Get client data and settings from last running state.

3211

2578

if server_settings["restore"]:

3212

2579

try:

3213

2580

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

3214

if sys.version_info.major == 2:

3215

clients_data, old_client_settings = pickle.load(

3216

stored_state)

3217

else:

3218

bytes_clients_data, bytes_old_client_settings = (

3219

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

3220

# Fix bytes to strings

3221

# clients_data

3222

# .keys()

3223

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

3224

if isinstance(key, bytes)

3225

else key): value

3226

for key, value in

3227

bytes_clients_data.items()}

3228

del bytes_clients_data

3229

for key in clients_data:

3230

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

3231

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

3232

for k, v in

3233

clients_data[key].items()}

3234

clients_data[key] = value

3235

# .client_structure

3236

value["client_structure"] = [

3237

(s.decode("utf-8")

3238

if isinstance(s, bytes)

3239

else s) for s in

3240

value["client_structure"]]

3241

# .name & .host

3242

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

3243

if isinstance(value[k], bytes):

3244

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

3245

if not value.has_key("key_id"):

3246

value["key_id"] = ""

3247

elif not value.has_key("fingerprint"):

3248

value["fingerprint"] = ""

3249

# old_client_settings

3250

# .keys()

3251

old_client_settings = {

3252

(key.decode("utf-8")

3253

if isinstance(key, bytes)

3254

else key): value

3255

for key, value in

3256

bytes_old_client_settings.items()}

3257

del bytes_old_client_settings

3258

# .host

3259

for value in old_client_settings.values():

3260

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

3261

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

3262

.decode("utf-8"))

2581

clients_data, old_client_settings = (pickle.load

2582

(stored_state))

3263

2583

os.remove(stored_state_path)

3264

2584

except IOError as e:

3265

2585

if e.errno == errno.ENOENT:

3266

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

3267

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

2586

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

2587

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

3268

2588

else:

3269

2589

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

3270

2590

exc_info=e)

3271

2591

raise

3272

2592

except EOFError as e:

3273

2593

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

3274

"EOFError:",

3275

exc_info=e)

3276

2594

"EOFError:", exc_info=e)

2595

3277

2596

with PGPEngine() as pgp:

3278

for client_name, client in clients_data.items():

2597

for client_name, client in clients_data.iteritems():

3279

2598

# Skip removed clients

3280

2599

if client_name not in client_settings:

3281

2600

continue

3282

2601

3283

2602

# Decide which value to use after restoring saved state.

3284

2603

# We have three different values: Old config file,

3285

2604

# new config file, and saved state.

3290

2609

# For each value in new config, check if it

3291

2610

# differs from the old config value (Except for

3292

2611

# the "secret" attribute)

3293

if (name != "secret"

3294

and (value !=

3295

old_client_settings[client_name][name])):

2612

if (name != "secret" and

2613

value != old_client_settings[client_name]

2614

[name]):

3296

2615

client[name] = value

3297

2616

except KeyError:

3298

2617

pass

3299

2618

3300

2619

# Clients who has passed its expire date can still be

3301

# enabled if its last checker was successful. A Client

2620

# enabled if its last checker was successful. Clients

3302

2621

# whose checker succeeded before we stored its state is

3303

2622

# assumed to have successfully run all checkers during

3304

2623

# downtime.

3306

2625

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

3307

2626

if not client["last_checked_ok"]:

3308

2627

logger.warning(

3309

"disabling client {} - Client never "

3310

"performed a successful checker".format(

3311

client_name))

2628

"disabling client {0} - Client never "

2629

"performed a successful checker"

2630

.format(client_name))

3312

2631

client["enabled"] = False

3313

2632

elif client["last_checker_status"] != 0:

3314

2633

logger.warning(

3315

"disabling client {} - Client last"

3316

" checker failed with error code"

3317

" {}".format(

3318

client_name,

3319

client["last_checker_status"]))

2634

"disabling client {0} - Client "

2635

"last checker failed with error code {1}"

2636

.format(client_name,

2637

client["last_checker_status"]))

3320

2638

client["enabled"] = False

3321

2639

else:

3322

client["expires"] = (

3323

datetime.datetime.utcnow()

3324

+ client["timeout"])

2640

client["expires"] = (datetime.datetime

2641

.utcnow()

2642

+ client["timeout"])

3325

2643

logger.debug("Last checker succeeded,"

3326

" keeping {} enabled".format(

3327

client_name))

2644

" keeping {0} enabled"

2645

.format(client_name))

3328

2646

try:

3329

client["secret"] = pgp.decrypt(

3330

client["encrypted_secret"],

3331

client_settings[client_name]["secret"])

2647

client["secret"] = (

2648

pgp.decrypt(client["encrypted_secret"],

2649

client_settings[client_name]

2650

["secret"]))

3332

2651

except PGPError:

3333

2652

# If decryption fails, we use secret from new settings

3334

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

3335

client_name))

3336

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

3337

["secret"])

3338

2653

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

2654

.format(client_name))

2655

client["secret"] = (

2656

client_settings[client_name]["secret"])

2657

3339

2658

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

3340

2659

for client_name in (set(old_client_settings)

3341

2660

- set(client_settings)):

3343

2662

for client_name in (set(client_settings)

3344

2663

- set(old_client_settings)):

3345

2664

clients_data[client_name] = client_settings[client_name]

3346

2665

3347

2666

# Create all client objects

3348

for client_name, client in clients_data.items():

2667

for client_name, client in clients_data.iteritems():

3349

2668

tcp_server.clients[client_name] = client_class(

3350

name=client_name,

3351

settings=client,

3352

server_settings=server_settings)

3353

2669

name = client_name, settings = client,

2670

server_settings = server_settings)

2671

3354

2672

if not tcp_server.clients:

3355

2673

logger.warning("No clients defined")

3356

2674

3357

2675

if not foreground:

3358

2676

if pidfile is not None:

3359

pid = os.getpid()

3360

2677

try:

3361

2678

with pidfile:

3362

print(pid, file=pidfile)

2679

pid = os.getpid()

2680

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

3363

2681

except IOError:

3364

2682

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

3365

2683

pidfilename, pid)

3366

2684

del pidfile

3367

2685

del pidfilename

3368

3369

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

3370

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3371

lambda: main_loop.quit() and False)

3372

2686

2687

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

2688

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

2689

3373

2690

if use_dbus:

3374

3375

@alternate_dbus_interfaces(

3376

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

3377

class MandosDBusService(DBusObjectWithObjectManager):

2691

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

2692

"se.bsnet.fukt.Mandos"})

2693

class MandosDBusService(DBusObjectWithProperties):

3378

2694

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

3379

3380

2695

def __init__(self):

3381

2696

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

3382

3383

2697

_interface = "se.recompile.Mandos"

3384

2698

2699

@dbus_interface_annotations(_interface)

2700

def _foo(self):

2701

return { "org.freedesktop.DBus.Property"

2702

".EmitsChangedSignal":

2703

"false"}

2704

3385

2705

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

3386

2706

def ClientAdded(self, objpath):

3387

2707

"D-Bus signal"

3388

2708

pass

3389

2709

3390

2710

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

3391

def ClientNotFound(self, key_id, address):

2711

def ClientNotFound(self, fingerprint, address):

3392

2712

"D-Bus signal"

3393

2713

pass

3394

3395

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

3396

"true"})

2714

3397

2715

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

3398

2716

def ClientRemoved(self, objpath, name):

3399

2717

"D-Bus signal"

3400

2718

pass

3401

3402

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

3403

"true"})

2719

3404

2720

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

3405

2721

def GetAllClients(self):

3406

2722

"D-Bus method"

3407

return dbus.Array(c.dbus_object_path for c in

3408

tcp_server.clients.values())

3409

3410

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

3411

"true"})

2723

return dbus.Array(c.dbus_object_path

2724

for c in

2725

tcp_server.clients.itervalues())

2726

3412

2727

@dbus.service.method(_interface,

3413

2728

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

3414

2729

def GetAllClientsWithProperties(self):

3415

2730

"D-Bus method"

3416

2731

return dbus.Dictionary(

3417

{c.dbus_object_path: c.GetAll(

3418

"se.recompile.Mandos.Client")

3419

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

2732

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

2733

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

3420

2734

signature="oa{sv}")

3421

2735

3422

2736

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

3423

2737

def RemoveClient(self, object_path):

3424

2738

"D-Bus method"

3425

for c in tcp_server.clients.values():

2739

for c in tcp_server.clients.itervalues():

3426

2740

if c.dbus_object_path == object_path:

3427

2741

del tcp_server.clients[c.name]

3428

2742

c.remove_from_connection()

3429

# Don't signal the disabling

2743

# Don't signal anything except ClientRemoved

3430

2744

c.disable(quiet=True)

3431

# Emit D-Bus signal for removal

3432

self.client_removed_signal(c)

2745

# Emit D-Bus signal

2746

self.ClientRemoved(object_path, c.name)

3433

2747

return

3434

2748

raise KeyError(object_path)

3435

2749

3436

2750

del _interface

3437

3438

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3439

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

3440

def GetManagedObjects(self):

3441

"""D-Bus method"""

3442

return dbus.Dictionary(

3443

{client.dbus_object_path:

3444

dbus.Dictionary(

3445

{interface: client.GetAll(interface)

3446

for interface in

3447

client._get_all_interface_names()})

3448

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

3449

3450

def client_added_signal(self, client):

3451

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

3452

if use_dbus:

3453

# New standard signal

3454

self.InterfacesAdded(

3455

client.dbus_object_path,

3456

dbus.Dictionary(

3457

{interface: client.GetAll(interface)

3458

for interface in

3459

client._get_all_interface_names()}))

3460

# Old signal

3461

self.ClientAdded(client.dbus_object_path)

3462

3463

def client_removed_signal(self, client):

3464

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

3465

if use_dbus:

3466

# New standard signal

3467

self.InterfacesRemoved(

3468

client.dbus_object_path,

3469

client._get_all_interface_names())

3470

# Old signal

3471

self.ClientRemoved(client.dbus_object_path,

3472

client.name)

3473

2751

3474

2752

mandos_dbus_service = MandosDBusService()

3475

3476

# Save modules to variables to exempt the modules from being

3477

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

3478

mp = multiprocessing

3479

wn = wnull

3480

2753

3481

2754

def cleanup():

3482

2755

"Cleanup function; run on exit"

3483

2756

if zeroconf:

3484

2757

service.cleanup()

3485

3486

mp.active_children()

3487

wn.close()

2758

2759

multiprocessing.active_children()

2760

wnull.close()

3488

2761

if not (tcp_server.clients or client_settings):

3489

2762

return

3490

2763

3491

2764

# Store client before exiting. Secrets are encrypted with key

3492

2765

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

3493

2766

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

3494

2767

clients = {}

3495

2768

with PGPEngine() as pgp:

3496

for client in tcp_server.clients.values():

2769

for client in tcp_server.clients.itervalues():

3497

2770

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

3498

2771

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

3499

2772

key)

3500

2773

client_dict = {}

3501

2774

3502

2775

# A list of attributes that can not be pickled

3503

2776

# + secret.

3504

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

3505

"checker", "server_settings"}

3506

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

3507

.Object):

2777

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

2778

"checker", "server_settings"))

2779

for name, typ in (inspect.getmembers

2780

(dbus.service.Object)):

3508

2781

exclude.add(name)

3509

2782

3510

2783

client_dict["encrypted_secret"] = (client

3511

2784

.encrypted_secret)

3512

2785

for attr in client.client_structure:

3513

2786

if attr not in exclude:

3514

2787

client_dict[attr] = getattr(client, attr)

3515

2788

3516

2789

clients[client.name] = client_dict

3517

2790

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

3518

2791

3519

2792

try:

3520

with tempfile.NamedTemporaryFile(

3521

mode='wb',

3522

suffix=".pickle",

3523

prefix='clients-',

3524

dir=os.path.dirname(stored_state_path),

3525

delete=False) as stored_state:

3526

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

3527

protocol=2)

3528

tempname = stored_state.name

2793

with (tempfile.NamedTemporaryFile

2794

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

2795

dir=os.path.dirname(stored_state_path),

2796

delete=False)) as stored_state:

2797

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

2798

tempname=stored_state.name

3529

2799

os.rename(tempname, stored_state_path)

3530

2800

except (IOError, OSError) as e:

3531

2801

if not debug:

3534

2804

except NameError:

3535

2805

pass

3536

2806

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

3537

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

2807

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

3538

2808

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

3539

2809

else:

3540

2810

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

3541

2811

exc_info=e)

3542

2812

raise

3543

2813

3544

2814

# Delete all clients, and settings from config

3545

2815

while tcp_server.clients:

3546

2816

name, client = tcp_server.clients.popitem()

3547

2817

if use_dbus:

3548

2818

client.remove_from_connection()

3549

# Don't signal the disabling

2819

# Don't signal anything except ClientRemoved

3550

2820

client.disable(quiet=True)

3551

# Emit D-Bus signal for removal

3552

2821

if use_dbus:

3553

mandos_dbus_service.client_removed_signal(client)

2822

# Emit D-Bus signal

2823

mandos_dbus_service.ClientRemoved(client

2824

.dbus_object_path,

2825

client.name)

3554

2826

client_settings.clear()

3555

2827

3556

2828

atexit.register(cleanup)

3557

3558

for client in tcp_server.clients.values():

2829

2830

for client in tcp_server.clients.itervalues():

3559

2831

if use_dbus:

3560

# Emit D-Bus signal for adding

3561

mandos_dbus_service.client_added_signal(client)

2832

# Emit D-Bus signal

2833

mandos_dbus_service.ClientAdded(client.dbus_object_path)

3562

2834

# Need to initiate checking of clients

3563

2835

if client.enabled:

3564

2836

client.init_checker()

3565

2837

3566

2838

tcp_server.enable()

3567

2839

tcp_server.server_activate()

3568

2840

3569

2841

# Find out what port we got

3570

2842

if zeroconf:

3571

2843

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

3576

2848

else: # IPv4

3577

2849

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

3578

2850

*tcp_server.socket.getsockname())

3579

3580

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

3581

2851

2852

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

2853

3582

2854

try:

3583

2855

if zeroconf:

3584

2856

# From the Avahi example code

3589

2861

cleanup()

3590

2862

sys.exit(1)

3591

2863

# End of Avahi example code

3592

3593

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

3594

lambda *args, **kwargs:

3595

(tcp_server.handle_request

3596

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

3597

2864

2865

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

2866

lambda *args, **kwargs:

2867

(tcp_server.handle_request

2868

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

2869

3598

2870

logger.debug("Starting main loop")

3599

2871

main_loop.run()

3600

2872

except AvahiError as error:

3609

2881

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

3610

2882

cleanup()

3611

2883

3612

3613

2884

if __name__ == '__main__':

3614

2885

main()