/mandos/release : revision 237.7.109

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

42

43

try:

44

import SocketServer as socketserver

45

except ImportError:

46

import socketserver

37

import SocketServer as socketserver

47

38

import socket

48

39

import argparse

49

40

import datetime

50

41

import errno

51

try:

52

import ConfigParser as configparser

53

except ImportError:

54

import configparser

42

import gnutls.crypto

43

import gnutls.connection

44

import gnutls.errors

45

import gnutls.library.functions

46

import gnutls.library.constants

47

import gnutls.library.types

48

import ConfigParser as configparser

55

49

import sys

56

50

import re

57

51

import os

66

60

import struct

67

61

import fcntl

68

62

import functools

69

try:

70

import cPickle as pickle

71

except ImportError:

72

import pickle

63

import cPickle as pickle

73

64

import multiprocessing

74

65

import types

75

66

import binascii

76

67

import tempfile

77

68

import itertools

78

import collections

79

import codecs

80

69

81

70

import dbus

82

71

import dbus.service

83

import gi

84

from gi.repository import GLib

72

import gobject

73

import avahi

85

74

from dbus.mainloop.glib import DBusGMainLoop

86

75

import ctypes

87

76

import ctypes.util

88

77

import xml.dom.minidom

89

78

import inspect

90

91

if sys.version_info.major == 2:

92

__metaclass__ = type

93

94

# Try to find the value of SO_BINDTODEVICE:

79

import GnuPGInterface

80

95

81

try:

96

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

97

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

98

82

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

99

83

except AttributeError:

100

84

try:

101

# This is where SO_BINDTODEVICE was up to and including Python

102

# 2.6, and also 3.2:

103

85

from IN import SO_BINDTODEVICE

104

86

except ImportError:

105

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

106

# Try running the C preprocessor:

107

try:

108

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

109

"/dev/stdin"],

110

stdin=subprocess.PIPE,

111

stdout=subprocess.PIPE)

112

stdout = cc.communicate(

113

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

114

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

115

except (OSError, ValueError, IndexError):

116

# No value found

117

SO_BINDTODEVICE = None

118

119

if sys.version_info.major == 2:

120

str = unicode

121

122

if sys.version_info < (3, 2):

123

configparser.Configparser = configparser.SafeConfigParser

124

125

version = "1.8.8"

87

SO_BINDTODEVICE = None

88

89

version = "1.5.3"

126

90

stored_state_file = "clients.pickle"

127

91

128

92

logger = logging.getLogger()

129

syslogger = None

93

syslogger = (logging.handlers.SysLogHandler

94

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

95

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

130

96

131

97

try:

132

if_nametoindex = ctypes.cdll.LoadLibrary(

133

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

98

if_nametoindex = (ctypes.cdll.LoadLibrary

99

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

100

.if_nametoindex)

134

101

except (OSError, AttributeError):

135

136

102

def if_nametoindex(interface):

137

103

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

138

104

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

139

105

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

140

106

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

141

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

142

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]

143

111

return interface_index

144

112

145

113

146

def copy_function(func):

147

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

148

if sys.version_info.major == 2:

149

return types.FunctionType(func.func_code,

150

func.func_globals,

151

func.func_name,

152

func.func_defaults,

153

func.func_closure)

154

else:

155

return types.FunctionType(func.__code__,

156

func.__globals__,

157

func.__name__,

158

func.__defaults__,

159

func.__closure__)

160

161

162

114

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

163

115

"""init logger and add loglevel"""

164

165

global syslogger

166

syslogger = (logging.handlers.SysLogHandler(

167

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

168

address="/dev/log"))

116

169

117

syslogger.setFormatter(logging.Formatter

170

118

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

171

119

' %(message)s'))

172

120

logger.addHandler(syslogger)

173

121

174

122

if debug:

175

123

console = logging.StreamHandler()

176

124

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

186

134

pass

187

135

188

136

189

class PGPEngine:

137

class PGPEngine(object):

190

138

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

191

192

139

def __init__(self):

140

self.gnupg = GnuPGInterface.GnuPG()

193

141

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

194

self.gpg = "gpg"

195

try:

196

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

197

for line in output.splitlines():

198

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

199

if name == "gpg":

200

self.gpg = path

201

break

202

except OSError as e:

203

if e.errno != errno.ENOENT:

204

raise

205

self.gnupgargs = ['--batch',

206

'--homedir', self.tempdir,

207

'--force-mdc',

208

'--quiet']

209

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

210

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

211

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

212

142

self.gnupg = GnuPGInterface.GnuPG()

143

self.gnupg.options.meta_interactive = False

144

self.gnupg.options.homedir = self.tempdir

145

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

146

'--quiet',

147

'--no-use-agent'])

148

213

149

def __enter__(self):

214

150

return self

215

216

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

151

152

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

217

153

self._cleanup()

218

154

return False

219

155

220

156

def __del__(self):

221

157

self._cleanup()

222

158

223

159

def _cleanup(self):

224

160

if self.tempdir is not None:

225

161

# Delete contents of tempdir

226

162

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

227

topdown=False):

163

topdown = False):

228

164

for filename in files:

229

165

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

230

166

for dirname in dirs:

232

168

# Remove tempdir

233

169

os.rmdir(self.tempdir)

234

170

self.tempdir = None

235

171

236

172

def password_encode(self, password):

237

173

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

238

174

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

239

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

240

if len(encoded) > 2048:

241

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

242

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

243

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

244

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

245

return encoded

246

175

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

176

247

177

def encrypt(self, data, password):

248

passphrase = self.password_encode(password)

249

with tempfile.NamedTemporaryFile(

250

dir=self.tempdir) as passfile:

251

passfile.write(passphrase)

252

passfile.flush()

253

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

254

'--passphrase-file',

255

passfile.name]

256

+ self.gnupgargs,

257

stdin=subprocess.PIPE,

258

stdout=subprocess.PIPE,

259

stderr=subprocess.PIPE)

260

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

261

if proc.returncode != 0:

262

raise PGPError(err)

178

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

179

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

180

try:

181

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

182

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

183

attach_fhs={'stderr': devnull})

184

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

185

f.write(data)

186

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

187

ciphertext = f.read()

188

proc.wait()

189

except IOError as e:

190

raise PGPError(e)

191

self.gnupg.passphrase = None

263

192

return ciphertext

264

193

265

194

def decrypt(self, data, password):

266

passphrase = self.password_encode(password)

267

with tempfile.NamedTemporaryFile(

268

dir=self.tempdir) as passfile:

269

passfile.write(passphrase)

270

passfile.flush()

271

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

272

'--passphrase-file',

273

passfile.name]

274

+ self.gnupgargs,

275

stdin=subprocess.PIPE,

276

stdout=subprocess.PIPE,

277

stderr=subprocess.PIPE)

278

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

279

if proc.returncode != 0:

280

raise PGPError(err)

195

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

196

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

197

try:

198

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

199

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

200

attach_fhs={'stderr': devnull})

201

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

202

f.write(data)

203

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

204

decrypted_plaintext = f.read()

205

proc.wait()

206

except IOError as e:

207

raise PGPError(e)

208

self.gnupg.passphrase = None

281

209

return decrypted_plaintext

282

210

283

211

284

# Pretend that we have an Avahi module

285

class avahi:

286

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

287

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

288

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

289

PROTO_INET = 0 # avahi-common/address.h

290

PROTO_INET6 = 1 # avahi-common/address.h

291

DBUS_NAME = "org.freedesktop.Avahi"

292

DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"

293

DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"

294

DBUS_PATH_SERVER = "/"

295

296

@staticmethod

297

def string_array_to_txt_array(t):

298

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

299

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

300

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

301

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

302

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

303

SERVER_INVALID = 0 # avahi-common/defs.h

304

SERVER_REGISTERING = 1 # avahi-common/defs.h

305

SERVER_RUNNING = 2 # avahi-common/defs.h

306

SERVER_COLLISION = 3 # avahi-common/defs.h

307

SERVER_FAILURE = 4 # avahi-common/defs.h

308

309

212

310

213

class AvahiError(Exception):

311

214

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

312

215

self.value = value

313

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

314

**kwargs)

315

216

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

217

def __unicode__(self):

218

return unicode(repr(self.value))

316

219

317

220

class AvahiServiceError(AvahiError):

318

221

pass

319

222

320

321

223

class AvahiGroupError(AvahiError):

322

224

pass

323

225

324

226

325

class AvahiService:

227

class AvahiService(object):

326

228

"""An Avahi (Zeroconf) service.

327

229

328

230

Attributes:

329

231

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

330

232

Used to optionally bind to the specified interface.

331

233

name: string; Example: 'Mandos'

332

234

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

333

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

235

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

334

236

port: integer; what port to announce

335

237

TXT: list of strings; TXT record for the service

336

238

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

342

244

server: D-Bus Server

343

245

bus: dbus.SystemBus()

344

246

"""

345

346

def __init__(self,

347

interface=avahi.IF_UNSPEC,

348

name=None,

349

servicetype=None,

350

port=None,

351

TXT=None,

352

domain="",

353

host="",

354

max_renames=32768,

355

protocol=avahi.PROTO_UNSPEC,

356

bus=None):

247

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

248

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

249

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

250

protocol = avahi.PROTO_UNSPEC, bus = None):

357

251

self.interface = interface

358

252

self.name = name

359

253

self.type = servicetype

368

262

self.server = None

369

263

self.bus = bus

370

264

self.entry_group_state_changed_match = None

371

372

def rename(self, remove=True):

265

def rename(self):

373

266

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

374

267

if self.rename_count >= self.max_renames:

375

268

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

376

269

" after %i retries, exiting.",

377

270

self.rename_count)

378

271

raise AvahiServiceError("Too many renames")

379

self.name = str(

380

self.server.GetAlternativeServiceName(self.name))

381

self.rename_count += 1

272

self.name = unicode(self.server

273

.GetAlternativeServiceName(self.name))

382

274

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

383

275

self.name)

384

if remove:

385

self.remove()

276

self.remove()

386

277

try:

387

278

self.add()

388

279

except dbus.exceptions.DBusException as error:

389

if (error.get_dbus_name()

390

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

391

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

392

return self.rename(remove=False)

393

else:

394

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

395

self.cleanup()

396

os._exit(1)

397

280

logger.critical("DBusException: %s", error)

281

self.cleanup()

282

os._exit(1)

283

self.rename_count += 1

398

284

def remove(self):

399

285

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

400

286

if self.entry_group_state_changed_match is not None:

402

288

self.entry_group_state_changed_match = None

403

289

if self.group is not None:

404

290

self.group.Reset()

405

406

291

def add(self):

407

292

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

408

293

self.remove()

425

310

dbus.UInt16(self.port),

426

311

avahi.string_array_to_txt_array(self.TXT))

427

312

self.group.Commit()

428

429

313

def entry_group_state_changed(self, state, error):

430

314

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

431

315

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

432

316

433

317

if state == avahi.ENTRY_GROUP_ESTABLISHED:

434

318

logger.debug("Zeroconf service established.")

435

319

elif state == avahi.ENTRY_GROUP_COLLISION:

437

321

self.rename()

438

322

elif state == avahi.ENTRY_GROUP_FAILURE:

439

323

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

440

str(error))

441

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

442

324

unicode(error))

325

raise AvahiGroupError("State changed: %s"

326

% unicode(error))

443

327

def cleanup(self):

444

328

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

445

329

if self.group is not None:

450

334

pass

451

335

self.group = None

452

336

self.remove()

453

454

337

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

455

338

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

456

339

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

457

bad_states = {

458

avahi.SERVER_INVALID: "Zeroconf server invalid",

459

avahi.SERVER_REGISTERING: None,

460

avahi.SERVER_COLLISION: "Zeroconf server name collision",

461

avahi.SERVER_FAILURE: "Zeroconf server failure",

462

}

340

bad_states = { avahi.SERVER_INVALID:

341

"Zeroconf server invalid",

342

avahi.SERVER_REGISTERING: None,

343

avahi.SERVER_COLLISION:

344

"Zeroconf server name collision",

345

avahi.SERVER_FAILURE:

346

"Zeroconf server failure" }

463

347

if state in bad_states:

464

348

if bad_states[state] is not None:

465

349

if error is None:

468

352

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

469

353

self.cleanup()

470

354

elif state == avahi.SERVER_RUNNING:

471

try:

472

self.add()

473

except dbus.exceptions.DBusException as error:

474

if (error.get_dbus_name()

475

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

476

logger.info("Local Zeroconf service name"

477

" collision.")

478

return self.rename(remove=False)

479

else:

480

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

481

self.cleanup()

482

os._exit(1)

355

self.add()

483

356

else:

484

357

if error is None:

485

358

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

486

359

else:

487

360

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

488

489

361

def activate(self):

490

362

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

491

363

if self.server is None:

495

367

follow_name_owner_changes=True),

496

368

avahi.DBUS_INTERFACE_SERVER)

497

369

self.server.connect_to_signal("StateChanged",

498

self.server_state_changed)

370

self.server_state_changed)

499

371

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

500

372

501

502

373

class AvahiServiceToSyslog(AvahiService):

503

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

374

def rename(self):

504

375

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

505

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

506

syslogger.setFormatter(logging.Formatter(

507

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

508

.format(self.name)))

376

ret = AvahiService.rename(self)

377

syslogger.setFormatter(logging.Formatter

378

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

379

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

380

% self.name))

509

381

return ret

510

382

511

512

# Pretend that we have a GnuTLS module

513

class gnutls:

514

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

515

516

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

517

if library is None:

518

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

519

_library = ctypes.cdll.LoadLibrary(library)

520

del library

521

522

# Unless otherwise indicated, the constants and types below are

523

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

524

525

# Constants

526

E_SUCCESS = 0

527

E_INTERRUPTED = -52

528

E_AGAIN = -28

529

CRT_OPENPGP = 2

530

CRT_RAWPK = 3

531

CLIENT = 2

532

SHUT_RDWR = 0

533

CRD_CERTIFICATE = 1

534

E_NO_CERTIFICATE_FOUND = -49

535

X509_FMT_DER = 0

536

NO_TICKETS = 1<<10

537

ENABLE_RAWPK = 1<<18

538

CTYPE_PEERS = 3

539

KEYID_USE_SHA256 = 1 # gnutls/x509.h

540

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

541

542

# Types

543

class session_int(ctypes.Structure):

544

_fields_ = []

545

session_t = ctypes.POINTER(session_int)

546

547

class certificate_credentials_st(ctypes.Structure):

548

_fields_ = []

549

certificate_credentials_t = ctypes.POINTER(

550

certificate_credentials_st)

551

certificate_type_t = ctypes.c_int

552

553

class datum_t(ctypes.Structure):

554

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

555

('size', ctypes.c_uint)]

556

557

class openpgp_crt_int(ctypes.Structure):

558

_fields_ = []

559

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

560

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

561

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

562

credentials_type_t = ctypes.c_int

563

transport_ptr_t = ctypes.c_void_p

564

close_request_t = ctypes.c_int

565

566

# Exceptions

567

class Error(Exception):

568

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

569

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

570

# code is passed, convert it to a string with

571

# gnutls.strerror()

572

self.code = code

573

if message is None and code is not None:

574

message = gnutls.strerror(code)

575

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

576

message, *args)

577

578

class CertificateSecurityError(Error):

579

pass

580

581

# Classes

582

class Credentials:

583

def __init__(self):

584

self._c_object = gnutls.certificate_credentials_t()

585

gnutls.certificate_allocate_credentials(

586

ctypes.byref(self._c_object))

587

self.type = gnutls.CRD_CERTIFICATE

588

589

def __del__(self):

590

gnutls.certificate_free_credentials(self._c_object)

591

592

class ClientSession:

593

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

594

self._c_object = gnutls.session_t()

595

gnutls_flags = gnutls.CLIENT

596

if gnutls.check_version(b"3.5.6"):

597

gnutls_flags |= gnutls.NO_TICKETS

598

if gnutls.has_rawpk:

599

gnutls_flags |= gnutls.ENABLE_RAWPK

600

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

601

del gnutls_flags

602

gnutls.set_default_priority(self._c_object)

603

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

604

gnutls.handshake_set_private_extensions(self._c_object,

605

True)

606

self.socket = socket

607

if credentials is None:

608

credentials = gnutls.Credentials()

609

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

610

ctypes.cast(credentials._c_object,

611

ctypes.c_void_p))

612

self.credentials = credentials

613

614

def __del__(self):

615

gnutls.deinit(self._c_object)

616

617

def handshake(self):

618

return gnutls.handshake(self._c_object)

619

620

def send(self, data):

621

data = bytes(data)

622

data_len = len(data)

623

while data_len > 0:

624

data_len -= gnutls.record_send(self._c_object,

625

data[-data_len:],

626

data_len)

627

628

def bye(self):

629

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

630

631

# Error handling functions

632

def _error_code(result):

633

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

634

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

635

if result >= 0:

636

return result

637

if result == gnutls.E_NO_CERTIFICATE_FOUND:

638

raise gnutls.CertificateSecurityError(code=result)

639

raise gnutls.Error(code=result)

640

641

def _retry_on_error(result, func, arguments):

642

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

643

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

644

while result < 0:

645

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

646

return _error_code(result)

647

result = func(*arguments)

648

return result

649

650

# Unless otherwise indicated, the function declarations below are

651

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

652

653

# Functions

654

priority_set_direct = _library.gnutls_priority_set_direct

655

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

656

ctypes.POINTER(ctypes.c_char_p)]

657

priority_set_direct.restype = _error_code

658

659

init = _library.gnutls_init

660

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

661

init.restype = _error_code

662

663

set_default_priority = _library.gnutls_set_default_priority

664

set_default_priority.argtypes = [session_t]

665

set_default_priority.restype = _error_code

666

667

record_send = _library.gnutls_record_send

668

record_send.argtypes = [session_t, ctypes.c_void_p,

669

ctypes.c_size_t]

670

record_send.restype = ctypes.c_ssize_t

671

record_send.errcheck = _retry_on_error

672

673

certificate_allocate_credentials = (

674

_library.gnutls_certificate_allocate_credentials)

675

certificate_allocate_credentials.argtypes = [

676

ctypes.POINTER(certificate_credentials_t)]

677

certificate_allocate_credentials.restype = _error_code

678

679

certificate_free_credentials = (

680

_library.gnutls_certificate_free_credentials)

681

certificate_free_credentials.argtypes = [

682

certificate_credentials_t]

683

certificate_free_credentials.restype = None

684

685

handshake_set_private_extensions = (

686

_library.gnutls_handshake_set_private_extensions)

687

handshake_set_private_extensions.argtypes = [session_t,

688

ctypes.c_int]

689

handshake_set_private_extensions.restype = None

690

691

credentials_set = _library.gnutls_credentials_set

692

credentials_set.argtypes = [session_t, credentials_type_t,

693

ctypes.c_void_p]

694

credentials_set.restype = _error_code

695

696

strerror = _library.gnutls_strerror

697

strerror.argtypes = [ctypes.c_int]

698

strerror.restype = ctypes.c_char_p

699

700

certificate_type_get = _library.gnutls_certificate_type_get

701

certificate_type_get.argtypes = [session_t]

702

certificate_type_get.restype = _error_code

703

704

certificate_get_peers = _library.gnutls_certificate_get_peers

705

certificate_get_peers.argtypes = [session_t,

706

ctypes.POINTER(ctypes.c_uint)]

707

certificate_get_peers.restype = ctypes.POINTER(datum_t)

708

709

global_set_log_level = _library.gnutls_global_set_log_level

710

global_set_log_level.argtypes = [ctypes.c_int]

711

global_set_log_level.restype = None

712

713

global_set_log_function = _library.gnutls_global_set_log_function

714

global_set_log_function.argtypes = [log_func]

715

global_set_log_function.restype = None

716

717

deinit = _library.gnutls_deinit

718

deinit.argtypes = [session_t]

719

deinit.restype = None

720

721

handshake = _library.gnutls_handshake

722

handshake.argtypes = [session_t]

723

handshake.restype = _error_code

724

handshake.errcheck = _retry_on_error

725

726

transport_set_ptr = _library.gnutls_transport_set_ptr

727

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

728

transport_set_ptr.restype = None

729

730

bye = _library.gnutls_bye

731

bye.argtypes = [session_t, close_request_t]

732

bye.restype = _error_code

733

bye.errcheck = _retry_on_error

734

735

check_version = _library.gnutls_check_version

736

check_version.argtypes = [ctypes.c_char_p]

737

check_version.restype = ctypes.c_char_p

738

739

_need_version = b"3.3.0"

740

if check_version(_need_version) is None:

741

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

742

.format(_need_version))

743

744

_tls_rawpk_version = b"3.6.6"

745

has_rawpk = bool(check_version(_tls_rawpk_version))

746

747

if has_rawpk:

748

# Types

749

class pubkey_st(ctypes.Structure):

750

_fields = []

751

pubkey_t = ctypes.POINTER(pubkey_st)

752

753

x509_crt_fmt_t = ctypes.c_int

754

755

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

756

pubkey_init = _library.gnutls_pubkey_init

757

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

758

pubkey_init.restype = _error_code

759

760

pubkey_import = _library.gnutls_pubkey_import

761

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

762

x509_crt_fmt_t]

763

pubkey_import.restype = _error_code

764

765

pubkey_get_key_id = _library.gnutls_pubkey_get_key_id

766

pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,

767

ctypes.POINTER(ctypes.c_ubyte),

768

ctypes.POINTER(ctypes.c_size_t)]

769

pubkey_get_key_id.restype = _error_code

770

771

pubkey_deinit = _library.gnutls_pubkey_deinit

772

pubkey_deinit.argtypes = [pubkey_t]

773

pubkey_deinit.restype = None

774

else:

775

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

776

777

openpgp_crt_init = _library.gnutls_openpgp_crt_init

778

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

779

openpgp_crt_init.restype = _error_code

780

781

openpgp_crt_import = _library.gnutls_openpgp_crt_import

782

openpgp_crt_import.argtypes = [openpgp_crt_t,

783

ctypes.POINTER(datum_t),

784

openpgp_crt_fmt_t]

785

openpgp_crt_import.restype = _error_code

786

787

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

788

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

789

ctypes.POINTER(ctypes.c_uint)]

790

openpgp_crt_verify_self.restype = _error_code

791

792

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

793

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

794

openpgp_crt_deinit.restype = None

795

796

openpgp_crt_get_fingerprint = (

797

_library.gnutls_openpgp_crt_get_fingerprint)

798

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

799

ctypes.c_void_p,

800

ctypes.POINTER(

801

ctypes.c_size_t)]

802

openpgp_crt_get_fingerprint.restype = _error_code

803

804

if check_version(b"3.6.4"):

805

certificate_type_get2 = _library.gnutls_certificate_type_get2

806

certificate_type_get2.argtypes = [session_t, ctypes.c_int]

807

certificate_type_get2.restype = _error_code

808

809

# Remove non-public functions

810

del _error_code, _retry_on_error

811

812

813

def call_pipe(connection, # : multiprocessing.Connection

814

func, *args, **kwargs):

815

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

816

817

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

818

return value on the provided multiprocessing.Connection.

819

"""

820

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

821

connection.close()

822

823

824

class Client:

383

def timedelta_to_milliseconds(td):

384

"Convert a datetime.timedelta() to milliseconds"

385

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

386

+ (td.seconds * 1000)

387

+ (td.microseconds // 1000))

388

389

class Client(object):

825

390

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

826

391

827

392

Attributes:

828

393

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

829

394

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

830

395

approval_duration: datetime.timedelta(); Duration of one approval

831

checker: multiprocessing.Process(); a running checker process used

832

to see if the client lives. 'None' if no process is

833

running.

834

checker_callback_tag: a GLib event source tag, or None

396

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

397

to see if the client lives.

398

'None' if no process is running.

399

checker_callback_tag: a gobject event source tag, or None

835

400

checker_command: string; External command which is run to check

836

401

if client lives. %() expansions are done at

837

402

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

838

403

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

839

checker_initiator_tag: a GLib event source tag, or None

404

checker_initiator_tag: a gobject event source tag, or None

840

405

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

841

406

client_structure: Object describing what attributes a client has

842

407

and is used for storing the client at exit

843

408

current_checker_command: string; current running checker_command

844

disable_initiator_tag: a GLib event source tag, or None

409

disable_initiator_tag: a gobject event source tag, or None

845

410

enabled: bool()

846

411

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

847

uniquely identify an OpenPGP client

848

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

849

a client using raw public keys

412

uniquely identify the client

850

413

host: string; available for use by the checker command

851

414

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

852

415

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

854

417

last_checker_status: integer between 0 and 255 reflecting exit

855

418

status of last checker. -1 reflects crashed

856

419

checker, -2 means no checker completed yet.

857

last_checker_signal: The signal which killed the last checker, if

858

last_checker_status is -1

859

420

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

860

421

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

861

422

D-Bus identifiers

866

427

runtime_expansions: Allowed attributes for runtime expansion.

867

428

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

868

429

disabled, or None

869

server_settings: The server_settings dict from main()

870

430

"""

871

431

872

432

runtime_expansions = ("approval_delay", "approval_duration",

873

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

874

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

875

"last_approval_request", "last_checked_ok",

433

"created", "enabled", "fingerprint",

434

"host", "interval", "last_checked_ok",

876

435

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

877

client_defaults = {

878

"timeout": "PT5M",

879

"extended_timeout": "PT15M",

880

"interval": "PT2M",

881

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

882

"host": "",

883

"approval_delay": "PT0S",

884

"approval_duration": "PT1S",

885

"approved_by_default": "True",

886

"enabled": "True",

887

}

436

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

437

"extended_timeout": "15m",

438

"interval": "2m",

439

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

440

"host": "",

441

"approval_delay": "0s",

442

"approval_duration": "1s",

443

"approved_by_default": "True",

444

"enabled": "True",

445

}

446

447

def timeout_milliseconds(self):

448

"Return the 'timeout' attribute in milliseconds"

449

return timedelta_to_milliseconds(self.timeout)

450

451

def extended_timeout_milliseconds(self):

452

"Return the 'extended_timeout' attribute in milliseconds"

453

return timedelta_to_milliseconds(self.extended_timeout)

454

455

def interval_milliseconds(self):

456

"Return the 'interval' attribute in milliseconds"

457

return timedelta_to_milliseconds(self.interval)

458

459

def approval_delay_milliseconds(self):

460

return timedelta_to_milliseconds(self.approval_delay)

888

461

889

462

@staticmethod

890

463

def config_parser(config):

898

471

for client_name in config.sections():

899

472

section = dict(config.items(client_name))

900

473

client = settings[client_name] = {}

901

474

902

475

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

903

476

# Reformat values from string types to Python types

904

477

client["approved_by_default"] = config.getboolean(

905

478

client_name, "approved_by_default")

906

479

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

907

480

"enabled")

908

909

# Uppercase and remove spaces from key_id and fingerprint

910

# for later comparison purposes with return value from the

911

# key_id() and fingerprint() functions

912

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

913

.replace(" ", ""))

481

914

482

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

915

483

.replace(" ", ""))

916

484

if "secret" in section:

917

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

918

.encode("utf-8"),

919

"base64")

485

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

920

486

elif "secfile" in section:

921

487

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

922

488

(section["secfile"])),

923

489

"rb") as secfile:

924

490

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

925

491

else:

926

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

927

.format(section))

492

raise TypeError("No secret or secfile for section %s"

493

% section)

928

494

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

929

495

client["extended_timeout"] = string_to_delta(

930

496

section["extended_timeout"])

937

503

client["last_approval_request"] = None

938

504

client["last_checked_ok"] = None

939

505

client["last_checker_status"] = -2

940

506

941

507

return settings

942

943

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

508

509

510

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

511

"""Note: the 'checker' key in 'config' sets the

512

'checker_command' attribute and *not* the 'checker'

513

attribute."""

944

514

self.name = name

945

if server_settings is None:

946

server_settings = {}

947

self.server_settings = server_settings

948

515

# adding all client settings

949

for setting, value in settings.items():

516

for setting, value in settings.iteritems():

950

517

setattr(self, setting, value)

951

518

952

519

if self.enabled:

953

520

if not hasattr(self, "last_enabled"):

954

521

self.last_enabled = datetime.datetime.utcnow()

958

525

else:

959

526

self.last_enabled = None

960

527

self.expires = None

961

528

962

529

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

963

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

530

# Uppercase and remove spaces from fingerprint for later

531

# comparison purposes with return value from the fingerprint()

532

# function

964

533

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

965

534

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

966

535

datetime.datetime.utcnow())

973

542

self.current_checker_command = None

974

543

self.approved = None

975

544

self.approvals_pending = 0

976

self.changedstate = multiprocessing_manager.Condition(

977

multiprocessing_manager.Lock())

978

self.client_structure = [attr

979

for attr in self.__dict__.keys()

545

self.changedstate = (multiprocessing_manager

546

.Condition(multiprocessing_manager

547

.Lock()))

548

self.client_structure = [attr for attr in

549

self.__dict__.iterkeys()

980

550

if not attr.startswith("_")]

981

551

self.client_structure.append("client_structure")

982

983

for name, t in inspect.getmembers(

984

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

552

553

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

554

lambda obj:

555

isinstance(obj,

556

property)):

985

557

if not name.startswith("_"):

986

558

self.client_structure.append(name)

987

559

988

560

# Send notice to process children that client state has changed

989

561

def send_changedstate(self):

990

562

with self.changedstate:

991

563

self.changedstate.notify_all()

992

564

993

565

def enable(self):

994

566

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

995

567

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

996

568

# Already enabled

997

569

return

570

self.send_changedstate()

998

571

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

999

572

self.enabled = True

1000

573

self.last_enabled = datetime.datetime.utcnow()

1001

574

self.init_checker()

1002

self.send_changedstate()

1003

575

1004

576

def disable(self, quiet=True):

1005

577

"""Disable this client."""

1006

578

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

1007

579

return False

1008

580

if not quiet:

581

self.send_changedstate()

582

if not quiet:

1009

583

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

1010

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

1011

GLib.source_remove(self.disable_initiator_tag)

584

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

585

gobject.source_remove(self.disable_initiator_tag)

1012

586

self.disable_initiator_tag = None

1013

587

self.expires = None

1014

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

1015

GLib.source_remove(self.checker_initiator_tag)

588

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

589

gobject.source_remove(self.checker_initiator_tag)

1016

590

self.checker_initiator_tag = None

1017

591

self.stop_checker()

1018

592

self.enabled = False

1019

if not quiet:

1020

self.send_changedstate()

1021

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

593

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

1022

594

return False

1023

595

1024

596

def __del__(self):

1025

597

self.disable()

1026

598

1027

599

def init_checker(self):

1028

600

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

1029

601

# and every interval from then on.

1030

if self.checker_initiator_tag is not None:

1031

GLib.source_remove(self.checker_initiator_tag)

1032

self.checker_initiator_tag = GLib.timeout_add(

1033

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

1034

self.start_checker)

602

self.checker_initiator_tag = (gobject.timeout_add

603

(self.interval_milliseconds(),

604

self.start_checker))

1035

605

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

1036

if self.disable_initiator_tag is not None:

1037

GLib.source_remove(self.disable_initiator_tag)

1038

self.disable_initiator_tag = GLib.timeout_add(

1039

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

606

self.disable_initiator_tag = (gobject.timeout_add

607

(self.timeout_milliseconds(),

608

self.disable))

1040

609

# Also start a new checker *right now*.

1041

610

self.start_checker()

1042

1043

def checker_callback(self, source, condition, connection,

1044

command):

611

612

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

1045

613

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

1046

# Read return code from connection (see call_pipe)

1047

returncode = connection.recv()

1048

connection.close()

1049

self.checker.join()

1050

614

self.checker_callback_tag = None

1051

615

self.checker = None

1052

1053

if returncode >= 0:

1054

self.last_checker_status = returncode

1055

self.last_checker_signal = None

616

if os.WIFEXITED(condition):

617

self.last_checker_status = os.WEXITSTATUS(condition)

1056

618

if self.last_checker_status == 0:

1057

619

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

1058

620

vars(self))

1059

621

self.checked_ok()

1060

622

else:

1061

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

623

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

624

vars(self))

1062

625

else:

1063

626

self.last_checker_status = -1

1064

self.last_checker_signal = -returncode

1065

627

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

1066

628

vars(self))

1067

return False

1068

629

1069

630

def checked_ok(self):

1070

631

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

1071

632

self.last_checked_ok = datetime.datetime.utcnow()

1072

633

self.last_checker_status = 0

1073

self.last_checker_signal = None

1074

634

self.bump_timeout()

1075

635

1076

636

def bump_timeout(self, timeout=None):

1077

637

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

1078

638

if timeout is None:

1079

639

timeout = self.timeout

1080

640

if self.disable_initiator_tag is not None:

1081

GLib.source_remove(self.disable_initiator_tag)

1082

self.disable_initiator_tag = None

641

gobject.source_remove(self.disable_initiator_tag)

1083

642

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

1084

self.disable_initiator_tag = GLib.timeout_add(

1085

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

643

self.disable_initiator_tag = (gobject.timeout_add

644

(timedelta_to_milliseconds

645

(timeout), self.disable))

1086

646

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

1087

647

1088

648

def need_approval(self):

1089

649

self.last_approval_request = datetime.datetime.utcnow()

1090

650

1091

651

def start_checker(self):

1092

652

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

1093

653

1094

654

If a checker already exists, leave it running and do

1095

655

nothing."""

1096

656

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

1097

# did that, and if a checker (for some reason) started running

1098

# slowly and taking more than 'interval' time, then the client

1099

# would inevitably timeout, since no checker would get a

1100

# chance to run to completion. If we instead leave running

657

# did that, then if a checker (for some reason) started

658

# running slowly and taking more than 'interval' time, the

659

# client would inevitably timeout, since no checker would get

660

# a chance to run to completion. If we instead leave running

1101

661

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

1102

662

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

1103

663

# should be.

1104

1105

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

1106

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

1107

self.checker.join()

1108

self.checker = None

664

665

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

666

try:

667

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

668

except (AttributeError, OSError) as error:

669

if (isinstance(error, OSError)

670

and error.errno != errno.ECHILD):

671

raise error

672

else:

673

if pid:

674

logger.warning("Checker was a zombie")

675

gobject.source_remove(self.checker_callback_tag)

676

self.checker_callback(pid, status,

677

self.current_checker_command)

1109

678

# Start a new checker if needed

1110

679

if self.checker is None:

1111

# Escape attributes for the shell

1112

escaped_attrs = {

1113

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

1114

for attr in self.runtime_expansions}

1115

680

try:

1116

command = self.checker_command % escaped_attrs

1117

except TypeError as error:

1118

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

1119

self.checker_command,

1120

exc_info=error)

1121

return True # Try again later

681

# In case checker_command has exactly one % operator

682

command = self.checker_command % self.host

683

except TypeError:

684

# Escape attributes for the shell

685

escaped_attrs = dict(

686

(attr,

687

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

688

errors=

689

'replace')))

690

for attr in

691

self.runtime_expansions)

692

693

try:

694

command = self.checker_command % escaped_attrs

695

except TypeError as error:

696

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

697

' %s', self.checker_command, error)

698

return True # Try again later

1122

699

self.current_checker_command = command

1123

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

1124

self.name)

1125

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

1126

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

1127

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

1128

# always replaced by /dev/null.)

1129

# The exception is when not debugging but nevertheless

1130

# running in the foreground; use the previously

1131

# created wnull.

1132

popen_args = {"close_fds": True,

1133

"shell": True,

1134

"cwd": "/"}

1135

if (not self.server_settings["debug"]

1136

and self.server_settings["foreground"]):

1137

popen_args.update({"stdout": wnull,

1138

"stderr": wnull})

1139

pipe = multiprocessing.Pipe(duplex=False)

1140

self.checker = multiprocessing.Process(

1141

target=call_pipe,

1142

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

1143

kwargs=popen_args)

1144

self.checker.start()

1145

self.checker_callback_tag = GLib.io_add_watch(

1146

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

1147

self.checker_callback, pipe[0], command)

1148

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

700

try:

701

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

702

command, self.name)

703

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

704

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

705

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

706

# always replaced by /dev/null.)

707

self.checker = subprocess.Popen(command,

708

close_fds=True,

709

shell=True, cwd="/")

710

self.checker_callback_tag = (gobject.child_watch_add

711

(self.checker.pid,

712

self.checker_callback,

713

data=command))

714

# The checker may have completed before the gobject

715

# watch was added. Check for this.

716

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

717

if pid:

718

gobject.source_remove(self.checker_callback_tag)

719

self.checker_callback(pid, status, command)

720

except OSError as error:

721

logger.error("Failed to start subprocess: %s",

722

error)

723

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

1149

724

return True

1150

725

1151

726

def stop_checker(self):

1152

727

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

1153

728

if self.checker_callback_tag:

1154

GLib.source_remove(self.checker_callback_tag)

729

gobject.source_remove(self.checker_callback_tag)

1155

730

self.checker_callback_tag = None

1156

731

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

1157

732

return

1158

733

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

1159

self.checker.terminate()

734

try:

735

os.kill(self.checker.pid, signal.SIGTERM)

736

#time.sleep(0.5)

737

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

738

# os.kill(self.checker.pid, signal.SIGKILL)

739

except OSError as error:

740

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

741

raise

1160

742

self.checker = None

1161

743

1162

744

1163

def dbus_service_property(dbus_interface,

1164

signature="v",

1165

access="readwrite",

1166

byte_arrays=False):

745

def dbus_service_property(dbus_interface, signature="v",

746

access="readwrite", byte_arrays=False):

1167

747

"""Decorators for marking methods of a DBusObjectWithProperties to

1168

748

become properties on the D-Bus.

1169

749

1170

750

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

1171

751

and with one argument by "Set".

1172

752

1173

753

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

1174

754

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

1175

755

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

1178

758

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

1179

759

if byte_arrays and signature != "ay":

1180

760

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

1181

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

1182

761

" signature %r" % signature)

1183

762

def decorator(func):

1184

763

func._dbus_is_property = True

1185

764

func._dbus_interface = dbus_interface

1188

767

func._dbus_name = func.__name__

1189

768

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

1190

769

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

1191

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

770

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1192

771

return func

1193

1194

772

return decorator

1195

773

1196

774

1197

775

def dbus_interface_annotations(dbus_interface):

1198

"""Decorator for marking functions returning interface annotations

1199

776

"""Decorator for marking functions returning interface annotations.

777

1200

778

Usage:

1201

779

1202

780

@dbus_interface_annotations("org.example.Interface")

1203

781

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

1204

782

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

1205

783

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

1206

784

"false"}

1207

785

"""

1208

1209

786

def decorator(func):

1210

787

func._dbus_is_interface = True

1211

788

func._dbus_interface = dbus_interface

1212

789

func._dbus_name = dbus_interface

1213

790

return func

1214

1215

return decorator

1216

1217

1218

def dbus_annotations(annotations):

1219

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

1220

Usage:

1221

1222

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

1223

"org.freedesktop.DBus.Property."

1224

"EmitsChangedSignal": "false"})

1225

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

1226

access="r")

1227

def Property_dbus_property(self):

1228

return dbus.Boolean(False)

1229

1230

See also the DBusObjectWithAnnotations class.

1231

"""

1232

1233

def decorator(func):

1234

func._dbus_annotations = annotations

1235

return func

1236

1237

791

return decorator

1238

792

1239

793

1240

794

class DBusPropertyException(dbus.exceptions.DBusException):

1241

795

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

1242

796

"""

1243

pass

797

def __unicode__(self):

798

return unicode(str(self))

1244

799

1245

800

1246

801

class DBusPropertyAccessException(DBusPropertyException):

1255

810

pass

1256

811

1257

812

1258

class DBusObjectWithAnnotations(dbus.service.Object):

1259

"""A D-Bus object with annotations.

1260

1261

Classes inheriting from this can use the dbus_annotations

1262

decorator to add annotations to methods or signals.

813

class DBusObjectWithProperties(dbus.service.Object):

814

"""A D-Bus object with properties.

815

816

Classes inheriting from this can use the dbus_service_property

817

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

818

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

1263

819

"""

1264

820

1265

821

@staticmethod

1266

822

def _is_dbus_thing(thing):

1267

823

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

1268

824

1269

825

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

1270

826

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

1271

827

"""

1272

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

828

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

1273

829

False)

1274

830

1275

831

def _get_all_dbus_things(self, thing):

1276

832

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

1277

833

"""

1278

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

834

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

1279

835

athing.__get__(self))

1280

836

for cls in self.__class__.__mro__

1281

837

for name, athing in

1282

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

1283

1284

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1285

out_signature="s",

1286

path_keyword='object_path',

1287

connection_keyword='connection')

1288

def Introspect(self, object_path, connection):

1289

"""Overloading of standard D-Bus method.

1290

1291

Inserts annotation tags on methods and signals.

1292

"""

1293

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

1294

connection)

1295

try:

1296

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

1297

1298

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

1299

# Add annotation tags

1300

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

1301

for tag in if_tag.getElementsByTagName(typ):

1302

annots = dict()

1303

for name, prop in (self.

1304

_get_all_dbus_things(typ)):

1305

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

1306

and prop._dbus_interface

1307

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

1308

annots.update(getattr(

1309

prop, "_dbus_annotations", {}))

1310

for name, value in annots.items():

1311

ann_tag = document.createElement(

1312

"annotation")

1313

ann_tag.setAttribute("name", name)

1314

ann_tag.setAttribute("value", value)

1315

tag.appendChild(ann_tag)

1316

# Add interface annotation tags

1317

for annotation, value in dict(

1318

itertools.chain.from_iterable(

1319

annotations().items()

1320

for name, annotations

1321

in self._get_all_dbus_things("interface")

1322

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

1323

)).items():

1324

ann_tag = document.createElement("annotation")

1325

ann_tag.setAttribute("name", annotation)

1326

ann_tag.setAttribute("value", value)

1327

if_tag.appendChild(ann_tag)

1328

# Fix argument name for the Introspect method itself

1329

if (if_tag.getAttribute("name")

1330

== dbus.INTROSPECTABLE_IFACE):

1331

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

1332

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

1333

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

1334

if (arg.getAttribute("direction")

1335

== "out"):

1336

arg.setAttribute("name",

1337

"xml_data")

1338

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

1339

document.unlink()

1340

except (AttributeError, xml.dom.DOMException,

1341

xml.parsers.expat.ExpatError) as error:

1342

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

1343

exc_info=error)

1344

return xmlstring

1345

1346

1347

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1348

"""A D-Bus object with properties.

1349

1350

Classes inheriting from this can use the dbus_service_property

1351

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

1352

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

1353

"""

1354

838

inspect.getmembers(cls,

839

self._is_dbus_thing(thing)))

840

1355

841

def _get_dbus_property(self, interface_name, property_name):

1356

842

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

1357

843

property with the specified name and interface.

1358

844

"""

1359

for cls in self.__class__.__mro__:

1360

for name, value in inspect.getmembers(

1361

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

845

for cls in self.__class__.__mro__:

846

for name, value in (inspect.getmembers

847

(cls,

848

self._is_dbus_thing("property"))):

1362

849

if (value._dbus_name == property_name

1363

850

and value._dbus_interface == interface_name):

1364

851

return value.__get__(self)

1365

852

1366

853

# No such property

1367

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

1368

self.dbus_object_path, interface_name, property_name))

1369

1370

@classmethod

1371

def _get_all_interface_names(cls):

1372

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

1373

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

1374

"_dbus_interface", None)

1375

for x in (inspect.getmro(cls))

1376

for attr in dir(x))

1377

if name is not None)

1378

1379

@dbus.service.method(dbus.PROPERTIES_IFACE,

1380

in_signature="ss",

854

raise DBusPropertyNotFound(self.dbus_object_path + ":"

855

+ interface_name + "."

856

+ property_name)

857

858

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

1381

859

out_signature="v")

1382

860

def Get(self, interface_name, property_name):

1383

861

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

1389

867

if not hasattr(value, "variant_level"):

1390

868

return value

1391

869

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

1392

870

1393

871

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

1394

872

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

1395

873

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

1401

879

# The byte_arrays option is not supported yet on

1402

880

# signatures other than "ay".

1403

881

if prop._dbus_signature != "ay":

1404

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

1405

"'ay' signature {!r}"

1406

.format(prop._dbus_signature))

882

raise ValueError

1407

883

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

1408

884

for byte in value))

1409

885

prop(value)

1410

1411

@dbus.service.method(dbus.PROPERTIES_IFACE,

1412

in_signature="s",

886

887

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

1413

888

out_signature="a{sv}")

1414

889

def GetAll(self, interface_name):

1415

890

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

1416

891

standard.

1417

892

1418

893

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

1419

894

"""

1420

895

properties = {}

1430

905

if not hasattr(value, "variant_level"):

1431

906

properties[name] = value

1432

907

continue

1433

properties[name] = type(value)(

1434

value, variant_level=value.variant_level + 1)

908

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

909

value.variant_level+1)

1435

910

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

1436

1437

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

1438

def PropertiesChanged(self, interface_name, changed_properties,

1439

invalidated_properties):

1440

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

1441

standard.

1442

"""

1443

pass

1444

911

1445

912

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1446

913

out_signature="s",

1447

914

path_keyword='object_path',

1448

915

connection_keyword='connection')

1449

916

def Introspect(self, object_path, connection):

1450

917

"""Overloading of standard D-Bus method.

1451

918

1452

919

Inserts property tags and interface annotation tags.

1453

920

"""

1454

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1455

object_path,

1456

connection)

921

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

922

connection)

1457

923

try:

1458

924

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

1459

1460

925

def make_tag(document, name, prop):

1461

926

e = document.createElement("property")

1462

927

e.setAttribute("name", name)

1463

928

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

1464

929

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

1465

930

return e

1466

1467

931

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

1468

932

# Add property tags

1469

933

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

1472

936

if prop._dbus_interface

1473

937

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

1474

938

if_tag.appendChild(tag)

1475

# Add annotation tags for properties

1476

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

1477

annots = dict()

1478

for name, prop in self._get_all_dbus_things(

1479

"property"):

1480

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

1481

and prop._dbus_interface

1482

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

1483

annots.update(getattr(

1484

prop, "_dbus_annotations", {}))

1485

for name, value in annots.items():

1486

ann_tag = document.createElement(

1487

"annotation")

1488

ann_tag.setAttribute("name", name)

1489

ann_tag.setAttribute("value", value)

1490

tag.appendChild(ann_tag)

939

# Add interface annotation tags

940

for annotation, value in dict(

941

itertools.chain(

942

*(annotations().iteritems()

943

for name, annotations in

944

self._get_all_dbus_things("interface")

945

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

946

))).iteritems():

947

attr_tag = document.createElement("annotation")

948

attr_tag.setAttribute("name", annotation)

949

attr_tag.setAttribute("value", value)

950

if_tag.appendChild(attr_tag)

1491

951

# Add the names to the return values for the

1492

952

# "org.freedesktop.DBus.Properties" methods

1493

953

if (if_tag.getAttribute("name")

1508

968

except (AttributeError, xml.dom.DOMException,

1509

969

xml.parsers.expat.ExpatError) as error:

1510

970

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

1511

exc_info=error)

1512

return xmlstring

1513

1514

1515

try:

1516

dbus.OBJECT_MANAGER_IFACE

1517

except AttributeError:

1518

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

1519

1520

1521

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1522

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

1523

1524

Classes inheriting from this exposes the standard

1525

GetManagedObjects call and the InterfacesAdded and

1526

InterfacesRemoved signals on the standard

1527

"org.freedesktop.DBus.ObjectManager" interface.

1528

1529

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

1530

manually.

1531

"""

1532

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1533

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

1534

def GetManagedObjects(self):

1535

"""This function must be overridden"""

1536

raise NotImplementedError()

1537

1538

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1539

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

1540

def InterfacesAdded(self, object_path, interfaces_and_properties):

1541

pass

1542

1543

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

1544

def InterfacesRemoved(self, object_path, interfaces):

1545

pass

1546

1547

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1548

out_signature="s",

1549

path_keyword='object_path',

1550

connection_keyword='connection')

1551

def Introspect(self, object_path, connection):

1552

"""Overloading of standard D-Bus method.

1553

1554

Override return argument name of GetManagedObjects to be

1555

"objpath_interfaces_and_properties"

1556

"""

1557

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1558

object_path,

1559

connection)

1560

try:

1561

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

1562

1563

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

1564

# Fix argument name for the GetManagedObjects method

1565

if (if_tag.getAttribute("name")

1566

== dbus.OBJECT_MANAGER_IFACE):

1567

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

1568

if (cn.getAttribute("name")

1569

== "GetManagedObjects"):

1570

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

1571

if (arg.getAttribute("direction")

1572

== "out"):

1573

arg.setAttribute(

1574

"name",

1575

"objpath_interfaces"

1576

"_and_properties")

1577

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

1578

document.unlink()

1579

except (AttributeError, xml.dom.DOMException,

1580

xml.parsers.expat.ExpatError) as error:

1581

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

1582

exc_info=error)

1583

return xmlstring

1584

1585

1586

def datetime_to_dbus(dt, variant_level=0):

971

error)

972

return xmlstring

973

974

975

def datetime_to_dbus (dt, variant_level=0):

1587

976

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

1588

977

if dt is None:

1589

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

1590

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

1591

1592

1593

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1594

"""A class decorator; applied to a subclass of

1595

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

1596

interface names according to the "alt_interface_names" mapping.

1597

Usage:

1598

1599

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

1600

"net.example.AlternateInterface"})

1601

class SampleDBusObject(dbus.service.Object):

1602

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

1603

def SampleDBusMethod():

1604

pass

1605

1606

The above "SampleDBusMethod" on "SampleDBusObject" will be

1607

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

1608

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

1609

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

1610

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

1611

1612

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

1613

(from DBusObjectWithProperties) and interfaces (from the

1614

dbus_interface_annotations decorator).

978

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

979

return dbus.String(dt.isoformat(),

980

variant_level=variant_level)

981

982

983

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

984

.__metaclass__):

985

"""Applied to an empty subclass of a D-Bus object, this metaclass

986

will add additional D-Bus attributes matching a certain pattern.

1615

987

"""

1616

1617

def wrapper(cls):

1618

for orig_interface_name, alt_interface_name in (

1619

alt_interface_names.items()):

1620

attr = {}

1621

interface_names = set()

1622

# Go though all attributes of the class

1623

for attrname, attribute in inspect.getmembers(cls):

988

def __new__(mcs, name, bases, attr):

989

# Go through all the base classes which could have D-Bus

990

# methods, signals, or properties in them

991

old_interface_names = []

992

for base in (b for b in bases

993

if issubclass(b, dbus.service.Object)):

994

# Go though all attributes of the base class

995

for attrname, attribute in inspect.getmembers(base):

1624

996

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

1625

997

# with the wrong interface name

1626

998

if (not hasattr(attribute, "_dbus_interface")

1627

or not attribute._dbus_interface.startswith(

1628

orig_interface_name)):

999

or not attribute._dbus_interface

1000

.startswith("se.recompile.Mandos")):

1629

1001

continue

1630

1002

# Create an alternate D-Bus interface name based on

1631

1003

# the current name

1632

alt_interface = attribute._dbus_interface.replace(

1633

orig_interface_name, alt_interface_name)

1634

interface_names.add(alt_interface)

1004

alt_interface = (attribute._dbus_interface

1005

.replace("se.recompile.Mandos",

1006

"se.bsnet.fukt.Mandos"))

1007

if alt_interface != attribute._dbus_interface:

1008

old_interface_names.append(alt_interface)

1635

1009

# Is this a D-Bus signal?

1636

1010

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

1637

# Extract the original non-method undecorated

1638

# function by black magic

1639

if sys.version_info.major == 2:

1640

nonmethod_func = (dict(

1011

# Extract the original non-method function by

1012

# black magic

1013

nonmethod_func = (dict(

1641

1014

zip(attribute.func_code.co_freevars,

1642

attribute.__closure__))

1643

["func"].cell_contents)

1644

else:

1645

nonmethod_func = (dict(

1646

zip(attribute.__code__.co_freevars,

1647

attribute.__closure__))

1648

["func"].cell_contents)

1015

attribute.__closure__))["func"]

1016

.cell_contents)

1649

1017

# Create a new, but exactly alike, function

1650

1018

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

1651

1019

# with the alternate D-Bus interface name

1652

new_function = copy_function(nonmethod_func)

1653

new_function = (dbus.service.signal(

1654

alt_interface,

1655

attribute._dbus_signature)(new_function))

1656

# Copy annotations, if any

1657

try:

1658

new_function._dbus_annotations = dict(

1659

attribute._dbus_annotations)

1660

except AttributeError:

1661

pass

1662

1020

new_function = (dbus.service.signal

1021

(alt_interface,

1022

attribute._dbus_signature)

1023

(types.FunctionType(

1024

nonmethod_func.func_code,

1025

nonmethod_func.func_globals,

1026

nonmethod_func.func_name,

1027

nonmethod_func.func_defaults,

1028

nonmethod_func.func_closure)))

1663

1029

# Define a creator of a function to call both the

1664

# original and alternate functions, so both the

1665

# original and alternate signals gets sent when

1666

# the function is called

1030

# old and new functions, so both the old and new

1031

# signals gets sent when the function is called

1667

1032

def fixscope(func1, func2):

1668

1033

"""This function is a scope container to pass

1669

1034

func1 and func2 to the "call_both" function

1670

1035

outside of its arguments"""

1671

1672

@functools.wraps(func2)

1673

1036

def call_both(*args, **kwargs):

1674

1037

"""This function will emit two D-Bus

1675

1038

signals by calling func1 and func2"""

1676

1039

func1(*args, **kwargs)

1677

1040

func2(*args, **kwargs)

1678

# Make wrapper function look like a D-Bus

1679

# signal

1680

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

1681

if name.startswith("_dbus_"):

1682

setattr(call_both, name, attr)

1683

1684

1041

return call_both

1685

1042

# Create the "call_both" function and add it to

1686

1043

# the class

1687

attr[attrname] = fixscope(attribute, new_function)

1044

attr[attrname] = fixscope(attribute,

1045

new_function)

1688

1046

# Is this a D-Bus method?

1689

1047

elif getattr(attribute, "_dbus_is_method", False):

1690

1048

# Create a new, but exactly alike, function

1691

1049

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

1692

1050

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

1693

1051

# to the class.

1694

attr[attrname] = (

1695

dbus.service.method(

1696

alt_interface,

1697

attribute._dbus_in_signature,

1698

attribute._dbus_out_signature)

1699

(copy_function(attribute)))

1700

# Copy annotations, if any

1701

try:

1702

attr[attrname]._dbus_annotations = dict(

1703

attribute._dbus_annotations)

1704

except AttributeError:

1705

pass

1052

attr[attrname] = (dbus.service.method

1053

(alt_interface,

1054

attribute._dbus_in_signature,

1055

attribute._dbus_out_signature)

1056

(types.FunctionType

1057

(attribute.func_code,

1058

attribute.func_globals,

1059

attribute.func_name,

1060

attribute.func_defaults,

1061

attribute.func_closure)))

1706

1062

# Is this a D-Bus property?

1707

1063

elif getattr(attribute, "_dbus_is_property", False):

1708

1064

# Create a new, but exactly alike, function

1709

1065

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

1710

1066

# property with the alternate D-Bus interface

1711

1067

# name. Add it to the class.

1712

attr[attrname] = (dbus_service_property(

1713

alt_interface, attribute._dbus_signature,

1714

attribute._dbus_access,

1715

attribute._dbus_get_args_options

1716

["byte_arrays"])

1717

(copy_function(attribute)))

1718

# Copy annotations, if any

1719

try:

1720

attr[attrname]._dbus_annotations = dict(

1721

attribute._dbus_annotations)

1722

except AttributeError:

1723

pass

1068

attr[attrname] = (dbus_service_property

1069

(alt_interface,

1070

attribute._dbus_signature,

1071

attribute._dbus_access,

1072

attribute

1073

._dbus_get_args_options

1074

["byte_arrays"])

1075

(types.FunctionType

1076

(attribute.func_code,

1077

attribute.func_globals,

1078

attribute.func_name,

1079

attribute.func_defaults,

1080

attribute.func_closure)))

1724

1081

# Is this a D-Bus interface?

1725

1082

elif getattr(attribute, "_dbus_is_interface", False):

1726

1083

# Create a new, but exactly alike, function

1727

1084

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

1728

1085

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

1729

1086

# to the class.

1730

attr[attrname] = (

1731

dbus_interface_annotations(alt_interface)

1732

(copy_function(attribute)))

1733

if deprecate:

1734

# Deprecate all alternate interfaces

1735

iname = "_AlternateDBusNames_interface_annotation{}"

1736

for interface_name in interface_names:

1737

1738

@dbus_interface_annotations(interface_name)

1739

def func(self):

1740

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

1741

"true"}

1742

# Find an unused name

1743

for aname in (iname.format(i)

1744

for i in itertools.count()):

1745

if aname not in attr:

1746

attr[aname] = func

1747

break

1748

if interface_names:

1749

# Replace the class with a new subclass of it with

1750

# methods, signals, etc. as created above.

1751

if sys.version_info.major == 2:

1752

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

1753

(cls, ), attr)

1754

else:

1755

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

1756

(cls, ), attr)

1757

return cls

1758

1759

return wrapper

1760

1761

1762

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

1763

"se.bsnet.fukt.Mandos"})

1087

attr[attrname] = (dbus_interface_annotations

1088

(alt_interface)

1089

(types.FunctionType

1090

(attribute.func_code,

1091

attribute.func_globals,

1092

attribute.func_name,

1093

attribute.func_defaults,

1094

attribute.func_closure)))

1095

# Deprecate all old interfaces

1096

basename="_AlternateDBusNamesMetaclass_interface_annotation{0}"

1097

for old_interface_name in old_interface_names:

1098

@dbus_interface_annotations(old_interface_name)

1099

def func(self):

1100

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

1101

# Find an unused name

1102

for aname in (basename.format(i) for i in

1103

itertools.count()):

1104

if aname not in attr:

1105

attr[aname] = func

1106

break

1107

return type.__new__(mcs, name, bases, attr)

1108

1109

1764

1110

class ClientDBus(Client, DBusObjectWithProperties):

1765

1111

"""A Client class using D-Bus

1766

1112

1767

1113

Attributes:

1768

1114

dbus_object_path: dbus.ObjectPath

1769

1115

bus: dbus.SystemBus()

1770

1116

"""

1771

1117

1772

1118

runtime_expansions = (Client.runtime_expansions

1773

+ ("dbus_object_path", ))

1774

1775

_interface = "se.recompile.Mandos.Client"

1776

1119

+ ("dbus_object_path",))

1120

1777

1121

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

1778

1779

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

1122

1123

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

1780

1124

self.bus = bus

1781

1125

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

1782

1126

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

1783

1127

# the D-Bus

1784

client_object_name = str(self.name).translate(

1128

client_object_name = unicode(self.name).translate(

1785

1129

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

1786

1130

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

1787

self.dbus_object_path = dbus.ObjectPath(

1788

"/clients/" + client_object_name)

1131

self.dbus_object_path = (dbus.ObjectPath

1132

("/clients/" + client_object_name))

1789

1133

DBusObjectWithProperties.__init__(self, self.bus,

1790

1134

self.dbus_object_path)

1791

1792

def notifychangeproperty(transform_func, dbus_name,

1793

type_func=lambda x: x,

1794

variant_level=1,

1795

invalidate_only=False,

1796

_interface=_interface):

1135

1136

def notifychangeproperty(transform_func,

1137

dbus_name, type_func=lambda x: x,

1138

variant_level=1):

1797

1139

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

1798

1140

its changes to DBus.

1799

1141

1800

1142

transform_fun: Function that takes a value and a variant_level

1801

1143

and transforms it to a D-Bus type.

1802

1144

dbus_name: D-Bus name of the variable

1804

1146

to the D-Bus. Default: no transform

1805

1147

variant_level: D-Bus variant level. Default: 1

1806

1148

"""

1807

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

1808

1149

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

1809

1150

def setter(self, value):

1810

1151

if hasattr(self, "dbus_object_path"):

1811

1152

if (not hasattr(self, attrname) or

1812

1153

type_func(getattr(self, attrname, None))

1813

1154

!= type_func(value)):

1814

if invalidate_only:

1815

self.PropertiesChanged(

1816

_interface, dbus.Dictionary(),

1817

dbus.Array((dbus_name, )))

1818

else:

1819

dbus_value = transform_func(

1820

type_func(value),

1821

variant_level=variant_level)

1822

self.PropertyChanged(dbus.String(dbus_name),

1823

dbus_value)

1824

self.PropertiesChanged(

1825

_interface,

1826

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

1827

dbus_value}),

1828

dbus.Array())

1155

dbus_value = transform_func(type_func(value),

1156

variant_level

1157

=variant_level)

1158

self.PropertyChanged(dbus.String(dbus_name),

1159

dbus_value)

1829

1160

setattr(self, attrname, value)

1830

1161

1831

1162

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

1832

1163

1164

1833

1165

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1834

1166

approvals_pending = notifychangeproperty(dbus.Boolean,

1835

1167

"ApprovalPending",

1836

type_func=bool)

1168

type_func = bool)

1837

1169

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

1838

1170

last_enabled = notifychangeproperty(datetime_to_dbus,

1839

1171

"LastEnabled")

1840

checker = notifychangeproperty(

1841

dbus.Boolean, "CheckerRunning",

1842

type_func=lambda checker: checker is not None)

1172

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

1173

type_func = lambda checker:

1174

checker is not None)

1843

1175

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1844

1176

"LastCheckedOK")

1845

1177

last_checker_status = notifychangeproperty(dbus.Int16,

1848

1180

datetime_to_dbus, "LastApprovalRequest")

1849

1181

approved_by_default = notifychangeproperty(dbus.Boolean,

1850

1182

"ApprovedByDefault")

1851

approval_delay = notifychangeproperty(

1852

dbus.UInt64, "ApprovalDelay",

1853

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

1183

approval_delay = notifychangeproperty(dbus.UInt64,

1184

"ApprovalDelay",

1185

type_func =

1186

timedelta_to_milliseconds)

1854

1187

approval_duration = notifychangeproperty(

1855

1188

dbus.UInt64, "ApprovalDuration",

1856

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

1189

type_func = timedelta_to_milliseconds)

1857

1190

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

1858

timeout = notifychangeproperty(

1859

dbus.UInt64, "Timeout",

1860

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

1191

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

1192

type_func =

1193

timedelta_to_milliseconds)

1861

1194

extended_timeout = notifychangeproperty(

1862

1195

dbus.UInt64, "ExtendedTimeout",

1863

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

1864

interval = notifychangeproperty(

1865

dbus.UInt64, "Interval",

1866

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

1196

type_func = timedelta_to_milliseconds)

1197

interval = notifychangeproperty(dbus.UInt64,

1198

"Interval",

1199

type_func =

1200

timedelta_to_milliseconds)

1867

1201

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

1868

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

1869

invalidate_only=True)

1870

1202

1871

1203

del notifychangeproperty

1872

1204

1873

1205

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

1874

1206

try:

1875

1207

self.remove_from_connection()

1878

1210

if hasattr(DBusObjectWithProperties, "__del__"):

1879

1211

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

1880

1212

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

1881

1882

def checker_callback(self, source, condition,

1883

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

1884

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

1885

connection, command, *args,

1886

**kwargs)

1887

exitstatus = self.last_checker_status

1888

if exitstatus >= 0:

1213

1214

def checker_callback(self, pid, condition, command,

1215

*args, **kwargs):

1216

self.checker_callback_tag = None

1217

self.checker = None

1218

if os.WIFEXITED(condition):

1219

exitstatus = os.WEXITSTATUS(condition)

1889

1220

# Emit D-Bus signal

1890

1221

self.CheckerCompleted(dbus.Int16(exitstatus),

1891

# This is specific to GNU libC

1892

dbus.Int64(exitstatus << 8),

1222

dbus.Int64(condition),

1893

1223

dbus.String(command))

1894

1224

else:

1895

1225

# Emit D-Bus signal

1896

1226

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

1897

dbus.Int64(

1898

# This is specific to GNU libC

1899

(exitstatus << 8)

1900

| self.last_checker_signal),

1227

dbus.Int64(condition),

1901

1228

dbus.String(command))

1902

return ret

1903

1229

1230

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

1231

*args, **kwargs)

1232

1904

1233

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

1905

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

1234

old_checker = self.checker

1235

if self.checker is not None:

1236

old_checker_pid = self.checker.pid

1237

else:

1238

old_checker_pid = None

1906

1239

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

1907

1240

# Only if new checker process was started

1908

1241

if (self.checker is not None

1910

1243

# Emit D-Bus signal

1911

1244

self.CheckerStarted(self.current_checker_command)

1912

1245

return r

1913

1246

1914

1247

def _reset_approved(self):

1915

1248

self.approved = None

1916

1249

return False

1917

1250

1918

1251

def approve(self, value=True):

1252

self.send_changedstate()

1919

1253

self.approved = value

1920

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

1921

* 1000), self._reset_approved)

1922

self.send_changedstate()

1923

1924

# D-Bus methods, signals & properties

1925

1926

# Interfaces

1927

1928

# Signals

1929

1254

gobject.timeout_add(timedelta_to_milliseconds

1255

(self.approval_duration),

1256

self._reset_approved)

1257

1258

1259

## D-Bus methods, signals & properties

1260

_interface = "se.recompile.Mandos.Client"

1261

1262

## Interfaces

1263

1264

@dbus_interface_annotations(_interface)

1265

def _foo(self):

1266

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

1267

"false"}

1268

1269

## Signals

1270

1930

1271

# CheckerCompleted - signal

1931

1272

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

1932

1273

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

1933

1274

"D-Bus signal"

1934

1275

pass

1935

1276

1936

1277

# CheckerStarted - signal

1937

1278

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

1938

1279

def CheckerStarted(self, command):

1939

1280

"D-Bus signal"

1940

1281

pass

1941

1282

1942

1283

# PropertyChanged - signal

1943

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

1944

1284

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

1945

1285

def PropertyChanged(self, property, value):

1946

1286

"D-Bus signal"

1947

1287

pass

1948

1288

1949

1289

# GotSecret - signal

1950

1290

@dbus.service.signal(_interface)

1951

1291

def GotSecret(self):

1954

1294

server to mandos-client

1955

1295

"""

1956

1296

pass

1957

1297

1958

1298

# Rejected - signal

1959

1299

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

1960

1300

def Rejected(self, reason):

1961

1301

"D-Bus signal"

1962

1302

pass

1963

1303

1964

1304

# NeedApproval - signal

1965

1305

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

1966

1306

def NeedApproval(self, timeout, default):

1967

1307

"D-Bus signal"

1968

1308

return self.need_approval()

1969

1970

# Methods

1971

1309

1310

## Methods

1311

1972

1312

# Approve - method

1973

1313

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

1974

1314

def Approve(self, value):

1975

1315

self.approve(value)

1976

1316

1977

1317

# CheckedOK - method

1978

1318

@dbus.service.method(_interface)

1979

1319

def CheckedOK(self):

1980

1320

self.checked_ok()

1981

1321

1982

1322

# Enable - method

1983

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

1984

1323

@dbus.service.method(_interface)

1985

1324

def Enable(self):

1986

1325

"D-Bus method"

1987

1326

self.enable()

1988

1327

1989

1328

# StartChecker - method

1990

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

1991

1329

@dbus.service.method(_interface)

1992

1330

def StartChecker(self):

1993

1331

"D-Bus method"

1994

1332

self.start_checker()

1995

1333

1996

1334

# Disable - method

1997

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

1998

1335

@dbus.service.method(_interface)

1999

1336

def Disable(self):

2000

1337

"D-Bus method"

2001

1338

self.disable()

2002

1339

2003

1340

# StopChecker - method

2004

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

2005

1341

@dbus.service.method(_interface)

2006

1342

def StopChecker(self):

2007

1343

self.stop_checker()

2008

2009

# Properties

2010

1344

1345

## Properties

1346

2011

1347

# ApprovalPending - property

2012

1348

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

2013

1349

def ApprovalPending_dbus_property(self):

2014

1350

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

2015

1351

2016

1352

# ApprovedByDefault - property

2017

@dbus_service_property(_interface,

2018

signature="b",

1353

@dbus_service_property(_interface, signature="b",

2019

1354

access="readwrite")

2020

1355

def ApprovedByDefault_dbus_property(self, value=None):

2021

1356

if value is None: # get

2022

1357

return dbus.Boolean(self.approved_by_default)

2023

1358

self.approved_by_default = bool(value)

2024

1359

2025

1360

# ApprovalDelay - property

2026

@dbus_service_property(_interface,

2027

signature="t",

1361

@dbus_service_property(_interface, signature="t",

2028

1362

access="readwrite")

2029

1363

def ApprovalDelay_dbus_property(self, value=None):

2030

1364

if value is None: # get

2031

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

2032

* 1000)

1365

return dbus.UInt64(self.approval_delay_milliseconds())

2033

1366

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

2034

1367

2035

1368

# ApprovalDuration - property

2036

@dbus_service_property(_interface,

2037

signature="t",

1369

@dbus_service_property(_interface, signature="t",

2038

1370

access="readwrite")

2039

1371

def ApprovalDuration_dbus_property(self, value=None):

2040

1372

if value is None: # get

2041

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

2042

* 1000)

1373

return dbus.UInt64(timedelta_to_milliseconds(

1374

self.approval_duration))

2043

1375

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

2044

1376

2045

1377

# Name - property

2046

@dbus_annotations(

2047

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

2048

1378

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

2049

1379

def Name_dbus_property(self):

2050

1380

return dbus.String(self.name)

2051

2052

# KeyID - property

2053

@dbus_annotations(

2054

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

2055

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

2056

def KeyID_dbus_property(self):

2057

return dbus.String(self.key_id)

2058

1381

2059

1382

# Fingerprint - property

2060

@dbus_annotations(

2061

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

2062

1383

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

2063

1384

def Fingerprint_dbus_property(self):

2064

1385

return dbus.String(self.fingerprint)

2065

1386

2066

1387

# Host - property

2067

@dbus_service_property(_interface,

2068

signature="s",

1388

@dbus_service_property(_interface, signature="s",

2069

1389

access="readwrite")

2070

1390

def Host_dbus_property(self, value=None):

2071

1391

if value is None: # get

2072

1392

return dbus.String(self.host)

2073

self.host = str(value)

2074

1393

self.host = unicode(value)

1394

2075

1395

# Created - property

2076

@dbus_annotations(

2077

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

2078

1396

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

2079

1397

def Created_dbus_property(self):

2080

1398

return datetime_to_dbus(self.created)

2081

1399

2082

1400

# LastEnabled - property

2083

1401

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

2084

1402

def LastEnabled_dbus_property(self):

2085

1403

return datetime_to_dbus(self.last_enabled)

2086

1404

2087

1405

# Enabled - property

2088

@dbus_service_property(_interface,

2089

signature="b",

1406

@dbus_service_property(_interface, signature="b",

2090

1407

access="readwrite")

2091

1408

def Enabled_dbus_property(self, value=None):

2092

1409

if value is None: # get

2095

1412

self.enable()

2096

1413

else:

2097

1414

self.disable()

2098

1415

2099

1416

# LastCheckedOK - property

2100

@dbus_service_property(_interface,

2101

signature="s",

1417

@dbus_service_property(_interface, signature="s",

2102

1418

access="readwrite")

2103

1419

def LastCheckedOK_dbus_property(self, value=None):

2104

1420

if value is not None:

2105

1421

self.checked_ok()

2106

1422

return

2107

1423

return datetime_to_dbus(self.last_checked_ok)

2108

1424

2109

1425

# LastCheckerStatus - property

2110

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

1426

@dbus_service_property(_interface, signature="n",

1427

access="read")

2111

1428

def LastCheckerStatus_dbus_property(self):

2112

1429

return dbus.Int16(self.last_checker_status)

2113

1430

2114

1431

# Expires - property

2115

1432

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

2116

1433

def Expires_dbus_property(self):

2117

1434

return datetime_to_dbus(self.expires)

2118

1435

2119

1436

# LastApprovalRequest - property

2120

1437

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

2121

1438

def LastApprovalRequest_dbus_property(self):

2122

1439

return datetime_to_dbus(self.last_approval_request)

2123

1440

2124

1441

# Timeout - property

2125

@dbus_service_property(_interface,

2126

signature="t",

1442

@dbus_service_property(_interface, signature="t",

2127

1443

access="readwrite")

2128

1444

def Timeout_dbus_property(self, value=None):

2129

1445

if value is None: # get

2130

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

2131

old_timeout = self.timeout

1446

return dbus.UInt64(self.timeout_milliseconds())

2132

1447

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

2133

# Reschedule disabling

1448

# Reschedule timeout

2134

1449

if self.enabled:

2135

1450

now = datetime.datetime.utcnow()

2136

self.expires += self.timeout - old_timeout

2137

if self.expires <= now:

1451

time_to_die = timedelta_to_milliseconds(

1452

(self.last_checked_ok + self.timeout) - now)

1453

if time_to_die <= 0:

2138

1454

# The timeout has passed

2139

1455

self.disable()

2140

1456

else:

1457

self.expires = (now +

1458

datetime.timedelta(milliseconds =

1459

time_to_die))

2141

1460

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

2142

1461

is None):

2143

1462

return

2144

GLib.source_remove(self.disable_initiator_tag)

2145

self.disable_initiator_tag = GLib.timeout_add(

2146

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

2147

self.disable)

2148

1463

gobject.source_remove(self.disable_initiator_tag)

1464

self.disable_initiator_tag = (gobject.timeout_add

1465

(time_to_die,

1466

self.disable))

1467

2149

1468

# ExtendedTimeout - property

2150

@dbus_service_property(_interface,

2151

signature="t",

1469

@dbus_service_property(_interface, signature="t",

2152

1470

access="readwrite")

2153

1471

def ExtendedTimeout_dbus_property(self, value=None):

2154

1472

if value is None: # get

2155

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

2156

* 1000)

1473

return dbus.UInt64(self.extended_timeout_milliseconds())

2157

1474

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

2158

1475

2159

1476

# Interval - property

2160

@dbus_service_property(_interface,

2161

signature="t",

1477

@dbus_service_property(_interface, signature="t",

2162

1478

access="readwrite")

2163

1479

def Interval_dbus_property(self, value=None):

2164

1480

if value is None: # get

2165

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

1481

return dbus.UInt64(self.interval_milliseconds())

2166

1482

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

2167

1483

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

2168

1484

return

2169

1485

if self.enabled:

2170

1486

# Reschedule checker run

2171

GLib.source_remove(self.checker_initiator_tag)

2172

self.checker_initiator_tag = GLib.timeout_add(

2173

value, self.start_checker)

2174

self.start_checker() # Start one now, too

2175

1487

gobject.source_remove(self.checker_initiator_tag)

1488

self.checker_initiator_tag = (gobject.timeout_add

1489

(value, self.start_checker))

1490

self.start_checker() # Start one now, too

1491

2176

1492

# Checker - property

2177

@dbus_service_property(_interface,

2178

signature="s",

1493

@dbus_service_property(_interface, signature="s",

2179

1494

access="readwrite")

2180

1495

def Checker_dbus_property(self, value=None):

2181

1496

if value is None: # get

2182

1497

return dbus.String(self.checker_command)

2183

self.checker_command = str(value)

2184

1498

self.checker_command = unicode(value)

1499

2185

1500

# CheckerRunning - property

2186

@dbus_service_property(_interface,

2187

signature="b",

1501

@dbus_service_property(_interface, signature="b",

2188

1502

access="readwrite")

2189

1503

def CheckerRunning_dbus_property(self, value=None):

2190

1504

if value is None: # get

2193

1507

self.start_checker()

2194

1508

else:

2195

1509

self.stop_checker()

2196

1510

2197

1511

# ObjectPath - property

2198

@dbus_annotations(

2199

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

2200

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

2201

1512

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

2202

1513

def ObjectPath_dbus_property(self):

2203

return self.dbus_object_path # is already a dbus.ObjectPath

2204

1514

return self.dbus_object_path # is already a dbus.ObjectPath

1515

2205

1516

# Secret = property

2206

@dbus_annotations(

2207

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

2208

"invalidates"})

2209

@dbus_service_property(_interface,

2210

signature="ay",

2211

access="write",

2212

byte_arrays=True)

1517

@dbus_service_property(_interface, signature="ay",

1518

access="write", byte_arrays=True)

2213

1519

def Secret_dbus_property(self, value):

2214

self.secret = bytes(value)

2215

1520

self.secret = str(value)

1521

2216

1522

del _interface

2217

1523

2218

1524

2219

class ProxyClient:

2220

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

1525

class ProxyClient(object):

1526

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

2221

1527

self._pipe = child_pipe

2222

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

1528

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

2223

1529

if not self._pipe.recv():

2224

raise KeyError(key_id or fpr)

2225

1530

raise KeyError()

1531

2226

1532

def __getattribute__(self, name):

2227

1533

if name == '_pipe':

2228

1534

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

2231

1537

if data[0] == 'data':

2232

1538

return data[1]

2233

1539

if data[0] == 'function':

2234

2235

1540

def func(*args, **kwargs):

2236

1541

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

2237

1542

return self._pipe.recv()[1]

2238

2239

1543

return func

2240

1544

2241

1545

def __setattr__(self, name, value):

2242

1546

if name == '_pipe':

2243

1547

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

2244

1548

self._pipe.send(('setattr', name, value))

2245

1549

2246

1550

1551

class ClientDBusTransitional(ClientDBus):

1552

__metaclass__ = AlternateDBusNamesMetaclass

1553

1554

2247

1555

class ClientHandler(socketserver.BaseRequestHandler, object):

2248

1556

"""A class to handle client connections.

2249

1557

2250

1558

Instantiated once for each connection to handle it.

2251

1559

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

2252

1560

2253

1561

def handle(self):

2254

1562

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

2255

1563

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

2256

str(self.client_address))

1564

unicode(self.client_address))

2257

1565

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

2258

1566

self.server.child_pipe.fileno())

2259

2260

session = gnutls.ClientSession(self.request)

2261

2262

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

2263

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

2264

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

2265

# "+DHE-DSS"))

1567

1568

session = (gnutls.connection

1569

.ClientSession(self.request,

1570

gnutls.connection

1571

.X509Credentials()))

1572

1573

# Note: gnutls.connection.X509Credentials is really a

1574

# generic GnuTLS certificate credentials object so long as

1575

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

1576

# here despite using OpenPGP certificates.

1577

1578

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

1579

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

1580

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

1581

# "+DHE-DSS"))

2266

1582

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

2267

1583

priority = self.server.gnutls_priority

2268

1584

if priority is None:

2269

1585

priority = "NORMAL"

2270

gnutls.priority_set_direct(session._c_object,

2271

priority.encode("utf-8"),

2272

None)

2273

1586

(gnutls.library.functions

1587

.gnutls_priority_set_direct(session._c_object,

1588

priority, None))

1589

2274

1590

# Start communication using the Mandos protocol

2275

1591

# Get protocol number

2276

1592

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

2277

1593

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

2278

1594

try:

2279

1595

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

2280

raise RuntimeError(line)

1596

raise RuntimeError

2281

1597

except (ValueError, IndexError, RuntimeError) as error:

2282

1598

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

2283

1599

return

2284

1600

2285

1601

# Start GnuTLS connection

2286

1602

try:

2287

1603

session.handshake()

2288

except gnutls.Error as error:

1604

except gnutls.errors.GNUTLSError as error:

2289

1605

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

2290

1606

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

2291

1607

# established. Just abandon the request.

2292

1608

return

2293

1609

logger.debug("Handshake succeeded")

2294

1610

2295

1611

approval_required = False

2296

1612

try:

2297

if gnutls.has_rawpk:

2298

fpr = b""

2299

try:

2300

key_id = self.key_id(

2301

self.peer_certificate(session))

2302

except (TypeError, gnutls.Error) as error:

2303

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

2304

return

2305

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

2306

2307

else:

2308

key_id = b""

2309

try:

2310

fpr = self.fingerprint(

2311

self.peer_certificate(session))

2312

except (TypeError, gnutls.Error) as error:

2313

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

2314

return

2315

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

2316

2317

try:

2318

client = ProxyClient(child_pipe, key_id, fpr,

1613

try:

1614

fpr = self.fingerprint(self.peer_certificate

1615

(session))

1616

except (TypeError,

1617

gnutls.errors.GNUTLSError) as error:

1618

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

1619

return

1620

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

1621

1622

try:

1623

client = ProxyClient(child_pipe, fpr,

2319

1624

self.client_address)

2320

1625

except KeyError:

2321

1626

return

2322

1627

2323

1628

if client.approval_delay:

2324

1629

delay = client.approval_delay

2325

1630

client.approvals_pending += 1

2326

1631

approval_required = True

2327

1632

2328

1633

while True:

2329

1634

if not client.enabled:

2330

1635

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

2331

client.name)

1636

client.name)

2332

1637

if self.server.use_dbus:

2333

1638

# Emit D-Bus signal

2334

1639

client.Rejected("Disabled")

2335

1640

return

2336

1641

2337

1642

if client.approved or not client.approval_delay:

2338

# We are approved or approval is disabled

1643

#We are approved or approval is disabled

2339

1644

break

2340

1645

elif client.approved is None:

2341

1646

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

2343

1648

if self.server.use_dbus:

2344

1649

# Emit D-Bus signal

2345

1650

client.NeedApproval(

2346

client.approval_delay.total_seconds()

2347

* 1000, client.approved_by_default)

1651

client.approval_delay_milliseconds(),

1652

client.approved_by_default)

2348

1653

else:

2349

1654

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

2350

1655

client.name)

2352

1657

# Emit D-Bus signal

2353

1658

client.Rejected("Denied")

2354

1659

return

2355

2356

# wait until timeout or approved

1660

1661

#wait until timeout or approved

2357

1662

time = datetime.datetime.now()

2358

1663

client.changedstate.acquire()

2359

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

1664

(client.changedstate.wait

1665

(float(client.timedelta_to_milliseconds(delay)

1666

/ 1000)))

2360

1667

client.changedstate.release()

2361

1668

time2 = datetime.datetime.now()

2362

1669

if (time2 - time) >= delay:

2372

1679

break

2373

1680

else:

2374

1681

delay -= time2 - time

2375

2376

try:

2377

session.send(client.secret)

2378

except gnutls.Error as error:

2379

logger.warning("gnutls send failed",

2380

exc_info=error)

2381

return

2382

1682

1683

sent_size = 0

1684

while sent_size < len(client.secret):

1685

try:

1686

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

1687

except gnutls.errors.GNUTLSError as error:

1688

logger.warning("gnutls send failed")

1689

return

1690

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

1691

sent, len(client.secret)

1692

- (sent_size + sent))

1693

sent_size += sent

1694

2383

1695

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

2384

1696

# bump the timeout using extended_timeout

2385

1697

client.bump_timeout(client.extended_timeout)

2386

1698

if self.server.use_dbus:

2387

1699

# Emit D-Bus signal

2388

1700

client.GotSecret()

2389

1701

2390

1702

finally:

2391

1703

if approval_required:

2392

1704

client.approvals_pending -= 1

2393

1705

try:

2394

1706

session.bye()

2395

except gnutls.Error as error:

2396

logger.warning("GnuTLS bye failed",

2397

exc_info=error)

2398

1707

except gnutls.errors.GNUTLSError as error:

1708

logger.warning("GnuTLS bye failed")

1709

2399

1710

@staticmethod

2400

1711

def peer_certificate(session):

2401

"Return the peer's certificate as a bytestring"

2402

try:

2403

cert_type = gnutls.certificate_type_get2(session._c_object,

2404

gnutls.CTYPE_PEERS)

2405

except AttributeError:

2406

cert_type = gnutls.certificate_type_get(session._c_object)

2407

if gnutls.has_rawpk:

2408

valid_cert_types = frozenset((gnutls.CRT_RAWPK,))

2409

else:

2410

valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))

2411

# If not a valid certificate type...

2412

if cert_type not in valid_cert_types:

2413

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

2414

valid_cert_types)

2415

# ...return invalid data

2416

return b""

1712

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

1713

# If not an OpenPGP certificate...

1714

if (gnutls.library.functions

1715

.gnutls_certificate_type_get(session._c_object)

1716

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1717

# ...do the normal thing

1718

return session.peer_certificate

2417

1719

list_size = ctypes.c_uint(1)

2418

cert_list = (gnutls.certificate_get_peers

1720

cert_list = (gnutls.library.functions

1721

.gnutls_certificate_get_peers

2419

1722

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

2420

1723

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

2421

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

1724

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

1725

" certificate")

2422

1726

if list_size.value == 0:

2423

1727

return None

2424

1728

cert = cert_list[0]

2425

1729

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

2426

2427

@staticmethod

2428

def key_id(certificate):

2429

"Convert a certificate bytestring to a hexdigit key ID"

2430

# New GnuTLS "datum" with the public key

2431

datum = gnutls.datum_t(

2432

ctypes.cast(ctypes.c_char_p(certificate),

2433

ctypes.POINTER(ctypes.c_ubyte)),

2434

ctypes.c_uint(len(certificate)))

2435

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

2436

# New empty GnuTLS certificate

2437

pubkey = gnutls.pubkey_t()

2438

gnutls.pubkey_init(ctypes.byref(pubkey))

2439

# Import the raw public key into the certificate

2440

gnutls.pubkey_import(pubkey,

2441

ctypes.byref(datum),

2442

gnutls.X509_FMT_DER)

2443

# New buffer for the key ID

2444

buf = ctypes.create_string_buffer(32)

2445

buf_len = ctypes.c_size_t(len(buf))

2446

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

2447

gnutls.pubkey_get_key_id(pubkey,

2448

gnutls.KEYID_USE_SHA256,

2449

ctypes.cast(ctypes.byref(buf),

2450

ctypes.POINTER(ctypes.c_ubyte)),

2451

ctypes.byref(buf_len))

2452

# Deinit the certificate

2453

gnutls.pubkey_deinit(pubkey)

2454

2455

# Convert the buffer to a Python bytestring

2456

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

2457

# Convert the bytestring to hexadecimal notation

2458

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

2459

return hex_key_id

2460

1730

2461

1731

@staticmethod

2462

1732

def fingerprint(openpgp):

2463

1733

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2464

1734

# New GnuTLS "datum" with the OpenPGP public key

2465

datum = gnutls.datum_t(

2466

ctypes.cast(ctypes.c_char_p(openpgp),

2467

ctypes.POINTER(ctypes.c_ubyte)),

2468

ctypes.c_uint(len(openpgp)))

1735

datum = (gnutls.library.types

1736

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

1737

ctypes.POINTER

1738

(ctypes.c_ubyte)),

1739

ctypes.c_uint(len(openpgp))))

2469

1740

# New empty GnuTLS certificate

2470

crt = gnutls.openpgp_crt_t()

2471

gnutls.openpgp_crt_init(ctypes.byref(crt))

1741

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1742

(gnutls.library.functions

1743

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

2472

1744

# Import the OpenPGP public key into the certificate

2473

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

2474

gnutls.OPENPGP_FMT_RAW)

1745

(gnutls.library.functions

1746

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

1747

gnutls.library.constants

1748

.GNUTLS_OPENPGP_FMT_RAW))

2475

1749

# Verify the self signature in the key

2476

1750

crtverify = ctypes.c_uint()

2477

gnutls.openpgp_crt_verify_self(crt, 0,

2478

ctypes.byref(crtverify))

1751

(gnutls.library.functions

1752

.gnutls_openpgp_crt_verify_self(crt, 0,

1753

ctypes.byref(crtverify)))

2479

1754

if crtverify.value != 0:

2480

gnutls.openpgp_crt_deinit(crt)

2481

raise gnutls.CertificateSecurityError(code

2482

=crtverify.value)

1755

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1756

raise (gnutls.errors.CertificateSecurityError

1757

("Verify failed"))

2483

1758

# New buffer for the fingerprint

2484

1759

buf = ctypes.create_string_buffer(20)

2485

1760

buf_len = ctypes.c_size_t()

2486

1761

# Get the fingerprint from the certificate into the buffer

2487

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

2488

ctypes.byref(buf_len))

1762

(gnutls.library.functions

1763

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

1764

ctypes.byref(buf_len)))

2489

1765

# Deinit the certificate

2490

gnutls.openpgp_crt_deinit(crt)

1766

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2491

1767

# Convert the buffer to a Python bytestring

2492

1768

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

2493

1769

# Convert the bytestring to hexadecimal notation

2495

1771

return hex_fpr

2496

1772

2497

1773

2498

class MultiprocessingMixIn:

1774

class MultiprocessingMixIn(object):

2499

1775

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

2500

2501

1776

def sub_process_main(self, request, address):

2502

1777

try:

2503

1778

self.finish_request(request, address)

2504

1779

except Exception:

2505

1780

self.handle_error(request, address)

2506

1781

self.close_request(request)

2507

1782

2508

1783

def process_request(self, request, address):

2509

1784

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

2510

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

2511

args=(request, address))

1785

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

1786

args = (request,

1787

address))

2512

1788

proc.start()

2513

1789

return proc

2514

1790

2515

1791

2516

class MultiprocessingMixInWithPipe(MultiprocessingMixIn):

1792

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2517

1793

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

2518

2519

1794

def process_request(self, request, client_address):

2520

1795

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

2521

1796

2522

1797

This function creates a new pipe in self.pipe

2523

1798

"""

2524

1799

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2525

1800

2526

1801

proc = MultiprocessingMixIn.process_request(self, request,

2527

1802

client_address)

2528

1803

self.child_pipe.close()

2529

1804

self.add_pipe(parent_pipe, proc)

2530

1805

2531

1806

def add_pipe(self, parent_pipe, proc):

2532

1807

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

2533

raise NotImplementedError()

1808

raise NotImplementedError

2534

1809

2535

1810

2536

1811

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2537

socketserver.TCPServer):

1812

socketserver.TCPServer, object):

2538

1813

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

2539

1814

2540

1815

Attributes:

2541

1816

enabled: Boolean; whether this server is activated yet

2542

1817

interface: None or a network interface name (string)

2543

1818

use_ipv6: Boolean; to use IPv6 or not

2544

1819

"""

2545

2546

1820

def __init__(self, server_address, RequestHandlerClass,

2547

interface=None,

2548

use_ipv6=True,

2549

socketfd=None):

2550

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

2551

creating a new one with socket.socket().

2552

"""

1821

interface=None, use_ipv6=True):

2553

1822

self.interface = interface

2554

1823

if use_ipv6:

2555

1824

self.address_family = socket.AF_INET6

2556

if socketfd is not None:

2557

# Save the file descriptor

2558

self.socketfd = socketfd

2559

# Save the original socket.socket() function

2560

self.socket_socket = socket.socket

2561

2562

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

2563

#

2564

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

2565

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

2566

# patching socket.socket.)

2567

#

2568

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

2569

@functools.wraps(socket.socket)

2570

def socket_wrapper(*args, **kwargs):

2571

# Restore original function so subsequent calls are

2572

# not affected.

2573

socket.socket = self.socket_socket

2574

del self.socket_socket

2575

# This time only, return a new socket object from the

2576

# saved file descriptor.

2577

return socket.fromfd(self.socketfd, *args, **kwargs)

2578

# Replace socket.socket() function with wrapper

2579

socket.socket = socket_wrapper

2580

# The socketserver.TCPServer.__init__ will call

2581

# socket.socket(), which might be our replacement,

2582

# socket_wrapper(), if socketfd was set.

2583

1825

socketserver.TCPServer.__init__(self, server_address,

2584

1826

RequestHandlerClass)

2585

2586

1827

def server_bind(self):

2587

1828

"""This overrides the normal server_bind() function

2588

1829

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

2589

1830

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

2590

global SO_BINDTODEVICE

2591

1831

if self.interface is not None:

2592

1832

if SO_BINDTODEVICE is None:

2593

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

2594

# common enough.

2595

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

2596

SO_BINDTODEVICE = 25

2597

try:

2598

self.socket.setsockopt(

2599

socket.SOL_SOCKET, SO_BINDTODEVICE,

2600

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

2601

except socket.error as error:

2602

if error.errno == errno.EPERM:

2603

logger.error("No permission to bind to"

2604

" interface %s", self.interface)

2605

elif error.errno == errno.ENOPROTOOPT:

2606

logger.error("SO_BINDTODEVICE not available;"

2607

" cannot bind to interface %s",

2608

self.interface)

2609

elif error.errno == errno.ENODEV:

2610

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

2611

" cannot bind", self.interface)

2612

else:

2613

raise

1833

logger.error("SO_BINDTODEVICE does not exist;"

1834

" cannot bind to interface %s",

1835

self.interface)

1836

else:

1837

try:

1838

self.socket.setsockopt(socket.SOL_SOCKET,

1839

SO_BINDTODEVICE,

1840

str(self.interface

1841

+ '\0'))

1842

except socket.error as error:

1843

if error[0] == errno.EPERM:

1844

logger.error("No permission to"

1845

" bind to interface %s",

1846

self.interface)

1847

elif error[0] == errno.ENOPROTOOPT:

1848

logger.error("SO_BINDTODEVICE not available;"

1849

" cannot bind to interface %s",

1850

self.interface)

1851

else:

1852

raise

2614

1853

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

2615

1854

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

2616

if self.server_address[1]:

2617

self.allow_reuse_address = True

2618

1855

if not self.server_address[0]:

2619

1856

if self.address_family == socket.AF_INET6:

2620

any_address = "::" # in6addr_any

1857

any_address = "::" # in6addr_any

2621

1858

else:

2622

any_address = "0.0.0.0" # INADDR_ANY

1859

any_address = socket.INADDR_ANY

2623

1860

self.server_address = (any_address,

2624

1861

self.server_address[1])

2625

1862

elif not self.server_address[1]:

2626

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

1863

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

1864

0)

2627

1865

# if self.interface:

2628

1866

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

2629

1867

# 0, # port

2635

1873

2636

1874

class MandosServer(IPv6_TCPServer):

2637

1875

"""Mandos server.

2638

1876

2639

1877

Attributes:

2640

1878

clients: set of Client objects

2641

1879

gnutls_priority GnuTLS priority string

2642

1880

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

2643

2644

Assumes a GLib.MainLoop event loop.

1881

1882

Assumes a gobject.MainLoop event loop.

2645

1883

"""

2646

2647

1884

def __init__(self, server_address, RequestHandlerClass,

2648

interface=None,

2649

use_ipv6=True,

2650

clients=None,

2651

gnutls_priority=None,

2652

use_dbus=True,

2653

socketfd=None):

1885

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

1886

gnutls_priority=None, use_dbus=True):

2654

1887

self.enabled = False

2655

1888

self.clients = clients

2656

1889

if self.clients is None:

2659

1892

self.gnutls_priority = gnutls_priority

2660

1893

IPv6_TCPServer.__init__(self, server_address,

2661

1894

RequestHandlerClass,

2662

interface=interface,

2663

use_ipv6=use_ipv6,

2664

socketfd=socketfd)

2665

1895

interface = interface,

1896

use_ipv6 = use_ipv6)

2666

1897

def server_activate(self):

2667

1898

if self.enabled:

2668

1899

return socketserver.TCPServer.server_activate(self)

2669

1900

2670

1901

def enable(self):

2671

1902

self.enabled = True

2672

1903

2673

1904

def add_pipe(self, parent_pipe, proc):

2674

1905

# Call "handle_ipc" for both data and EOF events

2675

GLib.io_add_watch(

2676

parent_pipe.fileno(),

2677

GLib.IO_IN | GLib.IO_HUP,

2678

functools.partial(self.handle_ipc,

2679

parent_pipe=parent_pipe,

2680

proc=proc))

2681

2682

def handle_ipc(self, source, condition,

2683

parent_pipe=None,

2684

proc=None,

2685

client_object=None):

1906

gobject.io_add_watch(parent_pipe.fileno(),

1907

gobject.IO_IN | gobject.IO_HUP,

1908

functools.partial(self.handle_ipc,

1909

parent_pipe =

1910

parent_pipe,

1911

proc = proc))

1912

1913

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

1914

proc = None, client_object=None):

1915

condition_names = {

1916

gobject.IO_IN: "IN", # There is data to read.

1917

gobject.IO_OUT: "OUT", # Data can be written (without

1918

# blocking).

1919

gobject.IO_PRI: "PRI", # There is urgent data to read.

1920

gobject.IO_ERR: "ERR", # Error condition.

1921

gobject.IO_HUP: "HUP" # Hung up (the connection has been

1922

# broken, usually for pipes and

1923

# sockets).

1924

}

1925

conditions_string = ' | '.join(name

1926

for cond, name in

1927

condition_names.iteritems()

1928

if cond & condition)

2686

1929

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

2687

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

1930

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

2688

1931

# Wait for other process to exit

2689

1932

proc.join()

2690

1933

return False

2691

1934

2692

1935

# Read a request from the child

2693

1936

request = parent_pipe.recv()

2694

1937

command = request[0]

2695

1938

2696

1939

if command == 'init':

2697

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

2698

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

2699

address = request[3]

2700

2701

for c in self.clients.values():

2702

if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":

2703

continue

2704

if key_id and c.key_id == key_id:

2705

client = c

2706

break

2707

if fpr and c.fingerprint == fpr:

1940

fpr = request[1]

1941

address = request[2]

1942

1943

for c in self.clients.itervalues():

1944

if c.fingerprint == fpr:

2708

1945

client = c

2709

1946

break

2710

1947

else:

2711

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

2712

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

1948

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

1949

"dress: %s", fpr, address)

2713

1950

if self.use_dbus:

2714

1951

# Emit D-Bus signal

2715

mandos_dbus_service.ClientNotFound(key_id or fpr,

1952

mandos_dbus_service.ClientNotFound(fpr,

2716

1953

address[0])

2717

1954

parent_pipe.send(False)

2718

1955

return False

2719

2720

GLib.io_add_watch(

2721

parent_pipe.fileno(),

2722

GLib.IO_IN | GLib.IO_HUP,

2723

functools.partial(self.handle_ipc,

2724

parent_pipe=parent_pipe,

2725

proc=proc,

2726

client_object=client))

1956

1957

gobject.io_add_watch(parent_pipe.fileno(),

1958

gobject.IO_IN | gobject.IO_HUP,

1959

functools.partial(self.handle_ipc,

1960

parent_pipe =

1961

parent_pipe,

1962

proc = proc,

1963

client_object =

1964

client))

2727

1965

parent_pipe.send(True)

2728

1966

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

2729

1967

# same fileno

2732

1970

funcname = request[1]

2733

1971

args = request[2]

2734

1972

kwargs = request[3]

2735

1973

2736

1974

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

2737

1975

funcname)(*args,

2738

**kwargs)))

2739

1976

**kwargs)))

1977

2740

1978

if command == 'getattr':

2741

1979

attrname = request[1]

2742

if isinstance(client_object.__getattribute__(attrname),

2743

collections.Callable):

2744

parent_pipe.send(('function', ))

1980

if callable(client_object.__getattribute__(attrname)):

1981

parent_pipe.send(('function',))

2745

1982

else:

2746

parent_pipe.send((

2747

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

2748

1983

parent_pipe.send(('data', client_object

1984

.__getattribute__(attrname)))

1985

2749

1986

if command == 'setattr':

2750

1987

attrname = request[1]

2751

1988

value = request[2]

2752

1989

setattr(client_object, attrname, value)

2753

1990

2754

1991

return True

2755

1992

2756

1993

2757

def rfc3339_duration_to_delta(duration):

2758

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

2759

2760

>>> rfc3339_duration_to_delta("P7D")

2761

datetime.timedelta(7)

2762

>>> rfc3339_duration_to_delta("PT60S")

2763

datetime.timedelta(0, 60)

2764

>>> rfc3339_duration_to_delta("PT60M")

2765

datetime.timedelta(0, 3600)

2766

>>> rfc3339_duration_to_delta("PT24H")

2767

datetime.timedelta(1)

2768

>>> rfc3339_duration_to_delta("P1W")

2769

datetime.timedelta(7)

2770

>>> rfc3339_duration_to_delta("PT5M30S")

2771

datetime.timedelta(0, 330)

2772

>>> rfc3339_duration_to_delta("P1DT3M20S")

2773

datetime.timedelta(1, 200)

2774

"""

2775

2776

# Parsing an RFC 3339 duration with regular expressions is not

2777

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

2778

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

2779

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

2780

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

2781

# avoid excessive use of external libraries.

2782

2783

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

2784

Token = collections.namedtuple("Token", (

2785

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

2786

# a "group" containing digits

2787

"value", # datetime.timedelta or None

2788

"followers")) # Tokens valid after this token

2789

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

2790

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

2791

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

2792

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

2793

datetime.timedelta(seconds=1),

2794

frozenset((token_end, )))

2795

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

2796

datetime.timedelta(minutes=1),

2797

frozenset((token_second, token_end)))

2798

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

2799

datetime.timedelta(hours=1),

2800

frozenset((token_minute, token_end)))

2801

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

2802

None,

2803

frozenset((token_hour, token_minute,

2804

token_second)))

2805

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

2806

datetime.timedelta(days=1),

2807

frozenset((token_time, token_end)))

2808

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

2809

datetime.timedelta(weeks=4),

2810

frozenset((token_day, token_end)))

2811

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

2812

datetime.timedelta(weeks=52),

2813

frozenset((token_month, token_end)))

2814

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

2815

datetime.timedelta(weeks=1),

2816

frozenset((token_end, )))

2817

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

2818

frozenset((token_year, token_month,

2819

token_day, token_time,

2820

token_week)))

2821

# Define starting values:

2822

# Value so far

2823

value = datetime.timedelta()

2824

found_token = None

2825

# Following valid tokens

2826

followers = frozenset((token_duration, ))

2827

# String left to parse

2828

s = duration

2829

# Loop until end token is found

2830

while found_token is not token_end:

2831

# Search for any currently valid tokens

2832

for token in followers:

2833

match = token.regexp.match(s)

2834

if match is not None:

2835

# Token found

2836

if token.value is not None:

2837

# Value found, parse digits

2838

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

2839

# Add to value so far

2840

value += factor * token.value

2841

# Strip token from string

2842

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

2843

# Go to found token

2844

found_token = token

2845

# Set valid next tokens

2846

followers = found_token.followers

2847

break

2848

else:

2849

# No currently valid tokens were found

2850

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

2851

.format(duration))

2852

# End token found

2853

return value

2854

2855

2856

1994

def string_to_delta(interval):

2857

1995

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

2858

1996

2859

1997

>>> string_to_delta('7d')

2860

1998

datetime.timedelta(7)

2861

1999

>>> string_to_delta('60s')

2869

2007

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

2870

2008

datetime.timedelta(0, 330)

2871

2009

"""

2872

2873

try:

2874

return rfc3339_duration_to_delta(interval)

2875

except ValueError:

2876

pass

2877

2878

2010

timevalue = datetime.timedelta(0)

2879

2011

for s in interval.split():

2880

2012

try:

2881

suffix = s[-1]

2013

suffix = unicode(s[-1])

2882

2014

value = int(s[:-1])

2883

2015

if suffix == "d":

2884

2016

delta = datetime.timedelta(value)

2891

2023

elif suffix == "w":

2892

2024

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

2893

2025

else:

2894

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

2895

except IndexError as e:

2026

raise ValueError("Unknown suffix %r" % suffix)

2027

except (ValueError, IndexError) as e:

2896

2028

raise ValueError(*(e.args))

2897

2029

timevalue += delta

2898

2030

return timevalue

2899

2031

2900

2032

2901

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

2033

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

2902

2034

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

2903

2035

2904

2036

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

2905

2037

if os.fork():

2906

2038

sys.exit()

2914

2046

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

2915

2047

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

2916

2048

raise OSError(errno.ENODEV,

2917

"{} not a character device"

2918

.format(os.devnull))

2049

"%s not a character device"

2050

% os.devnull)

2919

2051

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

2920

2052

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

2921

2053

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

2924

2056

2925

2057

2926

2058

def main():

2927

2059

2928

2060

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

2929

2061

# Parsing of options, both command line and config file

2930

2062

2931

2063

parser = argparse.ArgumentParser()

2932

2064

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

2933

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

2065

version = "%%(prog)s %s" % version,

2934

2066

help="show version number and exit")

2935

2067

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

2936

2068

help="Bind to interface IF")

2942

2074

help="Run self-test")

2943

2075

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

2944

2076

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

2945

" to terminal", default=None)

2077

" to terminal")

2946

2078

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

2947

2079

help="Debug level for stdout output")

2948

2080

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

2955

2087

" files")

2956

2088

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

2957

2089

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

2958

" system bus interface", default=None)

2090

" system bus interface")

2959

2091

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

2960

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

2961

default=None)

2092

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

2962

2093

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

2963

2094

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

2964

" state", default=None)

2965

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

2966

help="Specify a file descriptor to a network"

2967

" socket to use instead of creating one")

2095

" state")

2968

2096

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

2969

2097

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

2970

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

2971

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

2972

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

2973

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

2974

default=None)

2975

2098

2976

2099

options = parser.parse_args()

2977

2100

2978

2101

if options.check:

2979

2102

import doctest

2980

fail_count, test_count = doctest.testmod()

2981

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

2982

2103

doctest.testmod()

2104

sys.exit()

2105

2983

2106

# Default values for config file for server-global settings

2984

if gnutls.has_rawpk:

2985

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

2986

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

2987

else:

2988

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

2989

":+SIGN-DSA-SHA256")

2990

server_defaults = {"interface": "",

2991

"address": "",

2992

"port": "",

2993

"debug": "False",

2994

"priority": priority,

2995

"servicename": "Mandos",

2996

"use_dbus": "True",

2997

"use_ipv6": "True",

2998

"debuglevel": "",

2999

"restore": "True",

3000

"socket": "",

3001

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

3002

"foreground": "False",

3003

"zeroconf": "True",

3004

}

3005

del priority

3006

2107

server_defaults = { "interface": "",

2108

"address": "",

2109

"port": "",

2110

"debug": "False",

2111

"priority":

2112

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

2113

"servicename": "Mandos",

2114

"use_dbus": "True",

2115

"use_ipv6": "True",

2116

"debuglevel": "",

2117

"restore": "True",

2118

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

2119

}

2120

3007

2121

# Parse config file for server-global settings

3008

server_config = configparser.ConfigParser(server_defaults)

2122

server_config = configparser.SafeConfigParser(server_defaults)

3009

2123

del server_defaults

3010

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

3011

# Convert the ConfigParser object to a dict

2124

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

2125

"mandos.conf"))

2126

# Convert the SafeConfigParser object to a dict

3012

2127

server_settings = server_config.defaults()

3013

2128

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

3014

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

3015

"foreground", "zeroconf"):

2129

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

3016

2130

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

3017

2131

option)

3018

2132

if server_settings["port"]:

3019

2133

server_settings["port"] = server_config.getint("DEFAULT",

3020

2134

"port")

3021

if server_settings["socket"]:

3022

server_settings["socket"] = server_config.getint("DEFAULT",

3023

"socket")

3024

# Later, stdin will, and stdout and stderr might, be dup'ed

3025

# over with an opened os.devnull. But we don't want this to

3026

# happen with a supplied network socket.

3027

if 0 <= server_settings["socket"] <= 2:

3028

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

3029

["socket"])

3030

2135

del server_config

3031

2136

3032

2137

# Override the settings from the config file with command line

3033

2138

# options, if set.

3034

2139

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

3035

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

3036

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

3037

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

2140

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

2141

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

2142

"statedir"):

3038

2143

value = getattr(options, option)

3039

2144

if value is not None:

3040

2145

server_settings[option] = value

3041

2146

del options

3042

2147

# Force all strings to be unicode

3043

2148

for option in server_settings.keys():

3044

if isinstance(server_settings[option], bytes):

3045

server_settings[option] = (server_settings[option]

3046

.decode("utf-8"))

3047

# Force all boolean options to be boolean

3048

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

3049

"foreground", "zeroconf"):

3050

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

3051

# Debug implies foreground

3052

if server_settings["debug"]:

3053

server_settings["foreground"] = True

2149

if type(server_settings[option]) is str:

2150

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

3054

2151

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

3055

2152

3056

2153

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

3057

3058

if (not server_settings["zeroconf"]

3059

and not (server_settings["port"]

3060

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

3061

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

3062

2154

3063

2155

# For convenience

3064

2156

debug = server_settings["debug"]

3065

2157

debuglevel = server_settings["debuglevel"]

3067

2159

use_ipv6 = server_settings["use_ipv6"]

3068

2160

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

3069

2161

stored_state_file)

3070

foreground = server_settings["foreground"]

3071

zeroconf = server_settings["zeroconf"]

3072

2162

3073

2163

if debug:

3074

2164

initlogger(debug, logging.DEBUG)

3075

2165

else:

3078

2168

else:

3079

2169

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

3080

2170

initlogger(debug, level)

3081

2171

3082

2172

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

3083

syslogger.setFormatter(

3084

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

3085

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

3086

server_settings["servicename"])))

3087

2173

syslogger.setFormatter(logging.Formatter

2174

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

2175

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

2176

% server_settings["servicename"]))

2177

3088

2178

# Parse config file with clients

3089

client_config = configparser.ConfigParser(Client.client_defaults)

2179

client_config = configparser.SafeConfigParser(Client

2180

.client_defaults)

3090

2181

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

3091

2182

"clients.conf"))

3092

2183

3093

2184

global mandos_dbus_service

3094

2185

mandos_dbus_service = None

3095

3096

socketfd = None

3097

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

3098

socketfd = server_settings["socket"]

3099

tcp_server = MandosServer(

3100

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

3101

ClientHandler,

3102

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

3103

use_ipv6=use_ipv6,

3104

gnutls_priority=server_settings["priority"],

3105

use_dbus=use_dbus,

3106

socketfd=socketfd)

3107

if not foreground:

3108

pidfilename = "/run/mandos.pid"

3109

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

3110

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

3111

pidfile = None

3112

try:

3113

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

3114

except IOError as e:

3115

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

3116

exc_info=e)

3117

3118

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

3119

("mandos", "mandos"),

3120

("nobody", "nogroup")):

3121

try:

3122

uid = pwd.getpwnam(name).pw_uid

3123

gid = pwd.getpwnam(group).pw_gid

3124

break

2186

2187

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

2188

server_settings["port"]),

2189

ClientHandler,

2190

interface=(server_settings["interface"]

2191

or None),

2192

use_ipv6=use_ipv6,

2193

gnutls_priority=

2194

server_settings["priority"],

2195

use_dbus=use_dbus)

2196

if not debug:

2197

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

2198

try:

2199

pidfile = open(pidfilename, "w")

2200

except IOError:

2201

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

2202

2203

try:

2204

uid = pwd.getpwnam("_mandos").pw_uid

2205

gid = pwd.getpwnam("_mandos").pw_gid

2206

except KeyError:

2207

try:

2208

uid = pwd.getpwnam("mandos").pw_uid

2209

gid = pwd.getpwnam("mandos").pw_gid

3125

2210

except KeyError:

3126

continue

3127

else:

3128

uid = 65534

3129

gid = 65534

2211

try:

2212

uid = pwd.getpwnam("nobody").pw_uid

2213

gid = pwd.getpwnam("nobody").pw_gid

2214

except KeyError:

2215

uid = 65534

2216

gid = 65534

3130

2217

try:

3131

2218

os.setgid(gid)

3132

2219

os.setuid(uid)

3133

if debug:

3134

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

3135

gid))

3136

2220

except OSError as error:

3137

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

3138

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

3139

if error.errno != errno.EPERM:

3140

raise

3141

2221

if error[0] != errno.EPERM:

2222

raise error

2223

3142

2224

if debug:

3143

2225

# Enable all possible GnuTLS debugging

3144

2226

3145

2227

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

3146

2228

# - GnuTLS manual

3147

gnutls.global_set_log_level(11)

3148

3149

@gnutls.log_func

2229

gnutls.library.functions.gnutls_global_set_log_level(11)

2230

2231

@gnutls.library.types.gnutls_log_func

3150

2232

def debug_gnutls(level, string):

3151

2233

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

3152

3153

gnutls.global_set_log_function(debug_gnutls)

3154

2234

2235

(gnutls.library.functions

2236

.gnutls_global_set_log_function(debug_gnutls))

2237

3155

2238

# Redirect stdin so all checkers get /dev/null

3156

2239

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

3157

2240

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

3158

2241

if null > 2:

3159

2242

os.close(null)

3160

2243

3161

2244

# Need to fork before connecting to D-Bus

3162

if not foreground:

2245

if not debug:

3163

2246

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

3164

2247

daemon()

3165

3166

if gi.version_info < (3, 10, 2):

3167

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

3168

# need to inform GLib that threads will be used.

3169

GLib.threads_init()

3170

2248

2249

gobject.threads_init()

2250

3171

2251

global main_loop

3172

2252

# From the Avahi example code

3173

2253

DBusGMainLoop(set_as_default=True)

3174

main_loop = GLib.MainLoop()

2254

main_loop = gobject.MainLoop()

3175

2255

bus = dbus.SystemBus()

3176

2256

# End of Avahi example code

3177

2257

if use_dbus:

3178

2258

try:

3179

2259

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

3180

bus,

3181

do_not_queue=True)

3182

old_bus_name = dbus.service.BusName(

3183

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

3184

do_not_queue=True)

3185

except dbus.exceptions.DBusException as e:

3186

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

2260

bus, do_not_queue=True)

2261

old_bus_name = (dbus.service.BusName

2262

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

2263

do_not_queue=True))

2264

except dbus.exceptions.NameExistsException as e:

2265

logger.error(unicode(e) + ", disabling D-Bus")

3187

2266

use_dbus = False

3188

2267

server_settings["use_dbus"] = False

3189

2268

tcp_server.use_dbus = False

3190

if zeroconf:

3191

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3192

service = AvahiServiceToSyslog(

3193

name=server_settings["servicename"],

3194

servicetype="_mandos._tcp",

3195

protocol=protocol,

3196

bus=bus)

3197

if server_settings["interface"]:

3198

service.interface = if_nametoindex(

3199

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

3200

2269

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2270

service = AvahiServiceToSyslog(name =

2271

server_settings["servicename"],

2272

servicetype = "_mandos._tcp",

2273

protocol = protocol, bus = bus)

2274

if server_settings["interface"]:

2275

service.interface = (if_nametoindex

2276

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

2277

3201

2278

global multiprocessing_manager

3202

2279

multiprocessing_manager = multiprocessing.Manager()

3203

2280

3204

2281

client_class = Client

3205

2282

if use_dbus:

3206

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

3207

2283

client_class = functools.partial(ClientDBusTransitional,

2284

bus = bus)

2285

3208

2286

client_settings = Client.config_parser(client_config)

3209

2287

old_client_settings = {}

3210

2288

clients_data = {}

3211

3212

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

3213

global wnull

3214

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

3215

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

3216

# mode

3217

if debug or not foreground:

3218

wnull.close()

3219

2289

3220

2290

# Get client data and settings from last running state.

3221

2291

if server_settings["restore"]:

3222

2292

try:

3223

2293

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

3224

if sys.version_info.major == 2:

3225

clients_data, old_client_settings = pickle.load(

3226

stored_state)

3227

else:

3228

bytes_clients_data, bytes_old_client_settings = (

3229

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

3230

# Fix bytes to strings

3231

# clients_data

3232

# .keys()

3233

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

3234

if isinstance(key, bytes)

3235

else key): value

3236

for key, value in

3237

bytes_clients_data.items()}

3238

del bytes_clients_data

3239

for key in clients_data:

3240

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

3241

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

3242

for k, v in

3243

clients_data[key].items()}

3244

clients_data[key] = value

3245

# .client_structure

3246

value["client_structure"] = [

3247

(s.decode("utf-8")

3248

if isinstance(s, bytes)

3249

else s) for s in

3250

value["client_structure"]]

3251

# .name & .host

3252

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

3253

if isinstance(value[k], bytes):

3254

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

3255

if "key_id" not in value:

3256

value["key_id"] = ""

3257

elif "fingerprint" not in value:

3258

value["fingerprint"] = ""

3259

# old_client_settings

3260

# .keys()

3261

old_client_settings = {

3262

(key.decode("utf-8")

3263

if isinstance(key, bytes)

3264

else key): value

3265

for key, value in

3266

bytes_old_client_settings.items()}

3267

del bytes_old_client_settings

3268

# .host

3269

for value in old_client_settings.values():

3270

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

3271

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

3272

.decode("utf-8"))

2294

clients_data, old_client_settings = (pickle.load

2295

(stored_state))

3273

2296

os.remove(stored_state_path)

3274

2297

except IOError as e:

3275

if e.errno == errno.ENOENT:

3276

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

3277

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

3278

else:

3279

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

3280

exc_info=e)

2298

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

2299

.format(e))

2300

if e.errno != errno.ENOENT:

3281

2301

raise

3282

2302

except EOFError as e:

3283

2303

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

3284

"EOFError:",

3285

exc_info=e)

3286

2304

"EOFError: {0}".format(e))

2305

3287

2306

with PGPEngine() as pgp:

3288

for client_name, client in clients_data.items():

3289

# Skip removed clients

3290

if client_name not in client_settings:

3291

continue

3292

2307

for client_name, client in clients_data.iteritems():

3293

2308

# Decide which value to use after restoring saved state.

3294

2309

# We have three different values: Old config file,

3295

2310

# new config file, and saved state.

3300

2315

# For each value in new config, check if it

3301

2316

# differs from the old config value (Except for

3302

2317

# the "secret" attribute)

3303

if (name != "secret"

3304

and (value !=

3305

old_client_settings[client_name][name])):

2318

if (name != "secret" and

2319

value != old_client_settings[client_name]

2320

[name]):

3306

2321

client[name] = value

3307

2322

except KeyError:

3308

2323

pass

3309

2324

3310

2325

# Clients who has passed its expire date can still be

3311

# enabled if its last checker was successful. A Client

2326

# enabled if its last checker was successful. Clients

3312

2327

# whose checker succeeded before we stored its state is

3313

2328

# assumed to have successfully run all checkers during

3314

2329

# downtime.

3316

2331

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

3317

2332

if not client["last_checked_ok"]:

3318

2333

logger.warning(

3319

"disabling client {} - Client never "

3320

"performed a successful checker".format(

3321

client_name))

2334

"disabling client {0} - Client never "

2335

"performed a successful checker"

2336

.format(client_name))

3322

2337

client["enabled"] = False

3323

2338

elif client["last_checker_status"] != 0:

3324

2339

logger.warning(

3325

"disabling client {} - Client last"

3326

" checker failed with error code"

3327

" {}".format(

3328

client_name,

3329

client["last_checker_status"]))

2340

"disabling client {0} - Client "

2341

"last checker failed with error code {1}"

2342

.format(client_name,

2343

client["last_checker_status"]))

3330

2344

client["enabled"] = False

3331

2345

else:

3332

client["expires"] = (

3333

datetime.datetime.utcnow()

3334

+ client["timeout"])

2346

client["expires"] = (datetime.datetime

2347

.utcnow()

2348

+ client["timeout"])

3335

2349

logger.debug("Last checker succeeded,"

3336

" keeping {} enabled".format(

3337

client_name))

2350

" keeping {0} enabled"

2351

.format(client_name))

3338

2352

try:

3339

client["secret"] = pgp.decrypt(

3340

client["encrypted_secret"],

3341

client_settings[client_name]["secret"])

2353

client["secret"] = (

2354

pgp.decrypt(client["encrypted_secret"],

2355

client_settings[client_name]

2356

["secret"]))

3342

2357

except PGPError:

3343

2358

# If decryption fails, we use secret from new settings

3344

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

3345

client_name))

3346

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

3347

["secret"])

2359

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

2360

.format(client_name))

2361

client["secret"] = (

2362

client_settings[client_name]["secret"])

3348

2363

2364

3349

2365

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

3350

2366

for client_name in (set(old_client_settings)

3351

2367

- set(client_settings)):

3355

2371

clients_data[client_name] = client_settings[client_name]

3356

2372

3357

2373

# Create all client objects

3358

for client_name, client in clients_data.items():

2374

for client_name, client in clients_data.iteritems():

3359

2375

tcp_server.clients[client_name] = client_class(

3360

name=client_name,

3361

settings=client,

3362

server_settings=server_settings)

3363

2376

name = client_name, settings = client)

2377

3364

2378

if not tcp_server.clients:

3365

2379

logger.warning("No clients defined")

3366

3367

if not foreground:

3368

if pidfile is not None:

3369

pid = os.getpid()

3370

try:

3371

with pidfile:

3372

print(pid, file=pidfile)

3373

except IOError:

3374

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

3375

pidfilename, pid)

3376

del pidfile

2380

2381

if not debug:

2382

try:

2383

with pidfile:

2384

pid = os.getpid()

2385

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

2386

del pidfile

2387

except IOError:

2388

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

2389

pidfilename, pid)

2390

except NameError:

2391

# "pidfile" was never created

2392

pass

3377

2393

del pidfilename

3378

3379

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

3380

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3381

lambda: main_loop.quit() and False)

3382

2394

signal.signal(signal.SIGINT, signal.SIG_IGN)

2395

2396

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

2397

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

2398

3383

2399

if use_dbus:

3384

3385

@alternate_dbus_interfaces(

3386

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

3387

class MandosDBusService(DBusObjectWithObjectManager):

2400

class MandosDBusService(DBusObjectWithProperties):

3388

2401

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

3389

3390

2402

def __init__(self):

3391

2403

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

3392

3393

2404

_interface = "se.recompile.Mandos"

3394

2405

2406

@dbus_interface_annotations(_interface)

2407

def _foo(self):

2408

return { "org.freedesktop.DBus.Property"

2409

".EmitsChangedSignal":

2410

"false"}

2411

3395

2412

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

3396

2413

def ClientAdded(self, objpath):

3397

2414

"D-Bus signal"

3398

2415

pass

3399

2416

3400

2417

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

3401

def ClientNotFound(self, key_id, address):

2418

def ClientNotFound(self, fingerprint, address):

3402

2419

"D-Bus signal"

3403

2420

pass

3404

3405

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

3406

"true"})

2421

3407

2422

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

3408

2423

def ClientRemoved(self, objpath, name):

3409

2424

"D-Bus signal"

3410

2425

pass

3411

3412

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

3413

"true"})

2426

3414

2427

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

3415

2428

def GetAllClients(self):

3416

2429

"D-Bus method"

3417

return dbus.Array(c.dbus_object_path for c in

3418

tcp_server.clients.values())

3419

3420

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

3421

"true"})

2430

return dbus.Array(c.dbus_object_path

2431

for c in

2432

tcp_server.clients.itervalues())

2433

3422

2434

@dbus.service.method(_interface,

3423

2435

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

3424

2436

def GetAllClientsWithProperties(self):

3425

2437

"D-Bus method"

3426

2438

return dbus.Dictionary(

3427

{c.dbus_object_path: c.GetAll(

3428

"se.recompile.Mandos.Client")

3429

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

2439

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

2440

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

3430

2441

signature="oa{sv}")

3431

2442

3432

2443

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

3433

2444

def RemoveClient(self, object_path):

3434

2445

"D-Bus method"

3435

for c in tcp_server.clients.values():

2446

for c in tcp_server.clients.itervalues():

3436

2447

if c.dbus_object_path == object_path:

3437

2448

del tcp_server.clients[c.name]

3438

2449

c.remove_from_connection()

3439

# Don't signal the disabling

2450

# Don't signal anything except ClientRemoved

3440

2451

c.disable(quiet=True)

3441

# Emit D-Bus signal for removal

3442

self.client_removed_signal(c)

2452

# Emit D-Bus signal

2453

self.ClientRemoved(object_path, c.name)

3443

2454

return

3444

2455

raise KeyError(object_path)

3445

2456

3446

2457

del _interface

3447

3448

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3449

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

3450

def GetManagedObjects(self):

3451

"""D-Bus method"""

3452

return dbus.Dictionary(

3453

{client.dbus_object_path:

3454

dbus.Dictionary(

3455

{interface: client.GetAll(interface)

3456

for interface in

3457

client._get_all_interface_names()})

3458

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

3459

3460

def client_added_signal(self, client):

3461

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

3462

if use_dbus:

3463

# New standard signal

3464

self.InterfacesAdded(

3465

client.dbus_object_path,

3466

dbus.Dictionary(

3467

{interface: client.GetAll(interface)

3468

for interface in

3469

client._get_all_interface_names()}))

3470

# Old signal

3471

self.ClientAdded(client.dbus_object_path)

3472

3473

def client_removed_signal(self, client):

3474

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

3475

if use_dbus:

3476

# New standard signal

3477

self.InterfacesRemoved(

3478

client.dbus_object_path,

3479

client._get_all_interface_names())

3480

# Old signal

3481

self.ClientRemoved(client.dbus_object_path,

3482

client.name)

3483

3484

mandos_dbus_service = MandosDBusService()

3485

3486

# Save modules to variables to exempt the modules from being

3487

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

3488

mp = multiprocessing

3489

wn = wnull

3490

2458

2459

class MandosDBusServiceTransitional(MandosDBusService):

2460

__metaclass__ = AlternateDBusNamesMetaclass

2461

mandos_dbus_service = MandosDBusServiceTransitional()

2462

3491

2463

def cleanup():

3492

2464

"Cleanup function; run on exit"

3493

if zeroconf:

3494

service.cleanup()

3495

3496

mp.active_children()

3497

wn.close()

2465

service.cleanup()

2466

2467

multiprocessing.active_children()

3498

2468

if not (tcp_server.clients or client_settings):

3499

2469

return

3500

2470

3501

2471

# Store client before exiting. Secrets are encrypted with key

3502

2472

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

3503

2473

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

3504

2474

clients = {}

3505

2475

with PGPEngine() as pgp:

3506

for client in tcp_server.clients.values():

2476

for client in tcp_server.clients.itervalues():

3507

2477

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

3508

2478

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

3509

2479

key)

3510

2480

client_dict = {}

3511

2481

3512

2482

# A list of attributes that can not be pickled

3513

2483

# + secret.

3514

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

3515

"checker", "server_settings"}

3516

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

3517

.Object):

2484

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

2485

"checker"))

2486

for name, typ in (inspect.getmembers

2487

(dbus.service.Object)):

3518

2488

exclude.add(name)

3519

2489

3520

2490

client_dict["encrypted_secret"] = (client

3521

2491

.encrypted_secret)

3522

2492

for attr in client.client_structure:

3523

2493

if attr not in exclude:

3524

2494

client_dict[attr] = getattr(client, attr)

3525

2495

3526

2496

clients[client.name] = client_dict

3527

2497

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

3528

2498

3529

2499

try:

3530

with tempfile.NamedTemporaryFile(

3531

mode='wb',

3532

suffix=".pickle",

3533

prefix='clients-',

3534

dir=os.path.dirname(stored_state_path),

3535

delete=False) as stored_state:

3536

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

3537

protocol=2)

3538

tempname = stored_state.name

2500

tempfd, tempname = tempfile.mkstemp(suffix=".pickle",

2501

prefix="clients-",

2502

dir=os.path.dirname

2503

(stored_state_path))

2504

with os.fdopen(tempfd, "wb") as stored_state:

2505

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

3539

2506

os.rename(tempname, stored_state_path)

3540

2507

except (IOError, OSError) as e:

2508

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

2509

.format(e))

3541

2510

if not debug:

3542

2511

try:

3543

2512

os.remove(tempname)

3544

2513

except NameError:

3545

2514

pass

3546

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

3547

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

3548

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

3549

else:

3550

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

3551

exc_info=e)

3552

raise

3553

2515

if e.errno not in set((errno.ENOENT, errno.EACCES,

2516

errno.EEXIST)):

2517

raise e

2518

3554

2519

# Delete all clients, and settings from config

3555

2520

while tcp_server.clients:

3556

2521

name, client = tcp_server.clients.popitem()

3557

2522

if use_dbus:

3558

2523

client.remove_from_connection()

3559

# Don't signal the disabling

2524

# Don't signal anything except ClientRemoved

3560

2525

client.disable(quiet=True)

3561

# Emit D-Bus signal for removal

3562

2526

if use_dbus:

3563

mandos_dbus_service.client_removed_signal(client)

2527

# Emit D-Bus signal

2528

mandos_dbus_service.ClientRemoved(client

2529

.dbus_object_path,

2530

client.name)

3564

2531

client_settings.clear()

3565

2532

3566

2533

atexit.register(cleanup)

3567

3568

for client in tcp_server.clients.values():

2534

2535

for client in tcp_server.clients.itervalues():

3569

2536

if use_dbus:

3570

# Emit D-Bus signal for adding

3571

mandos_dbus_service.client_added_signal(client)

2537

# Emit D-Bus signal

2538

mandos_dbus_service.ClientAdded(client.dbus_object_path)

3572

2539

# Need to initiate checking of clients

3573

2540

if client.enabled:

3574

2541

client.init_checker()

3575

2542

3576

2543

tcp_server.enable()

3577

2544

tcp_server.server_activate()

3578

2545

3579

2546

# Find out what port we got

3580

if zeroconf:

3581

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

2547

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

3582

2548

if use_ipv6:

3583

2549

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

3584

" flowinfo %d, scope_id %d",

3585

*tcp_server.socket.getsockname())

2550

" flowinfo %d, scope_id %d"

2551

% tcp_server.socket.getsockname())

3586

2552

else: # IPv4

3587

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

3588

*tcp_server.socket.getsockname())

3589

3590

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

3591

2553

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

2554

% tcp_server.socket.getsockname())

2555

2556

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

2557

3592

2558

try:

3593

if zeroconf:

3594

# From the Avahi example code

3595

try:

3596

service.activate()

3597

except dbus.exceptions.DBusException as error:

3598

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

3599

cleanup()

3600

sys.exit(1)

3601

# End of Avahi example code

3602

3603

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

3604

lambda *args, **kwargs:

3605

(tcp_server.handle_request

3606

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

3607

2559

# From the Avahi example code

2560

try:

2561

service.activate()

2562

except dbus.exceptions.DBusException as error:

2563

logger.critical("DBusException: %s", error)

2564

cleanup()

2565

sys.exit(1)

2566

# End of Avahi example code

2567

2568

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

2569

lambda *args, **kwargs:

2570

(tcp_server.handle_request

2571

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

2572

3608

2573

logger.debug("Starting main loop")

3609

2574

main_loop.run()

3610

2575

except AvahiError as error:

3611

logger.critical("Avahi Error", exc_info=error)

2576

logger.critical("AvahiError: %s", error)

3612

2577

cleanup()

3613

2578

sys.exit(1)

3614

2579

except KeyboardInterrupt:

3619

2584

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

3620

2585

cleanup()

3621

2586

3622

3623

2587

if __name__ == '__main__':

3624

2588

main()