/mandos/trunk : revision 549

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

import itertools

78

import collections

79

import codecs

80

68

81

69

import dbus

82

70

import dbus.service

83

from gi.repository import GLib

71

import gobject

72

import avahi

84

73

from dbus.mainloop.glib import DBusGMainLoop

85

74

import ctypes

86

75

import ctypes.util

87

76

import xml.dom.minidom

88

77

import inspect

78

import GnuPGInterface

89

79

90

# Try to find the value of SO_BINDTODEVICE:

91

80

try:

92

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

93

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

94

81

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

95

82

except AttributeError:

96

83

try:

97

# This is where SO_BINDTODEVICE was up to and including Python

98

# 2.6, and also 3.2:

99

84

from IN import SO_BINDTODEVICE

100

85

except ImportError:

101

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

102

# Try running the C preprocessor:

103

try:

104

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

105

"/dev/stdin"],

106

stdin=subprocess.PIPE,

107

stdout=subprocess.PIPE)

108

stdout = cc.communicate(

109

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

110

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

111

except (OSError, ValueError, IndexError):

112

# No value found

113

SO_BINDTODEVICE = None

114

115

if sys.version_info.major == 2:

116

str = unicode

117

118

version = "1.7.16"

86

SO_BINDTODEVICE = None

87

88

version = "1.5.0"

119

89

stored_state_file = "clients.pickle"

120

90

121

91

logger = logging.getLogger()

122

syslogger = None

92

syslogger = (logging.handlers.SysLogHandler

93

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

94

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

123

95

124

96

try:

125

if_nametoindex = ctypes.cdll.LoadLibrary(

126

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

97

if_nametoindex = (ctypes.cdll.LoadLibrary

98

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

99

.if_nametoindex)

127

100

except (OSError, AttributeError):

128

129

101

def if_nametoindex(interface):

130

102

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

131

103

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

132

104

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

133

105

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

134

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

135

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

106

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

107

interface))

108

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

109

ifreq[16:20])[0]

136

110

return interface_index

137

111

138

112

139

def copy_function(func):

140

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

141

if sys.version_info.major == 2:

142

return types.FunctionType(func.func_code,

143

func.func_globals,

144

func.func_name,

145

func.func_defaults,

146

func.func_closure)

147

else:

148

return types.FunctionType(func.__code__,

149

func.__globals__,

150

func.__name__,

151

func.__defaults__,

152

func.__closure__)

153

154

155

113

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

156

114

"""init logger and add loglevel"""

157

158

global syslogger

159

syslogger = (logging.handlers.SysLogHandler(

160

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

161

address="/dev/log"))

115

162

116

syslogger.setFormatter(logging.Formatter

163

117

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

164

118

' %(message)s'))

165

119

logger.addHandler(syslogger)

166

120

167

121

if debug:

168

122

console = logging.StreamHandler()

169

123

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

181

135

182

136

class PGPEngine(object):

183

137

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

184

185

138

def __init__(self):

139

self.gnupg = GnuPGInterface.GnuPG()

186

140

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

187

self.gpg = "gpg"

188

try:

189

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

190

for line in output.splitlines():

191

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

192

if name == "gpg":

193

self.gpg = path

194

break

195

except OSError as e:

196

if e.errno != errno.ENOENT:

197

raise

198

self.gnupgargs = ['--batch',

199

'--homedir', self.tempdir,

200

'--force-mdc',

201

'--quiet']

202

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

203

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

204

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

205

141

self.gnupg = GnuPGInterface.GnuPG()

142

self.gnupg.options.meta_interactive = False

143

self.gnupg.options.homedir = self.tempdir

144

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

145

'--quiet',

146

'--no-use-agent'])

147

206

148

def __enter__(self):

207

149

return self

208

209

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

150

151

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

210

152

self._cleanup()

211

153

return False

212

154

213

155

def __del__(self):

214

156

self._cleanup()

215

157

216

158

def _cleanup(self):

217

159

if self.tempdir is not None:

218

160

# Delete contents of tempdir

219

161

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

220

topdown=False):

162

topdown = False):

221

163

for filename in files:

222

164

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

223

165

for dirname in dirs:

225

167

# Remove tempdir

226

168

os.rmdir(self.tempdir)

227

169

self.tempdir = None

228

170

229

171

def password_encode(self, password):

230

172

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

231

173

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

232

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

233

if len(encoded) > 2048:

234

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

235

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

236

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

237

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

238

return encoded

239

174

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

175

240

176

def encrypt(self, data, password):

241

passphrase = self.password_encode(password)

242

with tempfile.NamedTemporaryFile(

243

dir=self.tempdir) as passfile:

244

passfile.write(passphrase)

245

passfile.flush()

246

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

247

'--passphrase-file',

248

passfile.name]

249

+ self.gnupgargs,

250

stdin=subprocess.PIPE,

251

stdout=subprocess.PIPE,

252

stderr=subprocess.PIPE)

253

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

254

if proc.returncode != 0:

255

raise PGPError(err)

177

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

178

with open(os.devnull) as devnull:

179

try:

180

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

181

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

182

attach_fhs={'stderr': devnull})

183

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

184

f.write(data)

185

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

186

ciphertext = f.read()

187

proc.wait()

188

except IOError as e:

189

raise PGPError(e)

190

self.gnupg.passphrase = None

256

191

return ciphertext

257

192

258

193

def decrypt(self, data, password):

259

passphrase = self.password_encode(password)

260

with tempfile.NamedTemporaryFile(

261

dir=self.tempdir) as passfile:

262

passfile.write(passphrase)

263

passfile.flush()

264

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

265

'--passphrase-file',

266

passfile.name]

267

+ self.gnupgargs,

268

stdin=subprocess.PIPE,

269

stdout=subprocess.PIPE,

270

stderr=subprocess.PIPE)

271

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

272

if proc.returncode != 0:

273

raise PGPError(err)

194

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

195

with open(os.devnull) as devnull:

196

try:

197

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

198

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

199

attach_fhs={'stderr': devnull})

200

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

201

f.write(data)

202

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

203

decrypted_plaintext = f.read()

204

proc.wait()

205

except IOError as e:

206

raise PGPError(e)

207

self.gnupg.passphrase = None

274

208

return decrypted_plaintext

275

209

276

210

277

# Pretend that we have an Avahi module

278

class Avahi(object):

279

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

280

It is instantiated once, and simulates having an Avahi module."""

281

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

282

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

283

PROTO_INET = 0 # avahi-common/address.h

284

PROTO_INET6 = 1 # avahi-common/address.h

285

DBUS_NAME = "org.freedesktop.Avahi"

286

DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"

287

DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"

288

DBUS_PATH_SERVER = "/"

289

290

def string_array_to_txt_array(self, t):

291

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

292

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

293

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

294

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

295

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

296

SERVER_INVALID = 0 # avahi-common/defs.h

297

SERVER_REGISTERING = 1 # avahi-common/defs.h

298

SERVER_RUNNING = 2 # avahi-common/defs.h

299

SERVER_COLLISION = 3 # avahi-common/defs.h

300

SERVER_FAILURE = 4 # avahi-common/defs.h

301

avahi = Avahi()

302

303

211

304

212

class AvahiError(Exception):

305

213

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

306

214

self.value = value

307

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

308

**kwargs)

309

215

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

216

def __unicode__(self):

217

return unicode(repr(self.value))

310

218

311

219

class AvahiServiceError(AvahiError):

312

220

pass

313

221

314

315

222

class AvahiGroupError(AvahiError):

316

223

pass

317

224

318

225

319

226

class AvahiService(object):

320

227

"""An Avahi (Zeroconf) service.

321

228

322

229

Attributes:

323

230

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

324

231

Used to optionally bind to the specified interface.

325

232

name: string; Example: 'Mandos'

326

233

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

327

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

234

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

328

235

port: integer; what port to announce

329

236

TXT: list of strings; TXT record for the service

330

237

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

336

243

server: D-Bus Server

337

244

bus: dbus.SystemBus()

338

245

"""

339

340

def __init__(self,

341

interface=avahi.IF_UNSPEC,

342

name=None,

343

servicetype=None,

344

port=None,

345

TXT=None,

346

domain="",

347

host="",

348

max_renames=32768,

349

protocol=avahi.PROTO_UNSPEC,

350

bus=None):

246

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

247

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

248

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

249

protocol = avahi.PROTO_UNSPEC, bus = None):

351

250

self.interface = interface

352

251

self.name = name

353

252

self.type = servicetype

362

261

self.server = None

363

262

self.bus = bus

364

263

self.entry_group_state_changed_match = None

365

366

def rename(self, remove=True):

264

def rename(self):

367

265

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

368

266

if self.rename_count >= self.max_renames:

369

267

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

370

268

" after %i retries, exiting.",

371

269

self.rename_count)

372

270

raise AvahiServiceError("Too many renames")

373

self.name = str(

374

self.server.GetAlternativeServiceName(self.name))

375

self.rename_count += 1

271

self.name = unicode(self.server

272

.GetAlternativeServiceName(self.name))

376

273

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

377

274

self.name)

378

if remove:

379

self.remove()

275

self.remove()

380

276

try:

381

277

self.add()

382

278

except dbus.exceptions.DBusException as error:

383

if (error.get_dbus_name()

384

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

385

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

386

return self.rename(remove=False)

387

else:

388

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

389

self.cleanup()

390

os._exit(1)

391

279

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

280

self.cleanup()

281

os._exit(1)

282

self.rename_count += 1

392

283

def remove(self):

393

284

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

394

285

if self.entry_group_state_changed_match is not None:

396

287

self.entry_group_state_changed_match = None

397

288

if self.group is not None:

398

289

self.group.Reset()

399

400

290

def add(self):

401

291

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

402

292

self.remove()

419

309

dbus.UInt16(self.port),

420

310

avahi.string_array_to_txt_array(self.TXT))

421

311

self.group.Commit()

422

423

312

def entry_group_state_changed(self, state, error):

424

313

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

425

314

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

426

315

427

316

if state == avahi.ENTRY_GROUP_ESTABLISHED:

428

317

logger.debug("Zeroconf service established.")

429

318

elif state == avahi.ENTRY_GROUP_COLLISION:

431

320

self.rename()

432

321

elif state == avahi.ENTRY_GROUP_FAILURE:

433

322

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

434

str(error))

435

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

436

323

unicode(error))

324

raise AvahiGroupError("State changed: %s"

325

% unicode(error))

437

326

def cleanup(self):

438

327

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

439

328

if self.group is not None:

444

333

pass

445

334

self.group = None

446

335

self.remove()

447

448

336

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

449

337

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

450

338

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

451

bad_states = {

452

avahi.SERVER_INVALID: "Zeroconf server invalid",

453

avahi.SERVER_REGISTERING: None,

454

avahi.SERVER_COLLISION: "Zeroconf server name collision",

455

avahi.SERVER_FAILURE: "Zeroconf server failure",

456

}

339

bad_states = { avahi.SERVER_INVALID:

340

"Zeroconf server invalid",

341

avahi.SERVER_REGISTERING: None,

342

avahi.SERVER_COLLISION:

343

"Zeroconf server name collision",

344

avahi.SERVER_FAILURE:

345

"Zeroconf server failure" }

457

346

if state in bad_states:

458

347

if bad_states[state] is not None:

459

348

if error is None:

462

351

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

463

352

self.cleanup()

464

353

elif state == avahi.SERVER_RUNNING:

465

try:

466

self.add()

467

except dbus.exceptions.DBusException as error:

468

if (error.get_dbus_name()

469

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

470

logger.info("Local Zeroconf service name"

471

" collision.")

472

return self.rename(remove=False)

473

else:

474

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

475

self.cleanup()

476

os._exit(1)

354

self.add()

477

355

else:

478

356

if error is None:

479

357

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

480

358

else:

481

359

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

482

483

360

def activate(self):

484

361

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

485

362

if self.server is None:

489

366

follow_name_owner_changes=True),

490

367

avahi.DBUS_INTERFACE_SERVER)

491

368

self.server.connect_to_signal("StateChanged",

492

self.server_state_changed)

369

self.server_state_changed)

493

370

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

494

371

495

496

372

class AvahiServiceToSyslog(AvahiService):

497

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

373

def rename(self):

498

374

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

499

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

500

**kwargs)

501

syslogger.setFormatter(logging.Formatter(

502

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

503

.format(self.name)))

375

ret = AvahiService.rename(self)

376

syslogger.setFormatter(logging.Formatter

377

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

378

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

379

% self.name))

504

380

return ret

505

381

506

507

# Pretend that we have a GnuTLS module

508

class GnuTLS(object):

509

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

510

It is instantiated once, and simulates having a GnuTLS module."""

511

512

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

513

if library is None:

514

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

515

_library = ctypes.cdll.LoadLibrary(library)

516

del library

517

_need_version = b"3.3.0"

518

519

def __init__(self):

520

# Need to use "self" here, since this method is called before

521

# the assignment to the "gnutls" global variable happens.

522

if self.check_version(self._need_version) is None:

523

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

524

.format(self._need_version))

525

526

# Unless otherwise indicated, the constants and types below are

527

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

528

529

# Constants

530

E_SUCCESS = 0

531

E_INTERRUPTED = -52

532

E_AGAIN = -28

533

CRT_OPENPGP = 2

534

CLIENT = 2

535

SHUT_RDWR = 0

536

CRD_CERTIFICATE = 1

537

E_NO_CERTIFICATE_FOUND = -49

538

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

539

540

# Types

541

class session_int(ctypes.Structure):

542

_fields_ = []

543

session_t = ctypes.POINTER(session_int)

544

545

class certificate_credentials_st(ctypes.Structure):

546

_fields_ = []

547

certificate_credentials_t = ctypes.POINTER(

548

certificate_credentials_st)

549

certificate_type_t = ctypes.c_int

550

551

class datum_t(ctypes.Structure):

552

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

553

('size', ctypes.c_uint)]

554

555

class openpgp_crt_int(ctypes.Structure):

556

_fields_ = []

557

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

558

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

559

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

560

credentials_type_t = ctypes.c_int

561

transport_ptr_t = ctypes.c_void_p

562

close_request_t = ctypes.c_int

563

564

# Exceptions

565

class Error(Exception):

566

# We need to use the class name "GnuTLS" here, since this

567

# exception might be raised from within GnuTLS.__init__,

568

# which is called before the assignment to the "gnutls"

569

# global variable has happened.

570

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

571

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

572

# code is passed, convert it to a string with

573

# gnutls.strerror()

574

self.code = code

575

if message is None and code is not None:

576

message = GnuTLS.strerror(code)

577

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

578

message, *args)

579

580

class CertificateSecurityError(Error):

581

pass

582

583

# Classes

584

class Credentials(object):

585

def __init__(self):

586

self._c_object = gnutls.certificate_credentials_t()

587

gnutls.certificate_allocate_credentials(

588

ctypes.byref(self._c_object))

589

self.type = gnutls.CRD_CERTIFICATE

590

591

def __del__(self):

592

gnutls.certificate_free_credentials(self._c_object)

593

594

class ClientSession(object):

595

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

596

self._c_object = gnutls.session_t()

597

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

598

gnutls.set_default_priority(self._c_object)

599

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

600

gnutls.handshake_set_private_extensions(self._c_object,

601

True)

602

self.socket = socket

603

if credentials is None:

604

credentials = gnutls.Credentials()

605

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

606

ctypes.cast(credentials._c_object,

607

ctypes.c_void_p))

608

self.credentials = credentials

609

610

def __del__(self):

611

gnutls.deinit(self._c_object)

612

613

def handshake(self):

614

return gnutls.handshake(self._c_object)

615

616

def send(self, data):

617

data = bytes(data)

618

data_len = len(data)

619

while data_len > 0:

620

data_len -= gnutls.record_send(self._c_object,

621

data[-data_len:],

622

data_len)

623

624

def bye(self):

625

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

626

627

# Error handling functions

628

def _error_code(result):

629

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

630

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

631

if result >= 0:

632

return result

633

if result == gnutls.E_NO_CERTIFICATE_FOUND:

634

raise gnutls.CertificateSecurityError(code=result)

635

raise gnutls.Error(code=result)

636

637

def _retry_on_error(result, func, arguments):

638

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

639

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

640

while result < 0:

641

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

642

return _error_code(result)

643

result = func(*arguments)

644

return result

645

646

# Unless otherwise indicated, the function declarations below are

647

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

648

649

# Functions

650

priority_set_direct = _library.gnutls_priority_set_direct

651

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

652

ctypes.POINTER(ctypes.c_char_p)]

653

priority_set_direct.restype = _error_code

654

655

init = _library.gnutls_init

656

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

657

init.restype = _error_code

658

659

set_default_priority = _library.gnutls_set_default_priority

660

set_default_priority.argtypes = [session_t]

661

set_default_priority.restype = _error_code

662

663

record_send = _library.gnutls_record_send

664

record_send.argtypes = [session_t, ctypes.c_void_p,

665

ctypes.c_size_t]

666

record_send.restype = ctypes.c_ssize_t

667

record_send.errcheck = _retry_on_error

668

669

certificate_allocate_credentials = (

670

_library.gnutls_certificate_allocate_credentials)

671

certificate_allocate_credentials.argtypes = [

672

ctypes.POINTER(certificate_credentials_t)]

673

certificate_allocate_credentials.restype = _error_code

674

675

certificate_free_credentials = (

676

_library.gnutls_certificate_free_credentials)

677

certificate_free_credentials.argtypes = [

678

certificate_credentials_t]

679

certificate_free_credentials.restype = None

680

681

handshake_set_private_extensions = (

682

_library.gnutls_handshake_set_private_extensions)

683

handshake_set_private_extensions.argtypes = [session_t,

684

ctypes.c_int]

685

handshake_set_private_extensions.restype = None

686

687

credentials_set = _library.gnutls_credentials_set

688

credentials_set.argtypes = [session_t, credentials_type_t,

689

ctypes.c_void_p]

690

credentials_set.restype = _error_code

691

692

strerror = _library.gnutls_strerror

693

strerror.argtypes = [ctypes.c_int]

694

strerror.restype = ctypes.c_char_p

695

696

certificate_type_get = _library.gnutls_certificate_type_get

697

certificate_type_get.argtypes = [session_t]

698

certificate_type_get.restype = _error_code

699

700

certificate_get_peers = _library.gnutls_certificate_get_peers

701

certificate_get_peers.argtypes = [session_t,

702

ctypes.POINTER(ctypes.c_uint)]

703

certificate_get_peers.restype = ctypes.POINTER(datum_t)

704

705

global_set_log_level = _library.gnutls_global_set_log_level

706

global_set_log_level.argtypes = [ctypes.c_int]

707

global_set_log_level.restype = None

708

709

global_set_log_function = _library.gnutls_global_set_log_function

710

global_set_log_function.argtypes = [log_func]

711

global_set_log_function.restype = None

712

713

deinit = _library.gnutls_deinit

714

deinit.argtypes = [session_t]

715

deinit.restype = None

716

717

handshake = _library.gnutls_handshake

718

handshake.argtypes = [session_t]

719

handshake.restype = _error_code

720

handshake.errcheck = _retry_on_error

721

722

transport_set_ptr = _library.gnutls_transport_set_ptr

723

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

724

transport_set_ptr.restype = None

725

726

bye = _library.gnutls_bye

727

bye.argtypes = [session_t, close_request_t]

728

bye.restype = _error_code

729

bye.errcheck = _retry_on_error

730

731

check_version = _library.gnutls_check_version

732

check_version.argtypes = [ctypes.c_char_p]

733

check_version.restype = ctypes.c_char_p

734

735

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

736

737

openpgp_crt_init = _library.gnutls_openpgp_crt_init

738

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

739

openpgp_crt_init.restype = _error_code

740

741

openpgp_crt_import = _library.gnutls_openpgp_crt_import

742

openpgp_crt_import.argtypes = [openpgp_crt_t,

743

ctypes.POINTER(datum_t),

744

openpgp_crt_fmt_t]

745

openpgp_crt_import.restype = _error_code

746

747

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

748

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

749

ctypes.POINTER(ctypes.c_uint)]

750

openpgp_crt_verify_self.restype = _error_code

751

752

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

753

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

754

openpgp_crt_deinit.restype = None

755

756

openpgp_crt_get_fingerprint = (

757

_library.gnutls_openpgp_crt_get_fingerprint)

758

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

759

ctypes.c_void_p,

760

ctypes.POINTER(

761

ctypes.c_size_t)]

762

openpgp_crt_get_fingerprint.restype = _error_code

763

764

# Remove non-public functions

765

del _error_code, _retry_on_error

766

# Create the global "gnutls" object, simulating a module

767

gnutls = GnuTLS()

768

769

770

def call_pipe(connection, # : multiprocessing.Connection

771

func, *args, **kwargs):

772

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

773

774

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

775

return value on the provided multiprocessing.Connection.

776

"""

777

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

778

connection.close()

779

780

382

def timedelta_to_milliseconds(td):

383

"Convert a datetime.timedelta() to milliseconds"

384

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

385

+ (td.seconds * 1000)

386

+ (td.microseconds // 1000))

387

781

388

class Client(object):

782

389

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

783

390

784

391

Attributes:

785

392

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

786

393

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

788

395

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

789

396

to see if the client lives.

790

397

'None' if no process is running.

791

checker_callback_tag: a GLib event source tag, or None

398

checker_callback_tag: a gobject event source tag, or None

792

399

checker_command: string; External command which is run to check

793

400

if client lives. %() expansions are done at

794

401

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

795

402

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

796

checker_initiator_tag: a GLib event source tag, or None

403

checker_initiator_tag: a gobject event source tag, or None

797

404

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

798

405

client_structure: Object describing what attributes a client has

799

406

and is used for storing the client at exit

800

407

current_checker_command: string; current running checker_command

801

disable_initiator_tag: a GLib event source tag, or None

408

disable_initiator_tag: a gobject event source tag, or None

802

409

enabled: bool()

803

410

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

804

411

uniquely identify the client

808

415

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

809

416

last_checker_status: integer between 0 and 255 reflecting exit

810

417

status of last checker. -1 reflects crashed

811

checker, -2 means no checker completed yet.

812

last_checker_signal: The signal which killed the last checker, if

813

last_checker_status is -1

418

checker, or None.

814

419

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

815

420

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

816

421

D-Bus identifiers

817

422

secret: bytestring; sent verbatim (over TLS) to client

818

423

timeout: datetime.timedelta(); How long from last_checked_ok

819

424

until this client is disabled

820

extended_timeout: extra long timeout when secret has been sent

425

extended_timeout: extra long timeout when password has been sent

821

426

runtime_expansions: Allowed attributes for runtime expansion.

822

427

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

823

428

disabled, or None

824

server_settings: The server_settings dict from main()

825

429

"""

826

430

827

431

runtime_expansions = ("approval_delay", "approval_duration",

828

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

829

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

830

"last_approval_request", "last_checked_ok",

432

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

433

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

831

434

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

832

client_defaults = {

833

"timeout": "PT5M",

834

"extended_timeout": "PT15M",

835

"interval": "PT2M",

836

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

837

"host": "",

838

"approval_delay": "PT0S",

839

"approval_duration": "PT1S",

840

"approved_by_default": "True",

841

"enabled": "True",

842

}

435

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

436

"extended_timeout": "15m",

437

"interval": "2m",

438

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

439

"host": "",

440

"approval_delay": "0s",

441

"approval_duration": "1s",

442

"approved_by_default": "True",

443

"enabled": "True",

444

}

445

446

def timeout_milliseconds(self):

447

"Return the 'timeout' attribute in milliseconds"

448

return timedelta_to_milliseconds(self.timeout)

449

450

def extended_timeout_milliseconds(self):

451

"Return the 'extended_timeout' attribute in milliseconds"

452

return timedelta_to_milliseconds(self.extended_timeout)

453

454

def interval_milliseconds(self):

455

"Return the 'interval' attribute in milliseconds"

456

return timedelta_to_milliseconds(self.interval)

457

458

def approval_delay_milliseconds(self):

459

return timedelta_to_milliseconds(self.approval_delay)

843

460

844

461

@staticmethod

845

462

def config_parser(config):

853

470

for client_name in config.sections():

854

471

section = dict(config.items(client_name))

855

472

client = settings[client_name] = {}

856

473

857

474

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

858

475

# Reformat values from string types to Python types

859

476

client["approved_by_default"] = config.getboolean(

860

477

client_name, "approved_by_default")

861

478

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

862

479

"enabled")

863

864

# Uppercase and remove spaces from fingerprint for later

865

# comparison purposes with return value from the

866

# fingerprint() function

480

867

481

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

868

482

.replace(" ", ""))

869

483

if "secret" in section:

870

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

871

.encode("utf-8"),

872

"base64")

484

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

873

485

elif "secfile" in section:

874

486

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

875

487

(section["secfile"])),

876

488

"rb") as secfile:

877

489

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

878

490

else:

879

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

880

.format(section))

491

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

492

% section)

881

493

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

882

494

client["extended_timeout"] = string_to_delta(

883

495

section["extended_timeout"])

889

501

client["checker_command"] = section["checker"]

890

502

client["last_approval_request"] = None

891

503

client["last_checked_ok"] = None

892

client["last_checker_status"] = -2

893

504

client["last_checker_status"] = None

505

894

506

return settings

895

896

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

507

508

509

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

510

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

511

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

512

attribute."""

897

513

self.name = name

898

if server_settings is None:

899

server_settings = {}

900

self.server_settings = server_settings

901

514

# adding all client settings

902

for setting, value in settings.items():

515

for setting, value in settings.iteritems():

903

516

setattr(self, setting, value)

904

517

905

518

if self.enabled:

906

519

if not hasattr(self, "last_enabled"):

907

520

self.last_enabled = datetime.datetime.utcnow()

911

524

else:

912

525

self.last_enabled = None

913

526

self.expires = None

914

527

915

528

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

529

# Uppercase and remove spaces from fingerprint for later

530

# comparison purposes with return value from the fingerprint()

531

# function

916

532

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

917

533

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

918

534

datetime.datetime.utcnow())

925

541

self.current_checker_command = None

926

542

self.approved = None

927

543

self.approvals_pending = 0

928

self.changedstate = multiprocessing_manager.Condition(

929

multiprocessing_manager.Lock())

930

self.client_structure = [attr

931

for attr in self.__dict__.keys()

544

self.changedstate = (multiprocessing_manager

545

.Condition(multiprocessing_manager

546

.Lock()))

547

self.client_structure = [attr for attr in

548

self.__dict__.iterkeys()

932

549

if not attr.startswith("_")]

933

550

self.client_structure.append("client_structure")

934

935

for name, t in inspect.getmembers(

936

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

551

552

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

553

lambda obj:

554

isinstance(obj,

555

property)):

937

556

if not name.startswith("_"):

938

557

self.client_structure.append(name)

939

558

940

559

# Send notice to process children that client state has changed

941

560

def send_changedstate(self):

942

561

with self.changedstate:

943

562

self.changedstate.notify_all()

944

563

945

564

def enable(self):

946

565

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

947

566

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

948

567

# Already enabled

949

568

return

569

self.send_changedstate()

950

570

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

951

571

self.enabled = True

952

572

self.last_enabled = datetime.datetime.utcnow()

953

573

self.init_checker()

954

self.send_changedstate()

955

574

956

575

def disable(self, quiet=True):

957

576

"""Disable this client."""

958

577

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

959

578

return False

960

579

if not quiet:

580

self.send_changedstate()

581

if not quiet:

961

582

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

962

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

963

GLib.source_remove(self.disable_initiator_tag)

583

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

584

gobject.source_remove(self.disable_initiator_tag)

964

585

self.disable_initiator_tag = None

965

586

self.expires = None

966

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

967

GLib.source_remove(self.checker_initiator_tag)

587

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

588

gobject.source_remove(self.checker_initiator_tag)

968

589

self.checker_initiator_tag = None

969

590

self.stop_checker()

970

591

self.enabled = False

971

if not quiet:

972

self.send_changedstate()

973

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

592

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

974

593

return False

975

594

976

595

def __del__(self):

977

596

self.disable()

978

597

979

598

def init_checker(self):

980

599

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

981

600

# and every interval from then on.

982

if self.checker_initiator_tag is not None:

983

GLib.source_remove(self.checker_initiator_tag)

984

self.checker_initiator_tag = GLib.timeout_add(

985

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

986

self.start_checker)

601

self.checker_initiator_tag = (gobject.timeout_add

602

(self.interval_milliseconds(),

603

self.start_checker))

987

604

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

988

if self.disable_initiator_tag is not None:

989

GLib.source_remove(self.disable_initiator_tag)

990

self.disable_initiator_tag = GLib.timeout_add(

991

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

605

self.disable_initiator_tag = (gobject.timeout_add

606

(self.timeout_milliseconds(),

607

self.disable))

992

608

# Also start a new checker *right now*.

993

609

self.start_checker()

994

995

def checker_callback(self, source, condition, connection,

996

command):

610

611

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

997

612

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

998

613

self.checker_callback_tag = None

999

614

self.checker = None

1000

# Read return code from connection (see call_pipe)

1001

returncode = connection.recv()

1002

connection.close()

1003

1004

if returncode >= 0:

1005

self.last_checker_status = returncode

1006

self.last_checker_signal = None

615

if os.WIFEXITED(condition):

616

self.last_checker_status = os.WEXITSTATUS(condition)

1007

617

if self.last_checker_status == 0:

1008

618

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

1009

619

vars(self))

1010

620

self.checked_ok()

1011

621

else:

1012

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

622

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

623

vars(self))

1013

624

else:

1014

625

self.last_checker_status = -1

1015

self.last_checker_signal = -returncode

1016

626

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

1017

627

vars(self))

1018

return False

1019

1020

def checked_ok(self):

1021

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

1022

self.last_checked_ok = datetime.datetime.utcnow()

1023

self.last_checker_status = 0

1024

self.last_checker_signal = None

1025

self.bump_timeout()

1026

1027

def bump_timeout(self, timeout=None):

1028

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

628

629

def checked_ok(self, timeout=None):

630

"""Bump up the timeout for this client.

631

632

This should only be called when the client has been seen,

633

alive and well.

634

"""

1029

635

if timeout is None:

1030

636

timeout = self.timeout

637

self.last_checked_ok = datetime.datetime.utcnow()

1031

638

if self.disable_initiator_tag is not None:

1032

GLib.source_remove(self.disable_initiator_tag)

1033

self.disable_initiator_tag = None

639

gobject.source_remove(self.disable_initiator_tag)

1034

640

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

1035

self.disable_initiator_tag = GLib.timeout_add(

1036

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

641

self.disable_initiator_tag = (gobject.timeout_add

642

(timedelta_to_milliseconds

643

(timeout), self.disable))

1037

644

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

1038

645

1039

646

def need_approval(self):

1040

647

self.last_approval_request = datetime.datetime.utcnow()

1041

648

1042

649

def start_checker(self):

1043

650

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

1044

651

1045

652

If a checker already exists, leave it running and do

1046

653

nothing."""

1047

654

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

1048

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

1049

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

1050

# would inevitably timeout, since no checker would get a

1051

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

655

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

656

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

657

# client would inevitably timeout, since no checker would get

658

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

1052

659

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

1053

660

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

1054

661

# should be.

1055

1056

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

1057

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

1058

self.checker.join()

1059

self.checker = None

662

663

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

664

try:

665

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

666

except (AttributeError, OSError) as error:

667

if (isinstance(error, OSError)

668

and error.errno != errno.ECHILD):

669

raise error

670

else:

671

if pid:

672

logger.warning("Checker was a zombie")

673

gobject.source_remove(self.checker_callback_tag)

674

self.checker_callback(pid, status,

675

self.current_checker_command)

1060

676

# Start a new checker if needed

1061

677

if self.checker is None:

1062

# Escape attributes for the shell

1063

escaped_attrs = {

1064

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

1065

for attr in self.runtime_expansions}

1066

678

try:

1067

command = self.checker_command % escaped_attrs

1068

except TypeError as error:

1069

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

1070

self.checker_command,

1071

exc_info=error)

1072

return True # Try again later

679

# In case checker_command has exactly one % operator

680

command = self.checker_command % self.host

681

except TypeError:

682

# Escape attributes for the shell

683

escaped_attrs = dict(

684

(attr,

685

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

686

errors=

687

'replace')))

688

for attr in

689

self.runtime_expansions)

690

691

try:

692

command = self.checker_command % escaped_attrs

693

except TypeError as error:

694

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

695

' %s', self.checker_command, error)

696

return True # Try again later

1073

697

self.current_checker_command = command

1074

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

1075

self.name)

1076

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

1077

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

1078

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

1079

# always replaced by /dev/null.)

1080

# The exception is when not debugging but nevertheless

1081

# running in the foreground; use the previously

1082

# created wnull.

1083

popen_args = {"close_fds": True,

1084

"shell": True,

1085

"cwd": "/"}

1086

if (not self.server_settings["debug"]

1087

and self.server_settings["foreground"]):

1088

popen_args.update({"stdout": wnull,

1089

"stderr": wnull})

1090

pipe = multiprocessing.Pipe(duplex=False)

1091

self.checker = multiprocessing.Process(

1092

target=call_pipe,

1093

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

1094

kwargs=popen_args)

1095

self.checker.start()

1096

self.checker_callback_tag = GLib.io_add_watch(

1097

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

1098

self.checker_callback, pipe[0], command)

1099

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

698

try:

699

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

700

command, self.name)

701

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

702

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

703

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

704

# always replaced by /dev/null.)

705

self.checker = subprocess.Popen(command,

706

close_fds=True,

707

shell=True, cwd="/")

708

self.checker_callback_tag = (gobject.child_watch_add

709

(self.checker.pid,

710

self.checker_callback,

711

data=command))

712

# The checker may have completed before the gobject

713

# watch was added. Check for this.

714

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

715

if pid:

716

gobject.source_remove(self.checker_callback_tag)

717

self.checker_callback(pid, status, command)

718

except OSError as error:

719

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

720

error)

721

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

1100

722

return True

1101

723

1102

724

def stop_checker(self):

1103

725

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

1104

726

if self.checker_callback_tag:

1105

GLib.source_remove(self.checker_callback_tag)

727

gobject.source_remove(self.checker_callback_tag)

1106

728

self.checker_callback_tag = None

1107

729

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

1108

730

return

1109

731

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

1110

self.checker.terminate()

732

try:

733

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

734

#time.sleep(0.5)

735

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

736

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

737

except OSError as error:

738

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

739

raise

1111

740

self.checker = None

1112

741

1113

742

1114

def dbus_service_property(dbus_interface,

1115

signature="v",

1116

access="readwrite",

1117

byte_arrays=False):

743

def dbus_service_property(dbus_interface, signature="v",

744

access="readwrite", byte_arrays=False):

1118

745

"""Decorators for marking methods of a DBusObjectWithProperties to

1119

746

become properties on the D-Bus.

1120

747

1121

748

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

1122

749

and with one argument by "Set".

1123

750

1124

751

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

1125

752

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

1126

753

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

1129

756

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

1130

757

if byte_arrays and signature != "ay":

1131

758

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

1132

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

1133

759

" signature %r" % signature)

1134

760

def decorator(func):

1135

761

func._dbus_is_property = True

1136

762

func._dbus_interface = dbus_interface

1139

765

func._dbus_name = func.__name__

1140

766

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

1141

767

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

1142

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

1143

return func

1144

1145

return decorator

1146

1147

1148

def dbus_interface_annotations(dbus_interface):

1149

"""Decorator for marking functions returning interface annotations

1150

1151

Usage:

1152

1153

@dbus_interface_annotations("org.example.Interface")

1154

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

1155

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

1156

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

1157

"false"}

1158

"""

1159

1160

def decorator(func):

1161

func._dbus_is_interface = True

1162

func._dbus_interface = dbus_interface

1163

func._dbus_name = dbus_interface

1164

return func

1165

1166

return decorator

1167

1168

1169

def dbus_annotations(annotations):

1170

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

1171

Usage:

1172

1173

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

1174

"org.freedesktop.DBus.Property."

1175

"EmitsChangedSignal": "false"})

1176

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

1177

access="r")

1178

def Property_dbus_property(self):

1179

return dbus.Boolean(False)

1180

1181

See also the DBusObjectWithAnnotations class.

1182

"""

1183

1184

def decorator(func):

1185

func._dbus_annotations = annotations

1186

return func

1187

768

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

769

return func

1188

770

return decorator

1189

771

1190

772

1191

773

class DBusPropertyException(dbus.exceptions.DBusException):

1192

774

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

1193

775

"""

1194

pass

776

def __unicode__(self):

777

return unicode(str(self))

1195

778

1196

779

1197

780

class DBusPropertyAccessException(DBusPropertyException):

1206

789

pass

1207

790

1208

791

1209

class DBusObjectWithAnnotations(dbus.service.Object):

1210

"""A D-Bus object with annotations.

1211

1212

Classes inheriting from this can use the dbus_annotations

1213

decorator to add annotations to methods or signals.

1214

"""

1215

1216

@staticmethod

1217

def _is_dbus_thing(thing):

1218

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

1219

1220

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

1221

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

1222

"""

1223

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

1224

False)

1225

1226

def _get_all_dbus_things(self, thing):

1227

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

1228

"""

1229

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

1230

athing.__get__(self))

1231

for cls in self.__class__.__mro__

1232

for name, athing in

1233

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

1234

1235

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1236

out_signature="s",

1237

path_keyword='object_path',

1238

connection_keyword='connection')

1239

def Introspect(self, object_path, connection):

1240

"""Overloading of standard D-Bus method.

1241

1242

Inserts annotation tags on methods and signals.

1243

"""

1244

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

1245

connection)

1246

try:

1247

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

1248

1249

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

1250

# Add annotation tags

1251

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

1252

for tag in if_tag.getElementsByTagName(typ):

1253

annots = dict()

1254

for name, prop in (self.

1255

_get_all_dbus_things(typ)):

1256

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

1257

and prop._dbus_interface

1258

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

1259

annots.update(getattr(

1260

prop, "_dbus_annotations", {}))

1261

for name, value in annots.items():

1262

ann_tag = document.createElement(

1263

"annotation")

1264

ann_tag.setAttribute("name", name)

1265

ann_tag.setAttribute("value", value)

1266

tag.appendChild(ann_tag)

1267

# Add interface annotation tags

1268

for annotation, value in dict(

1269

itertools.chain.from_iterable(

1270

annotations().items()

1271

for name, annotations

1272

in self._get_all_dbus_things("interface")

1273

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

1274

)).items():

1275

ann_tag = document.createElement("annotation")

1276

ann_tag.setAttribute("name", annotation)

1277

ann_tag.setAttribute("value", value)

1278

if_tag.appendChild(ann_tag)

1279

# Fix argument name for the Introspect method itself

1280

if (if_tag.getAttribute("name")

1281

== dbus.INTROSPECTABLE_IFACE):

1282

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

1283

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

1284

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

1285

if (arg.getAttribute("direction")

1286

== "out"):

1287

arg.setAttribute("name",

1288

"xml_data")

1289

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

1290

document.unlink()

1291

except (AttributeError, xml.dom.DOMException,

1292

xml.parsers.expat.ExpatError) as error:

1293

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

1294

exc_info=error)

1295

return xmlstring

1296

1297

1298

class DBusObjectWithProperties(DBusObjectWithAnnotations):

792

class DBusObjectWithProperties(dbus.service.Object):

1299

793

"""A D-Bus object with properties.

1300

794

1301

795

Classes inheriting from this can use the dbus_service_property

1302

796

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

1303

797

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

1304

798

"""

1305

799

800

@staticmethod

801

def _is_dbus_property(obj):

802

return getattr(obj, "_dbus_is_property", False)

803

804

def _get_all_dbus_properties(self):

805

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

806

"""

807

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

808

for cls in self.__class__.__mro__

809

for name, prop in

810

inspect.getmembers(cls, self._is_dbus_property))

811

1306

812

def _get_dbus_property(self, interface_name, property_name):

1307

813

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

1308

814

property with the specified name and interface.

1309

815

"""

1310

for cls in self.__class__.__mro__:

1311

for name, value in inspect.getmembers(

1312

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

816

for cls in self.__class__.__mro__:

817

for name, value in (inspect.getmembers

818

(cls, self._is_dbus_property)):

1313

819

if (value._dbus_name == property_name

1314

820

and value._dbus_interface == interface_name):

1315

821

return value.__get__(self)

1316

822

1317

823

# No such property

1318

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

1319

self.dbus_object_path, interface_name, property_name))

1320

1321

@classmethod

1322

def _get_all_interface_names(cls):

1323

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

1324

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

1325

"_dbus_interface", None)

1326

for x in (inspect.getmro(cls))

1327

for attr in dir(x))

1328

if name is not None)

1329

1330

@dbus.service.method(dbus.PROPERTIES_IFACE,

1331

in_signature="ss",

824

raise DBusPropertyNotFound(self.dbus_object_path + ":"

825

+ interface_name + "."

826

+ property_name)

827

828

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

1332

829

out_signature="v")

1333

830

def Get(self, interface_name, property_name):

1334

831

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

1340

837

if not hasattr(value, "variant_level"):

1341

838

return value

1342

839

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

1343

840

1344

841

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

1345

842

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

1346

843

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

1352

849

# The byte_arrays option is not supported yet on

1353

850

# signatures other than "ay".

1354

851

if prop._dbus_signature != "ay":

1355

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

1356

"'ay' signature {!r}"

1357

.format(prop._dbus_signature))

852

raise ValueError

1358

853

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

1359

854

for byte in value))

1360

855

prop(value)

1361

1362

@dbus.service.method(dbus.PROPERTIES_IFACE,

1363

in_signature="s",

856

857

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

1364

858

out_signature="a{sv}")

1365

859

def GetAll(self, interface_name):

1366

860

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

1367

861

standard.

1368

862

1369

863

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

1370

864

"""

1371

865

properties = {}

1372

for name, prop in self._get_all_dbus_things("property"):

866

for name, prop in self._get_all_dbus_properties():

1373

867

if (interface_name

1374

868

and interface_name != prop._dbus_interface):

1375

869

# Interface non-empty but did not match

1381

875

if not hasattr(value, "variant_level"):

1382

876

properties[name] = value

1383

877

continue

1384

properties[name] = type(value)(

1385

value, variant_level=value.variant_level + 1)

878

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

879

value.variant_level+1)

1386

880

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

1387

1388

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

1389

def PropertiesChanged(self, interface_name, changed_properties,

1390

invalidated_properties):

1391

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

1392

standard.

1393

"""

1394

pass

1395

881

1396

882

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1397

883

out_signature="s",

1398

884

path_keyword='object_path',

1399

885

connection_keyword='connection')

1400

886

def Introspect(self, object_path, connection):

1401

"""Overloading of standard D-Bus method.

1402

1403

Inserts property tags and interface annotation tags.

887

"""Standard D-Bus method, overloaded to insert property tags.

1404

888

"""

1405

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1406

object_path,

1407

connection)

889

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

890

connection)

1408

891

try:

1409

892

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

1410

1411

893

def make_tag(document, name, prop):

1412

894

e = document.createElement("property")

1413

895

e.setAttribute("name", name)

1414

896

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

1415

897

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

1416

898

return e

1417

1418

899

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

1419

# Add property tags

1420

900

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

1421

901

for name, prop

1422

in self._get_all_dbus_things("property")

902

in self._get_all_dbus_properties()

1423

903

if prop._dbus_interface

1424

904

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

1425

905

if_tag.appendChild(tag)

1426

# Add annotation tags for properties

1427

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

1428

annots = dict()

1429

for name, prop in self._get_all_dbus_things(

1430

"property"):

1431

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

1432

and prop._dbus_interface

1433

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

1434

annots.update(getattr(

1435

prop, "_dbus_annotations", {}))

1436

for name, value in annots.items():

1437

ann_tag = document.createElement(

1438

"annotation")

1439

ann_tag.setAttribute("name", name)

1440

ann_tag.setAttribute("value", value)

1441

tag.appendChild(ann_tag)

1442

906

# Add the names to the return values for the

1443

907

# "org.freedesktop.DBus.Properties" methods

1444

908

if (if_tag.getAttribute("name")

1459

923

except (AttributeError, xml.dom.DOMException,

1460

924

xml.parsers.expat.ExpatError) as error:

1461

925

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

1462

exc_info=error)

1463

return xmlstring

1464

1465

1466

try:

1467

dbus.OBJECT_MANAGER_IFACE

1468

except AttributeError:

1469

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

1470

1471

1472

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1473

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

1474

1475

Classes inheriting from this exposes the standard

1476

GetManagedObjects call and the InterfacesAdded and

1477

InterfacesRemoved signals on the standard

1478

"org.freedesktop.DBus.ObjectManager" interface.

1479

1480

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

1481

manually.

1482

"""

1483

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1484

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

1485

def GetManagedObjects(self):

1486

"""This function must be overridden"""

1487

raise NotImplementedError()

1488

1489

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1490

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

1491

def InterfacesAdded(self, object_path, interfaces_and_properties):

1492

pass

1493

1494

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

1495

def InterfacesRemoved(self, object_path, interfaces):

1496

pass

1497

1498

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1499

out_signature="s",

1500

path_keyword='object_path',

1501

connection_keyword='connection')

1502

def Introspect(self, object_path, connection):

1503

"""Overloading of standard D-Bus method.

1504

1505

Override return argument name of GetManagedObjects to be

1506

"objpath_interfaces_and_properties"

1507

"""

1508

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1509

object_path,

1510

connection)

1511

try:

1512

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

1513

1514

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

1515

# Fix argument name for the GetManagedObjects method

1516

if (if_tag.getAttribute("name")

1517

== dbus.OBJECT_MANAGER_IFACE):

1518

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

1519

if (cn.getAttribute("name")

1520

== "GetManagedObjects"):

1521

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

1522

if (arg.getAttribute("direction")

1523

== "out"):

1524

arg.setAttribute(

1525

"name",

1526

"objpath_interfaces"

1527

"_and_properties")

1528

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

1529

document.unlink()

1530

except (AttributeError, xml.dom.DOMException,

1531

xml.parsers.expat.ExpatError) as error:

1532

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

1533

exc_info=error)

1534

return xmlstring

1535

1536

1537

def datetime_to_dbus(dt, variant_level=0):

926

error)

927

return xmlstring

928

929

930

def datetime_to_dbus (dt, variant_level=0):

1538

931

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

1539

932

if dt is None:

1540

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

1541

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

1542

1543

1544

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1545

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

1546

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

1547

interface names according to the "alt_interface_names" mapping.

1548

Usage:

1549

1550

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

1551

"net.example.AlternateInterface"})

1552

class SampleDBusObject(dbus.service.Object):

1553

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

1554

def SampleDBusMethod():

1555

pass

1556

1557

The above "SampleDBusMethod" on "SampleDBusObject" will be

1558

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

1559

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

1560

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

1561

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

1562

1563

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

1564

(from DBusObjectWithProperties) and interfaces (from the

1565

dbus_interface_annotations decorator).

933

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

934

return dbus.String(dt.isoformat(),

935

variant_level=variant_level)

936

937

938

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

939

.__metaclass__):

940

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

941

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

1566

942

"""

1567

1568

def wrapper(cls):

1569

for orig_interface_name, alt_interface_name in (

1570

alt_interface_names.items()):

1571

attr = {}

1572

interface_names = set()

1573

# Go though all attributes of the class

1574

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

943

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

944

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

945

# methods, signals, or properties in them

946

for base in (b for b in bases

947

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

948

# Go though all attributes of the base class

949

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

1575

950

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

1576

951

# with the wrong interface name

1577

952

if (not hasattr(attribute, "_dbus_interface")

1578

or not attribute._dbus_interface.startswith(

1579

orig_interface_name)):

953

or not attribute._dbus_interface

954

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

1580

955

continue

1581

956

# Create an alternate D-Bus interface name based on

1582

957

# the current name

1583

alt_interface = attribute._dbus_interface.replace(

1584

orig_interface_name, alt_interface_name)

1585

interface_names.add(alt_interface)

958

alt_interface = (attribute._dbus_interface

959

.replace("se.recompile.Mandos",

960

"se.bsnet.fukt.Mandos"))

1586

961

# Is this a D-Bus signal?

1587

962

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

1588

# Extract the original non-method undecorated

1589

# function by black magic

1590

if sys.version_info.major == 2:

1591

nonmethod_func = (dict(

963

# Extract the original non-method function by

964

# black magic

965

nonmethod_func = (dict(

1592

966

zip(attribute.func_code.co_freevars,

1593

attribute.__closure__))

1594

["func"].cell_contents)

1595

else:

1596

nonmethod_func = (dict(

1597

zip(attribute.__code__.co_freevars,

1598

attribute.__closure__))

1599

["func"].cell_contents)

967

attribute.__closure__))["func"]

968

.cell_contents)

1600

969

# Create a new, but exactly alike, function

1601

970

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

1602

971

# with the alternate D-Bus interface name

1603

new_function = copy_function(nonmethod_func)

1604

new_function = (dbus.service.signal(

1605

alt_interface,

1606

attribute._dbus_signature)(new_function))

1607

# Copy annotations, if any

1608

try:

1609

new_function._dbus_annotations = dict(

1610

attribute._dbus_annotations)

1611

except AttributeError:

1612

pass

1613

972

new_function = (dbus.service.signal

973

(alt_interface,

974

attribute._dbus_signature)

975

(types.FunctionType(

976

nonmethod_func.func_code,

977

nonmethod_func.func_globals,

978

nonmethod_func.func_name,

979

nonmethod_func.func_defaults,

980

nonmethod_func.func_closure)))

1614

981

# Define a creator of a function to call both the

1615

# original and alternate functions, so both the

1616

# original and alternate signals gets sent when

1617

# the function is called

982

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

983

# signals gets sent when the function is called

1618

984

def fixscope(func1, func2):

1619

985

"""This function is a scope container to pass

1620

986

func1 and func2 to the "call_both" function

1621

987

outside of its arguments"""

1622

1623

@functools.wraps(func2)

1624

988

def call_both(*args, **kwargs):

1625

989

"""This function will emit two D-Bus

1626

990

signals by calling func1 and func2"""

1627

991

func1(*args, **kwargs)

1628

992

func2(*args, **kwargs)

1629

# Make wrapper function look like a D-Bus

1630

# signal

1631

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

1632

if name.startswith("_dbus_"):

1633

setattr(call_both, name, attr)

1634

1635

993

return call_both

1636

994

# Create the "call_both" function and add it to

1637

995

# the class

1638

attr[attrname] = fixscope(attribute, new_function)

996

attr[attrname] = fixscope(attribute,

997

new_function)

1639

998

# Is this a D-Bus method?

1640

999

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

1641

1000

# Create a new, but exactly alike, function

1642

1001

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

1643

1002

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

1644

1003

# to the class.

1645

attr[attrname] = (

1646

dbus.service.method(

1647

alt_interface,

1648

attribute._dbus_in_signature,

1649

attribute._dbus_out_signature)

1650

(copy_function(attribute)))

1651

# Copy annotations, if any

1652

try:

1653

attr[attrname]._dbus_annotations = dict(

1654

attribute._dbus_annotations)

1655

except AttributeError:

1656

pass

1004

attr[attrname] = (dbus.service.method

1005

(alt_interface,

1006

attribute._dbus_in_signature,

1007

attribute._dbus_out_signature)

1008

(types.FunctionType

1009

(attribute.func_code,

1010

attribute.func_globals,

1011

attribute.func_name,

1012

attribute.func_defaults,

1013

attribute.func_closure)))

1657

1014

# Is this a D-Bus property?

1658

1015

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

1659

1016

# Create a new, but exactly alike, function

1660

1017

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

1661

1018

# property with the alternate D-Bus interface

1662

1019

# name. Add it to the class.

1663

attr[attrname] = (dbus_service_property(

1664

alt_interface, attribute._dbus_signature,

1665

attribute._dbus_access,

1666

attribute._dbus_get_args_options

1667

["byte_arrays"])

1668

(copy_function(attribute)))

1669

# Copy annotations, if any

1670

try:

1671

attr[attrname]._dbus_annotations = dict(

1672

attribute._dbus_annotations)

1673

except AttributeError:

1674

pass

1675

# Is this a D-Bus interface?

1676

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

1677

# Create a new, but exactly alike, function

1678

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

1679

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

1680

# to the class.

1681

attr[attrname] = (

1682

dbus_interface_annotations(alt_interface)

1683

(copy_function(attribute)))

1684

if deprecate:

1685

# Deprecate all alternate interfaces

1686

iname = "_AlternateDBusNames_interface_annotation{}"

1687

for interface_name in interface_names:

1688

1689

@dbus_interface_annotations(interface_name)

1690

def func(self):

1691

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

1692

"true"}

1693

# Find an unused name

1694

for aname in (iname.format(i)

1695

for i in itertools.count()):

1696

if aname not in attr:

1697

attr[aname] = func

1698

break

1699

if interface_names:

1700

# Replace the class with a new subclass of it with

1701

# methods, signals, etc. as created above.

1702

if sys.version_info.major == 2:

1703

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

1704

(cls, ), attr)

1705

else:

1706

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

1707

(cls, ), attr)

1708

return cls

1709

1710

return wrapper

1711

1712

1713

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

1714

"se.bsnet.fukt.Mandos"})

1020

attr[attrname] = (dbus_service_property

1021

(alt_interface,

1022

attribute._dbus_signature,

1023

attribute._dbus_access,

1024

attribute

1025

._dbus_get_args_options

1026

["byte_arrays"])

1027

(types.FunctionType

1028

(attribute.func_code,

1029

attribute.func_globals,

1030

attribute.func_name,

1031

attribute.func_defaults,

1032

attribute.func_closure)))

1033

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

1034

1035

1715

1036

class ClientDBus(Client, DBusObjectWithProperties):

1716

1037

"""A Client class using D-Bus

1717

1038

1718

1039

Attributes:

1719

1040

dbus_object_path: dbus.ObjectPath

1720

1041

bus: dbus.SystemBus()

1721

1042

"""

1722

1043

1723

1044

runtime_expansions = (Client.runtime_expansions

1724

+ ("dbus_object_path", ))

1725

1726

_interface = "se.recompile.Mandos.Client"

1727

1045

+ ("dbus_object_path",))

1046

1728

1047

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

1729

1730

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

1048

1049

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

1731

1050

self.bus = bus

1732

1051

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

1052

self._approvals_pending = 0

1053

1054

self._approvals_pending = 0

1733

1055

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

1734

1056

# the D-Bus

1735

client_object_name = str(self.name).translate(

1057

client_object_name = unicode(self.name).translate(

1736

1058

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

1737

1059

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

1738

self.dbus_object_path = dbus.ObjectPath(

1739

"/clients/" + client_object_name)

1060

self.dbus_object_path = (dbus.ObjectPath

1061

("/clients/" + client_object_name))

1740

1062

DBusObjectWithProperties.__init__(self, self.bus,

1741

1063

self.dbus_object_path)

1742

1743

def notifychangeproperty(transform_func, dbus_name,

1744

type_func=lambda x: x,

1745

variant_level=1,

1746

invalidate_only=False,

1747

_interface=_interface):

1064

1065

def notifychangeproperty(transform_func,

1066

dbus_name, type_func=lambda x: x,

1067

variant_level=1):

1748

1068

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

1749

1069

its changes to DBus.

1750

1070

1751

1071

transform_fun: Function that takes a value and a variant_level

1752

1072

and transforms it to a D-Bus type.

1753

1073

dbus_name: D-Bus name of the variable

1755

1075

to the D-Bus. Default: no transform

1756

1076

variant_level: D-Bus variant level. Default: 1

1757

1077

"""

1758

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

1759

1078

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

1760

1079

def setter(self, value):

1761

1080

if hasattr(self, "dbus_object_path"):

1762

1081

if (not hasattr(self, attrname) or

1763

1082

type_func(getattr(self, attrname, None))

1764

1083

!= type_func(value)):

1765

if invalidate_only:

1766

self.PropertiesChanged(

1767

_interface, dbus.Dictionary(),

1768

dbus.Array((dbus_name, )))

1769

else:

1770

dbus_value = transform_func(

1771

type_func(value),

1772

variant_level=variant_level)

1773

self.PropertyChanged(dbus.String(dbus_name),

1774

dbus_value)

1775

self.PropertiesChanged(

1776

_interface,

1777

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

1778

dbus_value}),

1779

dbus.Array())

1084

dbus_value = transform_func(type_func(value),

1085

variant_level

1086

=variant_level)

1087

self.PropertyChanged(dbus.String(dbus_name),

1088

dbus_value)

1780

1089

setattr(self, attrname, value)

1781

1090

1782

1091

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

1783

1092

1093

1784

1094

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1785

1095

approvals_pending = notifychangeproperty(dbus.Boolean,

1786

1096

"ApprovalPending",

1787

type_func=bool)

1097

type_func = bool)

1788

1098

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

1789

1099

last_enabled = notifychangeproperty(datetime_to_dbus,

1790

1100

"LastEnabled")

1791

checker = notifychangeproperty(

1792

dbus.Boolean, "CheckerRunning",

1793

type_func=lambda checker: checker is not None)

1101

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

1102

type_func = lambda checker:

1103

checker is not None)

1794

1104

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1795

1105

"LastCheckedOK")

1796

last_checker_status = notifychangeproperty(dbus.Int16,

1797

"LastCheckerStatus")

1798

1106

last_approval_request = notifychangeproperty(

1799

1107

datetime_to_dbus, "LastApprovalRequest")

1800

1108

approved_by_default = notifychangeproperty(dbus.Boolean,

1801

1109

"ApprovedByDefault")

1802

approval_delay = notifychangeproperty(

1803

dbus.UInt64, "ApprovalDelay",

1804

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

1110

approval_delay = notifychangeproperty(dbus.UInt64,

1111

"ApprovalDelay",

1112

type_func =

1113

timedelta_to_milliseconds)

1805

1114

approval_duration = notifychangeproperty(

1806

1115

dbus.UInt64, "ApprovalDuration",

1807

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

1116

type_func = timedelta_to_milliseconds)

1808

1117

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

1809

timeout = notifychangeproperty(

1810

dbus.UInt64, "Timeout",

1811

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

1118

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

1119

type_func =

1120

timedelta_to_milliseconds)

1812

1121

extended_timeout = notifychangeproperty(

1813

1122

dbus.UInt64, "ExtendedTimeout",

1814

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

1815

interval = notifychangeproperty(

1816

dbus.UInt64, "Interval",

1817

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

1123

type_func = timedelta_to_milliseconds)

1124

interval = notifychangeproperty(dbus.UInt64,

1125

"Interval",

1126

type_func =

1127

timedelta_to_milliseconds)

1818

1128

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

1819

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

1820

invalidate_only=True)

1821

1129

1822

1130

del notifychangeproperty

1823

1131

1824

1132

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

1825

1133

try:

1826

1134

self.remove_from_connection()

1829

1137

if hasattr(DBusObjectWithProperties, "__del__"):

1830

1138

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

1831

1139

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

1832

1833

def checker_callback(self, source, condition,

1834

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

1835

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

1836

connection, command, *args,

1837

**kwargs)

1838

exitstatus = self.last_checker_status

1839

if exitstatus >= 0:

1140

1141

def checker_callback(self, pid, condition, command,

1142

*args, **kwargs):

1143

self.checker_callback_tag = None

1144

self.checker = None

1145

if os.WIFEXITED(condition):

1146

exitstatus = os.WEXITSTATUS(condition)

1840

1147

# Emit D-Bus signal

1841

1148

self.CheckerCompleted(dbus.Int16(exitstatus),

1842

# This is specific to GNU libC

1843

dbus.Int64(exitstatus << 8),

1149

dbus.Int64(condition),

1844

1150

dbus.String(command))

1845

1151

else:

1846

1152

# Emit D-Bus signal

1847

1153

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

1848

dbus.Int64(

1849

# This is specific to GNU libC

1850

(exitstatus << 8)

1851

| self.last_checker_signal),

1154

dbus.Int64(condition),

1852

1155

dbus.String(command))

1853

return ret

1854

1156

1157

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

1158

*args, **kwargs)

1159

1855

1160

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

1856

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

1161

old_checker = self.checker

1162

if self.checker is not None:

1163

old_checker_pid = self.checker.pid

1164

else:

1165

old_checker_pid = None

1857

1166

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

1858

1167

# Only if new checker process was started

1859

1168

if (self.checker is not None

1861

1170

# Emit D-Bus signal

1862

1171

self.CheckerStarted(self.current_checker_command)

1863

1172

return r

1864

1173

1865

1174

def _reset_approved(self):

1866

1175

self.approved = None

1867

1176

return False

1868

1177

1869

1178

def approve(self, value=True):

1179

self.send_changedstate()

1870

1180

self.approved = value

1871

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

1872

* 1000), self._reset_approved)

1873

self.send_changedstate()

1874

1875

# D-Bus methods, signals & properties

1876

1877

# Interfaces

1878

1879

# Signals

1880

1181

gobject.timeout_add(timedelta_to_milliseconds

1182

(self.approval_duration),

1183

self._reset_approved)

1184

1185

1186

## D-Bus methods, signals & properties

1187

_interface = "se.recompile.Mandos.Client"

1188

1189

## Signals

1190

1881

1191

# CheckerCompleted - signal

1882

1192

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

1883

1193

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

1884

1194

"D-Bus signal"

1885

1195

pass

1886

1196

1887

1197

# CheckerStarted - signal

1888

1198

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

1889

1199

def CheckerStarted(self, command):

1890

1200

"D-Bus signal"

1891

1201

pass

1892

1202

1893

1203

# PropertyChanged - signal

1894

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

1895

1204

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

1896

1205

def PropertyChanged(self, property, value):

1897

1206

"D-Bus signal"

1898

1207

pass

1899

1208

1900

1209

# GotSecret - signal

1901

1210

@dbus.service.signal(_interface)

1902

1211

def GotSecret(self):

1905

1214

server to mandos-client

1906

1215

"""

1907

1216

pass

1908

1217

1909

1218

# Rejected - signal

1910

1219

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

1911

1220

def Rejected(self, reason):

1912

1221

"D-Bus signal"

1913

1222

pass

1914

1223

1915

1224

# NeedApproval - signal

1916

1225

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

1917

1226

def NeedApproval(self, timeout, default):

1918

1227

"D-Bus signal"

1919

1228

return self.need_approval()

1920

1921

# Methods

1922

1229

1230

# NeRwequest - signal

1231

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

1232

def NewRequest(self, ip):

1233

"""D-Bus signal

1234

Is sent after a client request a password.

1235

"""

1236

pass

1237

1238

## Methods

1239

1923

1240

# Approve - method

1924

1241

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

1925

1242

def Approve(self, value):

1926

1243

self.approve(value)

1927

1244

1928

1245

# CheckedOK - method

1929

1246

@dbus.service.method(_interface)

1930

1247

def CheckedOK(self):

1931

1248

self.checked_ok()

1932

1249

1933

1250

# Enable - method

1934

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

1935

1251

@dbus.service.method(_interface)

1936

1252

def Enable(self):

1937

1253

"D-Bus method"

1938

1254

self.enable()

1939

1255

1940

1256

# StartChecker - method

1941

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

1942

1257

@dbus.service.method(_interface)

1943

1258

def StartChecker(self):

1944

1259

"D-Bus method"

1945

1260

self.start_checker()

1946

1261

1947

1262

# Disable - method

1948

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

1949

1263

@dbus.service.method(_interface)

1950

1264

def Disable(self):

1951

1265

"D-Bus method"

1952

1266

self.disable()

1953

1267

1954

1268

# StopChecker - method

1955

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

1956

1269

@dbus.service.method(_interface)

1957

1270

def StopChecker(self):

1958

1271

self.stop_checker()

1959

1960

# Properties

1961

1272

1273

## Properties

1274

1962

1275

# ApprovalPending - property

1963

1276

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

1964

1277

def ApprovalPending_dbus_property(self):

1965

1278

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

1966

1279

1967

1280

# ApprovedByDefault - property

1968

@dbus_service_property(_interface,

1969

signature="b",

1281

@dbus_service_property(_interface, signature="b",

1970

1282

access="readwrite")

1971

1283

def ApprovedByDefault_dbus_property(self, value=None):

1972

1284

if value is None: # get

1973

1285

return dbus.Boolean(self.approved_by_default)

1974

1286

self.approved_by_default = bool(value)

1975

1287

1976

1288

# ApprovalDelay - property

1977

@dbus_service_property(_interface,

1978

signature="t",

1289

@dbus_service_property(_interface, signature="t",

1979

1290

access="readwrite")

1980

1291

def ApprovalDelay_dbus_property(self, value=None):

1981

1292

if value is None: # get

1982

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

1983

* 1000)

1293

return dbus.UInt64(self.approval_delay_milliseconds())

1984

1294

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

1985

1295

1986

1296

# ApprovalDuration - property

1987

@dbus_service_property(_interface,

1988

signature="t",

1297

@dbus_service_property(_interface, signature="t",

1989

1298

access="readwrite")

1990

1299

def ApprovalDuration_dbus_property(self, value=None):

1991

1300

if value is None: # get

1992

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

1993

* 1000)

1301

return dbus.UInt64(timedelta_to_milliseconds(

1302

self.approval_duration))

1994

1303

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

1995

1304

1996

1305

# Name - property

1997

@dbus_annotations(

1998

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

1999

1306

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

2000

1307

def Name_dbus_property(self):

2001

1308

return dbus.String(self.name)

2002

1309

2003

1310

# Fingerprint - property

2004

@dbus_annotations(

2005

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

2006

1311

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

2007

1312

def Fingerprint_dbus_property(self):

2008

1313

return dbus.String(self.fingerprint)

2009

1314

2010

1315

# Host - property

2011

@dbus_service_property(_interface,

2012

signature="s",

1316

@dbus_service_property(_interface, signature="s",

2013

1317

access="readwrite")

2014

1318

def Host_dbus_property(self, value=None):

2015

1319

if value is None: # get

2016

1320

return dbus.String(self.host)

2017

self.host = str(value)

2018

1321

self.host = unicode(value)

1322

2019

1323

# Created - property

2020

@dbus_annotations(

2021

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

2022

1324

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

2023

1325

def Created_dbus_property(self):

2024

1326

return datetime_to_dbus(self.created)

2025

1327

2026

1328

# LastEnabled - property

2027

1329

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

2028

1330

def LastEnabled_dbus_property(self):

2029

1331

return datetime_to_dbus(self.last_enabled)

2030

1332

2031

1333

# Enabled - property

2032

@dbus_service_property(_interface,

2033

signature="b",

1334

@dbus_service_property(_interface, signature="b",

2034

1335

access="readwrite")

2035

1336

def Enabled_dbus_property(self, value=None):

2036

1337

if value is None: # get

2039

1340

self.enable()

2040

1341

else:

2041

1342

self.disable()

2042

1343

2043

1344

# LastCheckedOK - property

2044

@dbus_service_property(_interface,

2045

signature="s",

1345

@dbus_service_property(_interface, signature="s",

2046

1346

access="readwrite")

2047

1347

def LastCheckedOK_dbus_property(self, value=None):

2048

1348

if value is not None:

2049

1349

self.checked_ok()

2050

1350

return

2051

1351

return datetime_to_dbus(self.last_checked_ok)

2052

2053

# LastCheckerStatus - property

2054

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

2055

def LastCheckerStatus_dbus_property(self):

2056

return dbus.Int16(self.last_checker_status)

2057

1352

2058

1353

# Expires - property

2059

1354

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

2060

1355

def Expires_dbus_property(self):

2061

1356

return datetime_to_dbus(self.expires)

2062

1357

2063

1358

# LastApprovalRequest - property

2064

1359

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

2065

1360

def LastApprovalRequest_dbus_property(self):

2066

1361

return datetime_to_dbus(self.last_approval_request)

2067

1362

2068

1363

# Timeout - property

2069

@dbus_service_property(_interface,

2070

signature="t",

1364

@dbus_service_property(_interface, signature="t",

2071

1365

access="readwrite")

2072

1366

def Timeout_dbus_property(self, value=None):

2073

1367

if value is None: # get

2074

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

2075

old_timeout = self.timeout

1368

return dbus.UInt64(self.timeout_milliseconds())

2076

1369

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

2077

# Reschedule disabling

1370

# Reschedule timeout

2078

1371

if self.enabled:

2079

1372

now = datetime.datetime.utcnow()

2080

self.expires += self.timeout - old_timeout

2081

if self.expires <= now:

1373

time_to_die = timedelta_to_milliseconds(

1374

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

1375

if time_to_die <= 0:

2082

1376

# The timeout has passed

2083

1377

self.disable()

2084

1378

else:

1379

self.expires = (now +

1380

datetime.timedelta(milliseconds =

1381

time_to_die))

2085

1382

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

2086

1383

is None):

2087

1384

return

2088

GLib.source_remove(self.disable_initiator_tag)

2089

self.disable_initiator_tag = GLib.timeout_add(

2090

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

2091

self.disable)

2092

1385

gobject.source_remove(self.disable_initiator_tag)

1386

self.disable_initiator_tag = (gobject.timeout_add

1387

(time_to_die,

1388

self.disable))

1389

2093

1390

# ExtendedTimeout - property

2094

@dbus_service_property(_interface,

2095

signature="t",

1391

@dbus_service_property(_interface, signature="t",

2096

1392

access="readwrite")

2097

1393

def ExtendedTimeout_dbus_property(self, value=None):

2098

1394

if value is None: # get

2099

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

2100

* 1000)

1395

return dbus.UInt64(self.extended_timeout_milliseconds())

2101

1396

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

2102

1397

2103

1398

# Interval - property

2104

@dbus_service_property(_interface,

2105

signature="t",

1399

@dbus_service_property(_interface, signature="t",

2106

1400

access="readwrite")

2107

1401

def Interval_dbus_property(self, value=None):

2108

1402

if value is None: # get

2109

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

1403

return dbus.UInt64(self.interval_milliseconds())

2110

1404

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

2111

1405

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

2112

1406

return

2113

1407

if self.enabled:

2114

1408

# Reschedule checker run

2115

GLib.source_remove(self.checker_initiator_tag)

2116

self.checker_initiator_tag = GLib.timeout_add(

2117

value, self.start_checker)

2118

self.start_checker() # Start one now, too

2119

1409

gobject.source_remove(self.checker_initiator_tag)

1410

self.checker_initiator_tag = (gobject.timeout_add

1411

(value, self.start_checker))

1412

self.start_checker() # Start one now, too

1413

2120

1414

# Checker - property

2121

@dbus_service_property(_interface,

2122

signature="s",

1415

@dbus_service_property(_interface, signature="s",

2123

1416

access="readwrite")

2124

1417

def Checker_dbus_property(self, value=None):

2125

1418

if value is None: # get

2126

1419

return dbus.String(self.checker_command)

2127

self.checker_command = str(value)

2128

1420

self.checker_command = unicode(value)

1421

2129

1422

# CheckerRunning - property

2130

@dbus_service_property(_interface,

2131

signature="b",

1423

@dbus_service_property(_interface, signature="b",

2132

1424

access="readwrite")

2133

1425

def CheckerRunning_dbus_property(self, value=None):

2134

1426

if value is None: # get

2137

1429

self.start_checker()

2138

1430

else:

2139

1431

self.stop_checker()

2140

1432

2141

1433

# ObjectPath - property

2142

@dbus_annotations(

2143

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

2144

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

2145

1434

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

2146

1435

def ObjectPath_dbus_property(self):

2147

return self.dbus_object_path # is already a dbus.ObjectPath

2148

1436

return self.dbus_object_path # is already a dbus.ObjectPath

1437

2149

1438

# Secret = property

2150

@dbus_annotations(

2151

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

2152

"invalidates"})

2153

@dbus_service_property(_interface,

2154

signature="ay",

2155

access="write",

2156

byte_arrays=True)

1439

@dbus_service_property(_interface, signature="ay",

1440

access="write", byte_arrays=True)

2157

1441

def Secret_dbus_property(self, value):

2158

self.secret = bytes(value)

2159

1442

self.secret = str(value)

1443

2160

1444

del _interface

2161

1445

2162

1446

2165

1449

self._pipe = child_pipe

2166

1450

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

2167

1451

if not self._pipe.recv():

2168

raise KeyError(fpr)

2169

1452

raise KeyError()

1453

2170

1454

def __getattribute__(self, name):

2171

1455

if name == '_pipe':

2172

1456

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

2175

1459

if data[0] == 'data':

2176

1460

return data[1]

2177

1461

if data[0] == 'function':

2178

2179

1462

def func(*args, **kwargs):

2180

1463

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

2181

1464

return self._pipe.recv()[1]

2182

2183

1465

return func

2184

1466

2185

1467

def __setattr__(self, name, value):

2186

1468

if name == '_pipe':

2187

1469

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

2188

1470

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

2189

1471

2190

1472

1473

class ClientDBusTransitional(ClientDBus):

1474

__metaclass__ = AlternateDBusNamesMetaclass

1475

1476

2191

1477

class ClientHandler(socketserver.BaseRequestHandler, object):

2192

1478

"""A class to handle client connections.

2193

1479

2194

1480

Instantiated once for each connection to handle it.

2195

1481

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

2196

1482

2197

1483

def handle(self):

2198

1484

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

2199

1485

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

2200

str(self.client_address))

1486

unicode(self.client_address))

2201

1487

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

2202

1488

self.server.child_pipe.fileno())

2203

2204

session = gnutls.ClientSession(self.request)

2205

2206

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

2207

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

2208

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

2209

# "+DHE-DSS"))

1489

1490

session = (gnutls.connection

1491

.ClientSession(self.request,

1492

gnutls.connection

1493

.X509Credentials()))

1494

1495

# Note: gnutls.connection.X509Credentials is really a

1496

# generic GnuTLS certificate credentials object so long as

1497

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

1498

# here despite using OpenPGP certificates.

1499

1500

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

1501

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

1502

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

1503

# "+DHE-DSS"))

2210

1504

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

2211

1505

priority = self.server.gnutls_priority

2212

1506

if priority is None:

2213

1507

priority = "NORMAL"

2214

gnutls.priority_set_direct(session._c_object,

2215

priority.encode("utf-8"),

2216

None)

2217

1508

(gnutls.library.functions

1509

.gnutls_priority_set_direct(session._c_object,

1510

priority, None))

1511

2218

1512

# Start communication using the Mandos protocol

2219

1513

# Get protocol number

2220

1514

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

2221

1515

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

2222

1516

try:

2223

1517

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

2224

raise RuntimeError(line)

1518

raise RuntimeError

2225

1519

except (ValueError, IndexError, RuntimeError) as error:

2226

1520

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

2227

1521

return

2228

1522

2229

1523

# Start GnuTLS connection

2230

1524

try:

2231

1525

session.handshake()

2232

except gnutls.Error as error:

1526

except gnutls.errors.GNUTLSError as error:

2233

1527

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

2234

1528

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

2235

1529

# established. Just abandon the request.

2236

1530

return

2237

1531

logger.debug("Handshake succeeded")

2238

1532

2239

1533

approval_required = False

2240

1534

try:

2241

1535

try:

2242

fpr = self.fingerprint(

2243

self.peer_certificate(session))

2244

except (TypeError, gnutls.Error) as error:

1536

fpr = self.fingerprint(self.peer_certificate

1537

(session))

1538

except (TypeError,

1539

gnutls.errors.GNUTLSError) as error:

2245

1540

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

2246

1541

return

2247

1542

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

2248

1543

2249

1544

try:

2250

1545

client = ProxyClient(child_pipe, fpr,

2251

1546

self.client_address)

2252

1547

except KeyError:

2253

1548

return

2254

1549

1550

if self.server.use_dbus:

1551

# Emit D-Bus signal

1552

client.NewRequest(str(self.client_address))

1553

2255

1554

if client.approval_delay:

2256

1555

delay = client.approval_delay

2257

1556

client.approvals_pending += 1

2258

1557

approval_required = True

2259

1558

2260

1559

while True:

2261

1560

if not client.enabled:

2262

1561

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

2263

client.name)

1562

client.name)

2264

1563

if self.server.use_dbus:

2265

1564

# Emit D-Bus signal

2266

1565

client.Rejected("Disabled")

2267

1566

return

2268

1567

2269

1568

if client.approved or not client.approval_delay:

2270

# We are approved or approval is disabled

1569

#We are approved or approval is disabled

2271

1570

break

2272

1571

elif client.approved is None:

2273

1572

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

2275

1574

if self.server.use_dbus:

2276

1575

# Emit D-Bus signal

2277

1576

client.NeedApproval(

2278

client.approval_delay.total_seconds()

2279

* 1000, client.approved_by_default)

1577

client.approval_delay_milliseconds(),

1578

client.approved_by_default)

2280

1579

else:

2281

1580

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

2282

1581

client.name)

2284

1583

# Emit D-Bus signal

2285

1584

client.Rejected("Denied")

2286

1585

return

2287

2288

# wait until timeout or approved

1586

1587

#wait until timeout or approved

2289

1588

time = datetime.datetime.now()

2290

1589

client.changedstate.acquire()

2291

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

1590

(client.changedstate.wait

1591

(float(client.timedelta_to_milliseconds(delay)

1592

/ 1000)))

2292

1593

client.changedstate.release()

2293

1594

time2 = datetime.datetime.now()

2294

1595

if (time2 - time) >= delay:

2304

1605

break

2305

1606

else:

2306

1607

delay -= time2 - time

2307

2308

try:

2309

session.send(client.secret)

2310

except gnutls.Error as error:

2311

logger.warning("gnutls send failed",

2312

exc_info=error)

2313

return

2314

1608

1609

sent_size = 0

1610

while sent_size < len(client.secret):

1611

try:

1612

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

1613

except gnutls.errors.GNUTLSError as error:

1614

logger.warning("gnutls send failed")

1615

return

1616

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

1617

sent, len(client.secret)

1618

- (sent_size + sent))

1619

sent_size += sent

1620

2315

1621

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

2316

1622

# bump the timeout using extended_timeout

2317

client.bump_timeout(client.extended_timeout)

1623

client.checked_ok(client.extended_timeout)

2318

1624

if self.server.use_dbus:

2319

1625

# Emit D-Bus signal

2320

1626

client.GotSecret()

2321

1627

2322

1628

finally:

2323

1629

if approval_required:

2324

1630

client.approvals_pending -= 1

2325

1631

try:

2326

1632

session.bye()

2327

except gnutls.Error as error:

2328

logger.warning("GnuTLS bye failed",

2329

exc_info=error)

2330

1633

except gnutls.errors.GNUTLSError as error:

1634

logger.warning("GnuTLS bye failed")

1635

2331

1636

@staticmethod

2332

1637

def peer_certificate(session):

2333

1638

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

2334

1639

# If not an OpenPGP certificate...

2335

if (gnutls.certificate_type_get(session._c_object)

2336

!= gnutls.CRT_OPENPGP):

2337

# ...return invalid data

2338

return b""

1640

if (gnutls.library.functions

1641

.gnutls_certificate_type_get(session._c_object)

1642

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1643

# ...do the normal thing

1644

return session.peer_certificate

2339

1645

list_size = ctypes.c_uint(1)

2340

cert_list = (gnutls.certificate_get_peers

1646

cert_list = (gnutls.library.functions

1647

.gnutls_certificate_get_peers

2341

1648

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

2342

1649

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

2343

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

1650

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

1651

" certificate")

2344

1652

if list_size.value == 0:

2345

1653

return None

2346

1654

cert = cert_list[0]

2347

1655

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

2348

1656

2349

1657

@staticmethod

2350

1658

def fingerprint(openpgp):

2351

1659

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2352

1660

# New GnuTLS "datum" with the OpenPGP public key

2353

datum = gnutls.datum_t(

2354

ctypes.cast(ctypes.c_char_p(openpgp),

2355

ctypes.POINTER(ctypes.c_ubyte)),

2356

ctypes.c_uint(len(openpgp)))

1661

datum = (gnutls.library.types

1662

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

1663

ctypes.POINTER

1664

(ctypes.c_ubyte)),

1665

ctypes.c_uint(len(openpgp))))

2357

1666

# New empty GnuTLS certificate

2358

crt = gnutls.openpgp_crt_t()

2359

gnutls.openpgp_crt_init(ctypes.byref(crt))

1667

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1668

(gnutls.library.functions

1669

.gnutls_openpgp_crt_init(ctypes.byref(crt)))

2360

1670

# Import the OpenPGP public key into the certificate

2361

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

2362

gnutls.OPENPGP_FMT_RAW)

1671

(gnutls.library.functions

1672

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

1673

gnutls.library.constants

1674

.GNUTLS_OPENPGP_FMT_RAW))

2363

1675

# Verify the self signature in the key

2364

1676

crtverify = ctypes.c_uint()

2365

gnutls.openpgp_crt_verify_self(crt, 0,

2366

ctypes.byref(crtverify))

1677

(gnutls.library.functions

1678

.gnutls_openpgp_crt_verify_self(crt, 0,

1679

ctypes.byref(crtverify)))

2367

1680

if crtverify.value != 0:

2368

gnutls.openpgp_crt_deinit(crt)

2369

raise gnutls.CertificateSecurityError("Verify failed")

1681

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1682

raise (gnutls.errors.CertificateSecurityError

1683

("Verify failed"))

2370

1684

# New buffer for the fingerprint

2371

1685

buf = ctypes.create_string_buffer(20)

2372

1686

buf_len = ctypes.c_size_t()

2373

1687

# Get the fingerprint from the certificate into the buffer

2374

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

2375

ctypes.byref(buf_len))

1688

(gnutls.library.functions

1689

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

1690

ctypes.byref(buf_len)))

2376

1691

# Deinit the certificate

2377

gnutls.openpgp_crt_deinit(crt)

1692

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2378

1693

# Convert the buffer to a Python bytestring

2379

1694

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

2380

1695

# Convert the bytestring to hexadecimal notation

2384

1699

2385

1700

class MultiprocessingMixIn(object):

2386

1701

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

2387

2388

1702

def sub_process_main(self, request, address):

2389

1703

try:

2390

1704

self.finish_request(request, address)

2391

1705

except Exception:

2392

1706

self.handle_error(request, address)

2393

1707

self.close_request(request)

2394

1708

2395

1709

def process_request(self, request, address):

2396

1710

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

2397

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

2398

args=(request, address))

1711

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

1712

args = (request,

1713

address))

2399

1714

proc.start()

2400

1715

return proc

2401

1716

2402

1717

2403

1718

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2404

1719

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

2405

2406

1720

def process_request(self, request, client_address):

2407

1721

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

2408

1722

2409

1723

This function creates a new pipe in self.pipe

2410

1724

"""

2411

1725

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2412

1726

2413

1727

proc = MultiprocessingMixIn.process_request(self, request,

2414

1728

client_address)

2415

1729

self.child_pipe.close()

2416

1730

self.add_pipe(parent_pipe, proc)

2417

1731

2418

1732

def add_pipe(self, parent_pipe, proc):

2419

1733

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

2420

raise NotImplementedError()

1734

raise NotImplementedError

2421

1735

2422

1736

2423

1737

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2424

1738

socketserver.TCPServer, object):

2425

1739

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

2426

1740

2427

1741

Attributes:

2428

1742

enabled: Boolean; whether this server is activated yet

2429

1743

interface: None or a network interface name (string)

2430

1744

use_ipv6: Boolean; to use IPv6 or not

2431

1745

"""

2432

2433

1746

def __init__(self, server_address, RequestHandlerClass,

2434

interface=None,

2435

use_ipv6=True,

2436

socketfd=None):

2437

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

2438

creating a new one with socket.socket().

2439

"""

1747

interface=None, use_ipv6=True):

2440

1748

self.interface = interface

2441

1749

if use_ipv6:

2442

1750

self.address_family = socket.AF_INET6

2443

if socketfd is not None:

2444

# Save the file descriptor

2445

self.socketfd = socketfd

2446

# Save the original socket.socket() function

2447

self.socket_socket = socket.socket

2448

2449

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

2450

#

2451

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

2452

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

2453

# patching socket.socket.)

2454

#

2455

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

2456

@functools.wraps(socket.socket)

2457

def socket_wrapper(*args, **kwargs):

2458

# Restore original function so subsequent calls are

2459

# not affected.

2460

socket.socket = self.socket_socket

2461

del self.socket_socket

2462

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

2463

# saved file descriptor.

2464

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

2465

# Replace socket.socket() function with wrapper

2466

socket.socket = socket_wrapper

2467

# The socketserver.TCPServer.__init__ will call

2468

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

2469

# socket_wrapper(), if socketfd was set.

2470

1751

socketserver.TCPServer.__init__(self, server_address,

2471

1752

RequestHandlerClass)

2472

2473

1753

def server_bind(self):

2474

1754

"""This overrides the normal server_bind() function

2475

1755

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

2476

1756

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

2477

global SO_BINDTODEVICE

2478

1757

if self.interface is not None:

2479

1758

if SO_BINDTODEVICE is None:

2480

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

2481

# common enough.

2482

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

2483

SO_BINDTODEVICE = 25

2484

try:

2485

self.socket.setsockopt(

2486

socket.SOL_SOCKET, SO_BINDTODEVICE,

2487

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

2488

except socket.error as error:

2489

if error.errno == errno.EPERM:

2490

logger.error("No permission to bind to"

2491

" interface %s", self.interface)

2492

elif error.errno == errno.ENOPROTOOPT:

2493

logger.error("SO_BINDTODEVICE not available;"

2494

" cannot bind to interface %s",

2495

self.interface)

2496

elif error.errno == errno.ENODEV:

2497

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

2498

" cannot bind", self.interface)

2499

else:

2500

raise

1759

logger.error("SO_BINDTODEVICE does not exist;"

1760

" cannot bind to interface %s",

1761

self.interface)

1762

else:

1763

try:

1764

self.socket.setsockopt(socket.SOL_SOCKET,

1765

SO_BINDTODEVICE,

1766

str(self.interface

1767

+ '\0'))

1768

except socket.error as error:

1769

if error[0] == errno.EPERM:

1770

logger.error("No permission to"

1771

" bind to interface %s",

1772

self.interface)

1773

elif error[0] == errno.ENOPROTOOPT:

1774

logger.error("SO_BINDTODEVICE not available;"

1775

" cannot bind to interface %s",

1776

self.interface)

1777

else:

1778

raise

2501

1779

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

2502

1780

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

2503

1781

if not self.server_address[0]:

2504

1782

if self.address_family == socket.AF_INET6:

2505

any_address = "::" # in6addr_any

1783

any_address = "::" # in6addr_any

2506

1784

else:

2507

any_address = "0.0.0.0" # INADDR_ANY

1785

any_address = socket.INADDR_ANY

2508

1786

self.server_address = (any_address,

2509

1787

self.server_address[1])

2510

1788

elif not self.server_address[1]:

2511

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

1789

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

1790

0)

2512

1791

# if self.interface:

2513

1792

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

2514

1793

# 0, # port

2520

1799

2521

1800

class MandosServer(IPv6_TCPServer):

2522

1801

"""Mandos server.

2523

1802

2524

1803

Attributes:

2525

1804

clients: set of Client objects

2526

1805

gnutls_priority GnuTLS priority string

2527

1806

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

2528

2529

Assumes a GLib.MainLoop event loop.

1807

1808

Assumes a gobject.MainLoop event loop.

2530

1809

"""

2531

2532

1810

def __init__(self, server_address, RequestHandlerClass,

2533

interface=None,

2534

use_ipv6=True,

2535

clients=None,

2536

gnutls_priority=None,

2537

use_dbus=True,

2538

socketfd=None):

1811

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

1812

gnutls_priority=None, use_dbus=True):

2539

1813

self.enabled = False

2540

1814

self.clients = clients

2541

1815

if self.clients is None:

2544

1818

self.gnutls_priority = gnutls_priority

2545

1819

IPv6_TCPServer.__init__(self, server_address,

2546

1820

RequestHandlerClass,

2547

interface=interface,

2548

use_ipv6=use_ipv6,

2549

socketfd=socketfd)

2550

1821

interface = interface,

1822

use_ipv6 = use_ipv6)

2551

1823

def server_activate(self):

2552

1824

if self.enabled:

2553

1825

return socketserver.TCPServer.server_activate(self)

2554

1826

2555

1827

def enable(self):

2556

1828

self.enabled = True

2557

1829

2558

1830

def add_pipe(self, parent_pipe, proc):

2559

1831

# Call "handle_ipc" for both data and EOF events

2560

GLib.io_add_watch(

2561

parent_pipe.fileno(),

2562

GLib.IO_IN | GLib.IO_HUP,

2563

functools.partial(self.handle_ipc,

2564

parent_pipe=parent_pipe,

2565

proc=proc))

2566

2567

def handle_ipc(self, source, condition,

2568

parent_pipe=None,

2569

proc=None,

2570

client_object=None):

1832

gobject.io_add_watch(parent_pipe.fileno(),

1833

gobject.IO_IN | gobject.IO_HUP,

1834

functools.partial(self.handle_ipc,

1835

parent_pipe =

1836

parent_pipe,

1837

proc = proc))

1838

1839

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

1840

proc = None, client_object=None):

1841

condition_names = {

1842

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

1843

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

1844

# blocking).

1845

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

1846

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

1847

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

1848

# broken, usually for pipes and

1849

# sockets).

1850

}

1851

conditions_string = ' | '.join(name

1852

for cond, name in

1853

condition_names.iteritems()

1854

if cond & condition)

2571

1855

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

2572

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

1856

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

2573

1857

# Wait for other process to exit

2574

1858

proc.join()

2575

1859

return False

2576

1860

2577

1861

# Read a request from the child

2578

1862

request = parent_pipe.recv()

2579

1863

command = request[0]

2580

1864

2581

1865

if command == 'init':

2582

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

1866

fpr = request[1]

2583

1867

address = request[2]

2584

2585

for c in self.clients.values():

1868

1869

for c in self.clients.itervalues():

2586

1870

if c.fingerprint == fpr:

2587

1871

client = c

2588

1872

break

2595

1879

address[0])

2596

1880

parent_pipe.send(False)

2597

1881

return False

2598

2599

GLib.io_add_watch(

2600

parent_pipe.fileno(),

2601

GLib.IO_IN | GLib.IO_HUP,

2602

functools.partial(self.handle_ipc,

2603

parent_pipe=parent_pipe,

2604

proc=proc,

2605

client_object=client))

1882

1883

gobject.io_add_watch(parent_pipe.fileno(),

1884

gobject.IO_IN | gobject.IO_HUP,

1885

functools.partial(self.handle_ipc,

1886

parent_pipe =

1887

parent_pipe,

1888

proc = proc,

1889

client_object =

1890

client))

2606

1891

parent_pipe.send(True)

2607

1892

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

2608

1893

# same fileno

2611

1896

funcname = request[1]

2612

1897

args = request[2]

2613

1898

kwargs = request[3]

2614

1899

2615

1900

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

2616

1901

funcname)(*args,

2617

**kwargs)))

2618

1902

**kwargs)))

1903

2619

1904

if command == 'getattr':

2620

1905

attrname = request[1]

2621

if isinstance(client_object.__getattribute__(attrname),

2622

collections.Callable):

2623

parent_pipe.send(('function', ))

1906

if callable(client_object.__getattribute__(attrname)):

1907

parent_pipe.send(('function',))

2624

1908

else:

2625

parent_pipe.send((

2626

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

2627

1909

parent_pipe.send(('data', client_object

1910

.__getattribute__(attrname)))

1911

2628

1912

if command == 'setattr':

2629

1913

attrname = request[1]

2630

1914

value = request[2]

2631

1915

setattr(client_object, attrname, value)

2632

1916

2633

1917

return True

2634

1918

2635

1919

2636

def rfc3339_duration_to_delta(duration):

2637

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

2638

2639

>>> rfc3339_duration_to_delta("P7D")

2640

datetime.timedelta(7)

2641

>>> rfc3339_duration_to_delta("PT60S")

2642

datetime.timedelta(0, 60)

2643

>>> rfc3339_duration_to_delta("PT60M")

2644

datetime.timedelta(0, 3600)

2645

>>> rfc3339_duration_to_delta("PT24H")

2646

datetime.timedelta(1)

2647

>>> rfc3339_duration_to_delta("P1W")

2648

datetime.timedelta(7)

2649

>>> rfc3339_duration_to_delta("PT5M30S")

2650

datetime.timedelta(0, 330)

2651

>>> rfc3339_duration_to_delta("P1DT3M20S")

2652

datetime.timedelta(1, 200)

2653

"""

2654

2655

# Parsing an RFC 3339 duration with regular expressions is not

2656

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

2657

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

2658

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

2659

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

2660

# avoid excessive use of external libraries.

2661

2662

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

2663

Token = collections.namedtuple("Token", (

2664

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

2665

# a "group" containing digits

2666

"value", # datetime.timedelta or None

2667

"followers")) # Tokens valid after this token

2668

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

2669

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

2670

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

2671

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

2672

datetime.timedelta(seconds=1),

2673

frozenset((token_end, )))

2674

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

2675

datetime.timedelta(minutes=1),

2676

frozenset((token_second, token_end)))

2677

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

2678

datetime.timedelta(hours=1),

2679

frozenset((token_minute, token_end)))

2680

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

2681

None,

2682

frozenset((token_hour, token_minute,

2683

token_second)))

2684

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

2685

datetime.timedelta(days=1),

2686

frozenset((token_time, token_end)))

2687

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

2688

datetime.timedelta(weeks=4),

2689

frozenset((token_day, token_end)))

2690

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

2691

datetime.timedelta(weeks=52),

2692

frozenset((token_month, token_end)))

2693

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

2694

datetime.timedelta(weeks=1),

2695

frozenset((token_end, )))

2696

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

2697

frozenset((token_year, token_month,

2698

token_day, token_time,

2699

token_week)))

2700

# Define starting values:

2701

# Value so far

2702

value = datetime.timedelta()

2703

found_token = None

2704

# Following valid tokens

2705

followers = frozenset((token_duration, ))

2706

# String left to parse

2707

s = duration

2708

# Loop until end token is found

2709

while found_token is not token_end:

2710

# Search for any currently valid tokens

2711

for token in followers:

2712

match = token.regexp.match(s)

2713

if match is not None:

2714

# Token found

2715

if token.value is not None:

2716

# Value found, parse digits

2717

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

2718

# Add to value so far

2719

value += factor * token.value

2720

# Strip token from string

2721

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

2722

# Go to found token

2723

found_token = token

2724

# Set valid next tokens

2725

followers = found_token.followers

2726

break

2727

else:

2728

# No currently valid tokens were found

2729

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

2730

.format(duration))

2731

# End token found

2732

return value

2733

2734

2735

1920

def string_to_delta(interval):

2736

1921

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

2737

1922

2738

1923

>>> string_to_delta('7d')

2739

1924

datetime.timedelta(7)

2740

1925

>>> string_to_delta('60s')

2748

1933

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

2749

1934

datetime.timedelta(0, 330)

2750

1935

"""

2751

2752

try:

2753

return rfc3339_duration_to_delta(interval)

2754

except ValueError:

2755

pass

2756

2757

1936

timevalue = datetime.timedelta(0)

2758

1937

for s in interval.split():

2759

1938

try:

2760

suffix = s[-1]

1939

suffix = unicode(s[-1])

2761

1940

value = int(s[:-1])

2762

1941

if suffix == "d":

2763

1942

delta = datetime.timedelta(value)

2770

1949

elif suffix == "w":

2771

1950

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

2772

1951

else:

2773

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

2774

except IndexError as e:

1952

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

1953

except (ValueError, IndexError) as e:

2775

1954

raise ValueError(*(e.args))

2776

1955

timevalue += delta

2777

1956

return timevalue

2778

1957

2779

1958

2780

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

1959

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

2781

1960

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

2782

1961

2783

1962

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

2784

1963

if os.fork():

2785

1964

sys.exit()

2790

1969

sys.exit()

2791

1970

if not noclose:

2792

1971

# Close all standard open file descriptors

2793

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

1972

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

2794

1973

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

2795

1974

raise OSError(errno.ENODEV,

2796

"{} not a character device"

2797

.format(os.devnull))

1975

"%s not a character device"

1976

% os.path.devnull)

2798

1977

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

2799

1978

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

2800

1979

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

2803

1982

2804

1983

2805

1984

def main():

2806

1985

2807

1986

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

2808

1987

# Parsing of options, both command line and config file

2809

1988

2810

1989

parser = argparse.ArgumentParser()

2811

1990

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

2812

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

1991

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

2813

1992

help="show version number and exit")

2814

1993

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

2815

1994

help="Bind to interface IF")

2821

2000

help="Run self-test")

2822

2001

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

2823

2002

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

2824

" to terminal", default=None)

2003

" to terminal")

2825

2004

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

2826

2005

help="Debug level for stdout output")

2827

2006

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

2834

2013

" files")

2835

2014

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

2836

2015

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

2837

" system bus interface", default=None)

2016

" system bus interface")

2838

2017

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

2839

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

2840

default=None)

2018

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

2841

2019

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

2842

2020

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

2843

" state", default=None)

2844

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

2845

help="Specify a file descriptor to a network"

2846

" socket to use instead of creating one")

2021

" state")

2847

2022

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

2848

2023

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

2849

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

2850

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

2851

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

2852

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

2853

default=None)

2854

2024

2855

2025

options = parser.parse_args()

2856

2026

2857

2027

if options.check:

2858

2028

import doctest

2859

fail_count, test_count = doctest.testmod()

2860

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

2861

2029

doctest.testmod()

2030

sys.exit()

2031

2862

2032

# Default values for config file for server-global settings

2863

server_defaults = {"interface": "",

2864

"address": "",

2865

"port": "",

2866

"debug": "False",

2867

"priority":

2868

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

2869

":+SIGN-DSA-SHA256",

2870

"servicename": "Mandos",

2871

"use_dbus": "True",

2872

"use_ipv6": "True",

2873

"debuglevel": "",

2874

"restore": "True",

2875

"socket": "",

2876

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

2877

"foreground": "False",

2878

"zeroconf": "True",

2879

}

2880

2033

server_defaults = { "interface": "",

2034

"address": "",

2035

"port": "",

2036

"debug": "False",

2037

"priority":

2038

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

2039

"servicename": "Mandos",

2040

"use_dbus": "True",

2041

"use_ipv6": "True",

2042

"debuglevel": "",

2043

"restore": "True",

2044

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

2045

}

2046

2881

2047

# Parse config file for server-global settings

2882

2048

server_config = configparser.SafeConfigParser(server_defaults)

2883

2049

del server_defaults

2884

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

2050

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

2051

"mandos.conf"))

2885

2052

# Convert the SafeConfigParser object to a dict

2886

2053

server_settings = server_config.defaults()

2887

2054

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

2888

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

2889

"foreground", "zeroconf"):

2055

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

2890

2056

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

2891

2057

option)

2892

2058

if server_settings["port"]:

2893

2059

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

2894

2060

"port")

2895

if server_settings["socket"]:

2896

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

2897

"socket")

2898

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

2899

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

2900

# happen with a supplied network socket.

2901

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

2902

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

2903

["socket"])

2904

2061

del server_config

2905

2062

2906

2063

# Override the settings from the config file with command line

2907

2064

# options, if set.

2908

2065

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

2909

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

2910

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

2911

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

2066

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

2067

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

2068

"statedir"):

2912

2069

value = getattr(options, option)

2913

2070

if value is not None:

2914

2071

server_settings[option] = value

2915

2072

del options

2916

2073

# Force all strings to be unicode

2917

2074

for option in server_settings.keys():

2918

if isinstance(server_settings[option], bytes):

2919

server_settings[option] = (server_settings[option]

2920

.decode("utf-8"))

2921

# Force all boolean options to be boolean

2922

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

2923

"foreground", "zeroconf"):

2924

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

2925

# Debug implies foreground

2926

if server_settings["debug"]:

2927

server_settings["foreground"] = True

2075

if type(server_settings[option]) is str:

2076

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

2928

2077

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

2929

2078

2930

2079

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

2931

2932

if (not server_settings["zeroconf"]

2933

and not (server_settings["port"]

2934

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

2935

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

2936

2080

2937

2081

# For convenience

2938

2082

debug = server_settings["debug"]

2939

2083

debuglevel = server_settings["debuglevel"]

2941

2085

use_ipv6 = server_settings["use_ipv6"]

2942

2086

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

2943

2087

stored_state_file)

2944

foreground = server_settings["foreground"]

2945

zeroconf = server_settings["zeroconf"]

2946

2088

2947

2089

if debug:

2948

2090

initlogger(debug, logging.DEBUG)

2949

2091

else:

2952

2094

else:

2953

2095

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

2954

2096

initlogger(debug, level)

2955

2097

2956

2098

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

2957

syslogger.setFormatter(

2958

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

2959

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

2960

server_settings["servicename"])))

2961

2099

syslogger.setFormatter(logging.Formatter

2100

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

2101

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

2102

% server_settings["servicename"]))

2103

2962

2104

# Parse config file with clients

2963

2105

client_config = configparser.SafeConfigParser(Client

2964

2106

.client_defaults)

2965

2107

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

2966

2108

"clients.conf"))

2967

2109

2968

2110

global mandos_dbus_service

2969

2111

mandos_dbus_service = None

2970

2971

socketfd = None

2972

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

2973

socketfd = server_settings["socket"]

2974

tcp_server = MandosServer(

2975

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

2976

ClientHandler,

2977

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

2978

use_ipv6=use_ipv6,

2979

gnutls_priority=server_settings["priority"],

2980

use_dbus=use_dbus,

2981

socketfd=socketfd)

2982

if not foreground:

2983

pidfilename = "/run/mandos.pid"

2984

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

2985

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

2986

pidfile = None

2987

try:

2988

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

2989

except IOError as e:

2990

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

2991

exc_info=e)

2992

2993

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

2994

("mandos", "mandos"),

2995

("nobody", "nogroup")):

2996

try:

2997

uid = pwd.getpwnam(name).pw_uid

2998

gid = pwd.getpwnam(group).pw_gid

2999

break

2112

2113

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

2114

server_settings["port"]),

2115

ClientHandler,

2116

interface=(server_settings["interface"]

2117

or None),

2118

use_ipv6=use_ipv6,

2119

gnutls_priority=

2120

server_settings["priority"],

2121

use_dbus=use_dbus)

2122

if not debug:

2123

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

2124

try:

2125

pidfile = open(pidfilename, "w")

2126

except IOError:

2127

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

2128

2129

try:

2130

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

2131

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

2132

except KeyError:

2133

try:

2134

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

2135

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

3000

2136

except KeyError:

3001

continue

3002

else:

3003

uid = 65534

3004

gid = 65534

2137

try:

2138

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

2139

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

2140

except KeyError:

2141

uid = 65534

2142

gid = 65534

3005

2143

try:

3006

2144

os.setgid(gid)

3007

2145

os.setuid(uid)

3008

if debug:

3009

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

3010

gid))

3011

2146

except OSError as error:

3012

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

3013

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

3014

if error.errno != errno.EPERM:

3015

raise

3016

2147

if error[0] != errno.EPERM:

2148

raise error

2149

3017

2150

if debug:

3018

2151

# Enable all possible GnuTLS debugging

3019

2152

3020

2153

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

3021

2154

# - GnuTLS manual

3022

gnutls.global_set_log_level(11)

3023

3024

@gnutls.log_func

2155

gnutls.library.functions.gnutls_global_set_log_level(11)

2156

2157

@gnutls.library.types.gnutls_log_func

3025

2158

def debug_gnutls(level, string):

3026

2159

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

3027

3028

gnutls.global_set_log_function(debug_gnutls)

3029

2160

2161

(gnutls.library.functions

2162

.gnutls_global_set_log_function(debug_gnutls))

2163

3030

2164

# Redirect stdin so all checkers get /dev/null

3031

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

2165

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

3032

2166

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

3033

2167

if null > 2:

3034

2168

os.close(null)

3035

2169

3036

2170

# Need to fork before connecting to D-Bus

3037

if not foreground:

2171

if not debug:

3038

2172

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

3039

2173

daemon()

3040

3041

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

3042

# to inform GLib that threads will be used.

3043

GLib.threads_init()

3044

2174

2175

gobject.threads_init()

2176

3045

2177

global main_loop

3046

2178

# From the Avahi example code

3047

DBusGMainLoop(set_as_default=True)

3048

main_loop = GLib.MainLoop()

2179

DBusGMainLoop(set_as_default=True )

2180

main_loop = gobject.MainLoop()

3049

2181

bus = dbus.SystemBus()

3050

2182

# End of Avahi example code

3051

2183

if use_dbus:

3052

2184

try:

3053

2185

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

3054

bus,

3055

do_not_queue=True)

3056

old_bus_name = dbus.service.BusName(

3057

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

3058

do_not_queue=True)

3059

except dbus.exceptions.DBusException as e:

3060

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

2186

bus, do_not_queue=True)

2187

old_bus_name = (dbus.service.BusName

2188

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

2189

do_not_queue=True))

2190

except dbus.exceptions.NameExistsException as e:

2191

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

3061

2192

use_dbus = False

3062

2193

server_settings["use_dbus"] = False

3063

2194

tcp_server.use_dbus = False

3064

if zeroconf:

3065

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3066

service = AvahiServiceToSyslog(

3067

name=server_settings["servicename"],

3068

servicetype="_mandos._tcp",

3069

protocol=protocol,

3070

bus=bus)

3071

if server_settings["interface"]:

3072

service.interface = if_nametoindex(

3073

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

3074

2195

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2196

service = AvahiServiceToSyslog(name =

2197

server_settings["servicename"],

2198

servicetype = "_mandos._tcp",

2199

protocol = protocol, bus = bus)

2200

if server_settings["interface"]:

2201

service.interface = (if_nametoindex

2202

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

2203

3075

2204

global multiprocessing_manager

3076

2205

multiprocessing_manager = multiprocessing.Manager()

3077

2206

3078

2207

client_class = Client

3079

2208

if use_dbus:

3080

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

3081

2209

client_class = functools.partial(ClientDBusTransitional,

2210

bus = bus)

2211

3082

2212

client_settings = Client.config_parser(client_config)

3083

2213

old_client_settings = {}

3084

2214

clients_data = {}

3085

3086

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

3087

global wnull

3088

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

3089

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

3090

# mode

3091

if debug or not foreground:

3092

wnull.close()

3093

2215

3094

2216

# Get client data and settings from last running state.

3095

2217

if server_settings["restore"]:

3096

2218

try:

3097

2219

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

3098

if sys.version_info.major == 2:

3099

clients_data, old_client_settings = pickle.load(

3100

stored_state)

3101

else:

3102

bytes_clients_data, bytes_old_client_settings = (

3103

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

3104

# Fix bytes to strings

3105

# clients_data

3106

# .keys()

3107

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

3108

if isinstance(key, bytes)

3109

else key): value

3110

for key, value in

3111

bytes_clients_data.items()}

3112

del bytes_clients_data

3113

for key in clients_data:

3114

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

3115

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

3116

for k, v in

3117

clients_data[key].items()}

3118

clients_data[key] = value

3119

# .client_structure

3120

value["client_structure"] = [

3121

(s.decode("utf-8")

3122

if isinstance(s, bytes)

3123

else s) for s in

3124

value["client_structure"]]

3125

# .name & .host

3126

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

3127

if isinstance(value[k], bytes):

3128

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

3129

# old_client_settings

3130

# .keys()

3131

old_client_settings = {

3132

(key.decode("utf-8")

3133

if isinstance(key, bytes)

3134

else key): value

3135

for key, value in

3136

bytes_old_client_settings.items()}

3137

del bytes_old_client_settings

3138

# .host

3139

for value in old_client_settings.values():

3140

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

3141

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

3142

.decode("utf-8"))

2220

clients_data, old_client_settings = (pickle.load

2221

(stored_state))

3143

2222

os.remove(stored_state_path)

3144

2223

except IOError as e:

3145

if e.errno == errno.ENOENT:

3146

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

3147

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

3148

else:

3149

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

3150

exc_info=e)

2224

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

2225

.format(e))

2226

if e.errno != errno.ENOENT:

3151

2227

raise

3152

2228

except EOFError as e:

3153

2229

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

3154

"EOFError:",

3155

exc_info=e)

3156

2230

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

2231

3157

2232

with PGPEngine() as pgp:

3158

for client_name, client in clients_data.items():

3159

# Skip removed clients

3160

if client_name not in client_settings:

3161

continue

3162

2233

for client_name, client in clients_data.iteritems():

3163

2234

# Decide which value to use after restoring saved state.

3164

2235

# We have three different values: Old config file,

3165

2236

# new config file, and saved state.

3170

2241

# For each value in new config, check if it

3171

2242

# differs from the old config value (Except for

3172

2243

# the "secret" attribute)

3173

if (name != "secret"

3174

and (value !=

3175

old_client_settings[client_name][name])):

2244

if (name != "secret" and

2245

value != old_client_settings[client_name]

2246

[name]):

3176

2247

client[name] = value

3177

2248

except KeyError:

3178

2249

pass

3179

2250

3180

2251

# Clients who has passed its expire date can still be

3181

# enabled if its last checker was successful. A Client

3182

# whose checker succeeded before we stored its state is

3183

# assumed to have successfully run all checkers during

3184

# downtime.

2252

# enabled if its last checker was successful. Clients

2253

# whose checker failed before we stored its state is

2254

# assumed to have failed all checkers during downtime.

3185

2255

if client["enabled"]:

3186

2256

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

3187

2257

if not client["last_checked_ok"]:

3188

2258

logger.warning(

3189

"disabling client {} - Client never "

3190

"performed a successful checker".format(

3191

client_name))

2259

"disabling client {0} - Client never "

2260

"performed a successfull checker"

2261

.format(client["name"]))

3192

2262

client["enabled"] = False

3193

2263

elif client["last_checker_status"] != 0:

3194

2264

logger.warning(

3195

"disabling client {} - Client last"

3196

" checker failed with error code"

3197

" {}".format(

3198

client_name,

3199

client["last_checker_status"]))

2265

"disabling client {0} - Client "

2266

"last checker failed with error code {1}"

2267

.format(client["name"],

2268

client["last_checker_status"]))

3200

2269

client["enabled"] = False

3201

2270

else:

3202

client["expires"] = (

3203

datetime.datetime.utcnow()

3204

+ client["timeout"])

2271

client["expires"] = (datetime.datetime

2272

.utcnow()

2273

+ client["timeout"])

3205

2274

logger.debug("Last checker succeeded,"

3206

" keeping {} enabled".format(

3207

client_name))

2275

" keeping {0} enabled"

2276

.format(client["name"]))

3208

2277

try:

3209

client["secret"] = pgp.decrypt(

3210

client["encrypted_secret"],

3211

client_settings[client_name]["secret"])

2278

client["secret"] = (

2279

pgp.decrypt(client["encrypted_secret"],

2280

client_settings[client_name]

2281

["secret"]))

3212

2282

except PGPError:

3213

2283

# If decryption fails, we use secret from new settings

3214

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

3215

client_name))

3216

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

3217

["secret"])

2284

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

2285

.format(client_name))

2286

client["secret"] = (

2287

client_settings[client_name]["secret"])

3218

2288

2289

3219

2290

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

3220

2291

for client_name in (set(old_client_settings)

3221

2292

- set(client_settings)):

3224

2295

- set(old_client_settings)):

3225

2296

clients_data[client_name] = client_settings[client_name]

3226

2297

3227

# Create all client objects

3228

for client_name, client in clients_data.items():

2298

# Create clients all clients

2299

for client_name, client in clients_data.iteritems():

3229

2300

tcp_server.clients[client_name] = client_class(

3230

name=client_name,

3231

settings=client,

3232

server_settings=server_settings)

3233

2301

name = client_name, settings = client)

2302

3234

2303

if not tcp_server.clients:

3235

2304

logger.warning("No clients defined")

3236

3237

if not foreground:

3238

if pidfile is not None:

3239

pid = os.getpid()

3240

try:

3241

with pidfile:

3242

print(pid, file=pidfile)

3243

except IOError:

3244

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

3245

pidfilename, pid)

3246

del pidfile

2305

2306

if not debug:

2307

try:

2308

with pidfile:

2309

pid = os.getpid()

2310

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

2311

del pidfile

2312

except IOError:

2313

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

2314

pidfilename, pid)

2315

except NameError:

2316

# "pidfile" was never created

2317

pass

3247

2318

del pidfilename

3248

3249

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

3250

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3251

lambda: main_loop.quit() and False)

3252

2319

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

2320

2321

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

2322

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

2323

3253

2324

if use_dbus:

3254

3255

@alternate_dbus_interfaces(

3256

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

3257

class MandosDBusService(DBusObjectWithObjectManager):

2325

class MandosDBusService(dbus.service.Object):

3258

2326

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

3259

3260

2327

def __init__(self):

3261

2328

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

3262

3263

2329

_interface = "se.recompile.Mandos"

3264

2330

3265

2331

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

3266

2332

def ClientAdded(self, objpath):

3267

2333

"D-Bus signal"

3268

2334

pass

3269

2335

3270

2336

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

3271

2337

def ClientNotFound(self, fingerprint, address):

3272

2338

"D-Bus signal"

3273

2339

pass

3274

3275

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

3276

"true"})

2340

3277

2341

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

3278

2342

def ClientRemoved(self, objpath, name):

3279

2343

"D-Bus signal"

3280

2344

pass

3281

3282

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

3283

"true"})

2345

3284

2346

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

3285

2347

def GetAllClients(self):

3286

2348

"D-Bus method"

3287

return dbus.Array(c.dbus_object_path for c in

3288

tcp_server.clients.values())

3289

3290

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

3291

"true"})

2349

return dbus.Array(c.dbus_object_path

2350

for c in

2351

tcp_server.clients.itervalues())

2352

3292

2353

@dbus.service.method(_interface,

3293

2354

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

3294

2355

def GetAllClientsWithProperties(self):

3295

2356

"D-Bus method"

3296

2357

return dbus.Dictionary(

3297

{c.dbus_object_path: c.GetAll(

3298

"se.recompile.Mandos.Client")

3299

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

2358

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

2359

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

3300

2360

signature="oa{sv}")

3301

2361

3302

2362

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

3303

2363

def RemoveClient(self, object_path):

3304

2364

"D-Bus method"

3305

for c in tcp_server.clients.values():

2365

for c in tcp_server.clients.itervalues():

3306

2366

if c.dbus_object_path == object_path:

3307

2367

del tcp_server.clients[c.name]

3308

2368

c.remove_from_connection()

3309

# Don't signal the disabling

2369

# Don't signal anything except ClientRemoved

3310

2370

c.disable(quiet=True)

3311

# Emit D-Bus signal for removal

3312

self.client_removed_signal(c)

2371

# Emit D-Bus signal

2372

self.ClientRemoved(object_path, c.name)

3313

2373

return

3314

2374

raise KeyError(object_path)

3315

2375

3316

2376

del _interface

3317

3318

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3319

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

3320

def GetManagedObjects(self):

3321

"""D-Bus method"""

3322

return dbus.Dictionary(

3323

{client.dbus_object_path:

3324

dbus.Dictionary(

3325

{interface: client.GetAll(interface)

3326

for interface in

3327

client._get_all_interface_names()})

3328

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

3329

3330

def client_added_signal(self, client):

3331

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

3332

if use_dbus:

3333

# New standard signal

3334

self.InterfacesAdded(

3335

client.dbus_object_path,

3336

dbus.Dictionary(

3337

{interface: client.GetAll(interface)

3338

for interface in

3339

client._get_all_interface_names()}))

3340

# Old signal

3341

self.ClientAdded(client.dbus_object_path)

3342

3343

def client_removed_signal(self, client):

3344

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

3345

if use_dbus:

3346

# New standard signal

3347

self.InterfacesRemoved(

3348

client.dbus_object_path,

3349

client._get_all_interface_names())

3350

# Old signal

3351

self.ClientRemoved(client.dbus_object_path,

3352

client.name)

3353

3354

mandos_dbus_service = MandosDBusService()

3355

3356

# Save modules to variables to exempt the modules from being

3357

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

3358

mp = multiprocessing

3359

wn = wnull

3360

2377

2378

class MandosDBusServiceTransitional(MandosDBusService):

2379

__metaclass__ = AlternateDBusNamesMetaclass

2380

mandos_dbus_service = MandosDBusServiceTransitional()

2381

3361

2382

def cleanup():

3362

2383

"Cleanup function; run on exit"

3363

if zeroconf:

3364

service.cleanup()

3365

3366

mp.active_children()

3367

wn.close()

2384

service.cleanup()

2385

2386

multiprocessing.active_children()

3368

2387

if not (tcp_server.clients or client_settings):

3369

2388

return

3370

2389

3371

2390

# Store client before exiting. Secrets are encrypted with key

3372

2391

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

3373

2392

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

3374

2393

clients = {}

3375

2394

with PGPEngine() as pgp:

3376

for client in tcp_server.clients.values():

2395

for client in tcp_server.clients.itervalues():

3377

2396

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

3378

2397

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

3379

2398

key)

3380

2399

client_dict = {}

3381

2400

3382

2401

# A list of attributes that can not be pickled

3383

2402

# + secret.

3384

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

3385

"checker", "server_settings"}

3386

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

3387

.Object):

2403

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

2404

"checker"))

2405

for name, typ in (inspect.getmembers

2406

(dbus.service.Object)):

3388

2407

exclude.add(name)

3389

2408

3390

2409

client_dict["encrypted_secret"] = (client

3391

2410

.encrypted_secret)

3392

2411

for attr in client.client_structure:

3393

2412

if attr not in exclude:

3394

2413

client_dict[attr] = getattr(client, attr)

3395

2414

3396

2415

clients[client.name] = client_dict

3397

2416

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

3398

2417

3399

2418

try:

3400

with tempfile.NamedTemporaryFile(

3401

mode='wb',

3402

suffix=".pickle",

3403

prefix='clients-',

3404

dir=os.path.dirname(stored_state_path),

3405

delete=False) as stored_state:

3406

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

3407

protocol=2)

3408

tempname = stored_state.name

2419

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

2420

prefix="clients-",

2421

dir=os.path.dirname

2422

(stored_state_path))

2423

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

2424

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

3409

2425

os.rename(tempname, stored_state_path)

3410

2426

except (IOError, OSError) as e:

2427

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

2428

.format(e))

3411

2429

if not debug:

3412

2430

try:

3413

2431

os.remove(tempname)

3414

2432

except NameError:

3415

2433

pass

3416

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

3417

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

3418

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

3419

else:

3420

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

3421

exc_info=e)

3422

raise

3423

2434

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

2435

errno.EEXIST)):

2436

raise e

2437

3424

2438

# Delete all clients, and settings from config

3425

2439

while tcp_server.clients:

3426

2440

name, client = tcp_server.clients.popitem()

3427

2441

if use_dbus:

3428

2442

client.remove_from_connection()

3429

# Don't signal the disabling

2443

# Don't signal anything except ClientRemoved

3430

2444

client.disable(quiet=True)

3431

# Emit D-Bus signal for removal

3432

2445

if use_dbus:

3433

mandos_dbus_service.client_removed_signal(client)

2446

# Emit D-Bus signal

2447

mandos_dbus_service.ClientRemoved(client

2448

.dbus_object_path,

2449

client.name)

3434

2450

client_settings.clear()

3435

2451

3436

2452

atexit.register(cleanup)

3437

3438

for client in tcp_server.clients.values():

2453

2454

for client in tcp_server.clients.itervalues():

3439

2455

if use_dbus:

3440

# Emit D-Bus signal for adding

3441

mandos_dbus_service.client_added_signal(client)

2456

# Emit D-Bus signal

2457

mandos_dbus_service.ClientAdded(client.dbus_object_path)

3442

2458

# Need to initiate checking of clients

3443

2459

if client.enabled:

3444

2460

client.init_checker()

3445

2461

3446

2462

tcp_server.enable()

3447

2463

tcp_server.server_activate()

3448

2464

3449

2465

# Find out what port we got

3450

if zeroconf:

3451

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

2466

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

3452

2467

if use_ipv6:

3453

2468

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

3454

" flowinfo %d, scope_id %d",

3455

*tcp_server.socket.getsockname())

2469

" flowinfo %d, scope_id %d"

2470

% tcp_server.socket.getsockname())

3456

2471

else: # IPv4

3457

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

3458

*tcp_server.socket.getsockname())

3459

3460

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

3461

2472

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

2473

% tcp_server.socket.getsockname())

2474

2475

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

2476

3462

2477

try:

3463

if zeroconf:

3464

# From the Avahi example code

3465

try:

3466

service.activate()

3467

except dbus.exceptions.DBusException as error:

3468

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

3469

cleanup()

3470

sys.exit(1)

3471

# End of Avahi example code

3472

3473

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

3474

lambda *args, **kwargs:

3475

(tcp_server.handle_request

3476

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

3477

2478

# From the Avahi example code

2479

try:

2480

service.activate()

2481

except dbus.exceptions.DBusException as error:

2482

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

2483

cleanup()

2484

sys.exit(1)

2485

# End of Avahi example code

2486

2487

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

2488

lambda *args, **kwargs:

2489

(tcp_server.handle_request

2490

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

2491

3478

2492

logger.debug("Starting main loop")

3479

2493

main_loop.run()

3480

2494

except AvahiError as error:

3481

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

2495

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

3482

2496

cleanup()

3483

2497

sys.exit(1)

3484

2498

except KeyboardInterrupt:

3489

2503

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

3490

2504

cleanup()

3491

2505

3492

3493

2506

if __name__ == '__main__':

3494

2507

main()