/mandos/release : revision 237.7.295

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

2

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

3

#

3

#

4

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

5

#

5

#

6

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

7

# service publisher, downloaded from

8

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

9

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

10

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

11

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

12

#

12

#

13

# Everything else is

14

15

16

#

17

# This file is part of Mandos.

18

#

19

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

20

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

14

15

16

#

17

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

18

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

21

19

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

22

20

# (at your option) any later version.

23

21

#

24

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

25

# WITHOUT ANY WARRANTY; without even the implied warranty of

22

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

23

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

26

24

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

27

25

# GNU General Public License for more details.

28

#

26

#

29

27

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

30

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

31

#

28

# along with this program. If not, see

29

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

30

#

32

31

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

33

#

32

#

34

33

35

34

from __future__ import (division, absolute_import, print_function,

36

35

unicode_literals)

37

36

38

try:

39

from future_builtins import *

40

except ImportError:

41

pass

37

from future_builtins import *

42

38

43

try:

44

import SocketServer as socketserver

45

except ImportError:

46

import socketserver

39

import SocketServer as socketserver

47

40

import socket

48

41

import argparse

49

42

import datetime

50

43

import errno

51

try:

52

import ConfigParser as configparser

53

except ImportError:

54

import configparser

44

import gnutls.crypto

45

import gnutls.connection

46

import gnutls.errors

47

import gnutls.library.functions

48

import gnutls.library.constants

49

import gnutls.library.types

50

import ConfigParser as configparser

55

51

import sys

56

52

import re

57

53

import os

66

62

import struct

67

63

import fcntl

68

64

import functools

69

try:

70

import cPickle as pickle

71

except ImportError:

72

import pickle

65

import cPickle as pickle

73

66

import multiprocessing

74

67

import types

75

68

import binascii

76

69

import tempfile

77

70

import itertools

78

71

import collections

79

import codecs

80

72

81

73

import dbus

82

74

import dbus.service

83

import gi

84

from gi.repository import GLib

75

import gobject

76

import avahi

85

77

from dbus.mainloop.glib import DBusGMainLoop

86

78

import ctypes

87

79

import ctypes.util

88

80

import xml.dom.minidom

89

81

import inspect

90

82

91

if sys.version_info.major == 2:

92

__metaclass__ = type

93

94

# Try to find the value of SO_BINDTODEVICE:

95

83

try:

96

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

97

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

98

84

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

99

85

except AttributeError:

100

86

try:

101

# This is where SO_BINDTODEVICE was up to and including Python

102

# 2.6, and also 3.2:

103

87

from IN import SO_BINDTODEVICE

104

88

except ImportError:

105

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

106

# Try running the C preprocessor:

107

try:

108

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

109

"/dev/stdin"],

110

stdin=subprocess.PIPE,

111

stdout=subprocess.PIPE)

112

stdout = cc.communicate(

113

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

114

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

115

except (OSError, ValueError, IndexError):

116

# No value found

117

SO_BINDTODEVICE = None

89

SO_BINDTODEVICE = None

118

90

119

91

if sys.version_info.major == 2:

120

92

str = unicode

121

93

122

if sys.version_info < (3, 2):

123

configparser.Configparser = configparser.SafeConfigParser

124

125

version = "1.8.7"

94

version = "1.6.9"

126

95

stored_state_file = "clients.pickle"

127

96

128

97

logger = logging.getLogger()

132

101

if_nametoindex = ctypes.cdll.LoadLibrary(

133

102

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

134

103

except (OSError, AttributeError):

135

104

136

105

def if_nametoindex(interface):

137

106

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

138

107

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

143

112

return interface_index

144

113

145

114

146

def copy_function(func):

147

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

148

if sys.version_info.major == 2:

149

return types.FunctionType(func.func_code,

150

func.func_globals,

151

func.func_name,

152

func.func_defaults,

153

func.func_closure)

154

else:

155

return types.FunctionType(func.__code__,

156

func.__globals__,

157

func.__name__,

158

func.__defaults__,

159

func.__closure__)

160

161

162

115

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

163

116

"""init logger and add loglevel"""

164

117

165

118

global syslogger

166

119

syslogger = (logging.handlers.SysLogHandler(

167

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

168

address="/dev/log"))

120

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

121

address = "/dev/log"))

169

122

syslogger.setFormatter(logging.Formatter

170

123

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

171

124

' %(message)s'))

172

125

logger.addHandler(syslogger)

173

126

174

127

if debug:

175

128

console = logging.StreamHandler()

176

129

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

186

139

pass

187

140

188

141

189

class PGPEngine:

142

class PGPEngine(object):

190

143

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

191

144

192

145

def __init__(self):

193

146

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

194

self.gpg = "gpg"

195

try:

196

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

197

for line in output.splitlines():

198

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

199

if name == "gpg":

200

self.gpg = path

201

break

202

except OSError as e:

203

if e.errno != errno.ENOENT:

204

raise

205

147

self.gnupgargs = ['--batch',

206

'--homedir', self.tempdir,

148

'--home', self.tempdir,

207

149

'--force-mdc',

208

'--quiet']

209

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

210

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

211

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

212

150

'--quiet',

151

'--no-use-agent']

152

213

153

def __enter__(self):

214

154

return self

215

155

216

156

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

217

157

self._cleanup()

218

158

return False

219

159

220

160

def __del__(self):

221

161

self._cleanup()

222

162

223

163

def _cleanup(self):

224

164

if self.tempdir is not None:

225

165

# Delete contents of tempdir

226

166

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

227

topdown=False):

167

topdown = False):

228

168

for filename in files:

229

169

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

230

170

for dirname in dirs:

232

172

# Remove tempdir

233

173

os.rmdir(self.tempdir)

234

174

self.tempdir = None

235

175

236

176

def password_encode(self, password):

237

177

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

238

178

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

243

183

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

244

184

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

245

185

return encoded

246

186

247

187

def encrypt(self, data, password):

248

188

passphrase = self.password_encode(password)

249

189

with tempfile.NamedTemporaryFile(

250

190

dir=self.tempdir) as passfile:

251

191

passfile.write(passphrase)

252

192

passfile.flush()

253

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

193

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

254

194

'--passphrase-file',

255

195

passfile.name]

256

196

+ self.gnupgargs,

257

stdin=subprocess.PIPE,

258

stdout=subprocess.PIPE,

259

stderr=subprocess.PIPE)

260

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

197

stdin = subprocess.PIPE,

198

stdout = subprocess.PIPE,

199

stderr = subprocess.PIPE)

200

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

261

201

if proc.returncode != 0:

262

202

raise PGPError(err)

263

203

return ciphertext

264

204

265

205

def decrypt(self, data, password):

266

206

passphrase = self.password_encode(password)

267

207

with tempfile.NamedTemporaryFile(

268

dir=self.tempdir) as passfile:

208

dir = self.tempdir) as passfile:

269

209

passfile.write(passphrase)

270

210

passfile.flush()

271

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

211

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

272

212

'--passphrase-file',

273

213

passfile.name]

274

214

+ self.gnupgargs,

275

stdin=subprocess.PIPE,

276

stdout=subprocess.PIPE,

277

stderr=subprocess.PIPE)

278

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

215

stdin = subprocess.PIPE,

216

stdout = subprocess.PIPE,

217

stderr = subprocess.PIPE)

218

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

279

219

if proc.returncode != 0:

280

220

raise PGPError(err)

281

221

return decrypted_plaintext

282

222

283

223

284

# Pretend that we have an Avahi module

285

class avahi:

286

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

287

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

288

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

289

PROTO_INET = 0 # avahi-common/address.h

290

PROTO_INET6 = 1 # avahi-common/address.h

291

DBUS_NAME = "org.freedesktop.Avahi"

292

DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"

293

DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"

294

DBUS_PATH_SERVER = "/"

295

296

@staticmethod

297

def string_array_to_txt_array(t):

298

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

299

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

300

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

301

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

302

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

303

SERVER_INVALID = 0 # avahi-common/defs.h

304

SERVER_REGISTERING = 1 # avahi-common/defs.h

305

SERVER_RUNNING = 2 # avahi-common/defs.h

306

SERVER_COLLISION = 3 # avahi-common/defs.h

307

SERVER_FAILURE = 4 # avahi-common/defs.h

308

309

310

224

class AvahiError(Exception):

311

225

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

312

226

self.value = value

322

236

pass

323

237

324

238

325

class AvahiService:

239

class AvahiService(object):

326

240

"""An Avahi (Zeroconf) service.

327

241

328

242

Attributes:

329

243

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

330

244

Used to optionally bind to the specified interface.

342

256

server: D-Bus Server

343

257

bus: dbus.SystemBus()

344

258

"""

345

259

346

260

def __init__(self,

347

interface=avahi.IF_UNSPEC,

348

name=None,

349

servicetype=None,

350

port=None,

351

TXT=None,

352

domain="",

353

host="",

354

max_renames=32768,

355

protocol=avahi.PROTO_UNSPEC,

356

bus=None):

261

interface = avahi.IF_UNSPEC,

262

name = None,

263

servicetype = None,

264

port = None,

265

TXT = None,

266

domain = "",

267

host = "",

268

max_renames = 32768,

269

protocol = avahi.PROTO_UNSPEC,

270

bus = None):

357

271

self.interface = interface

358

272

self.name = name

359

273

self.type = servicetype

368

282

self.server = None

369

283

self.bus = bus

370

284

self.entry_group_state_changed_match = None

371

285

372

286

def rename(self, remove=True):

373

287

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

374

288

if self.rename_count >= self.max_renames:

394

308

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

395

309

self.cleanup()

396

310

os._exit(1)

397

311

398

312

def remove(self):

399

313

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

400

314

if self.entry_group_state_changed_match is not None:

402

316

self.entry_group_state_changed_match = None

403

317

if self.group is not None:

404

318

self.group.Reset()

405

319

406

320

def add(self):

407

321

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

408

322

self.remove()

425

339

dbus.UInt16(self.port),

426

340

avahi.string_array_to_txt_array(self.TXT))

427

341

self.group.Commit()

428

342

429

343

def entry_group_state_changed(self, state, error):

430

344

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

431

345

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

432

346

433

347

if state == avahi.ENTRY_GROUP_ESTABLISHED:

434

348

logger.debug("Zeroconf service established.")

435

349

elif state == avahi.ENTRY_GROUP_COLLISION:

439

353

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

440

354

str(error))

441

355

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

442

356

443

357

def cleanup(self):

444

358

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

445

359

if self.group is not None:

450

364

pass

451

365

self.group = None

452

366

self.remove()

453

367

454

368

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

455

369

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

456

370

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

468

382

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

469

383

self.cleanup()

470

384

elif state == avahi.SERVER_RUNNING:

471

try:

472

self.add()

473

except dbus.exceptions.DBusException as error:

474

if (error.get_dbus_name()

475

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

476

logger.info("Local Zeroconf service name"

477

" collision.")

478

return self.rename(remove=False)

479

else:

480

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

481

self.cleanup()

482

os._exit(1)

385

self.add()

483

386

else:

484

387

if error is None:

485

388

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

486

389

else:

487

390

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

488

391

489

392

def activate(self):

490

393

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

491

394

if self.server is None:

502

405

class AvahiServiceToSyslog(AvahiService):

503

406

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

504

407

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

505

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

408

ret = AvahiService.rename(self, *args, **kwargs)

506

409

syslogger.setFormatter(logging.Formatter(

507

410

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

508

411

.format(self.name)))

509

412

return ret

510

413

511

414

512

# Pretend that we have a GnuTLS module

513

class gnutls:

514

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

515

516

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

517

if library is None:

518

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

519

_library = ctypes.cdll.LoadLibrary(library)

520

del library

521

522

# Unless otherwise indicated, the constants and types below are

523

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

524

525

# Constants

526

E_SUCCESS = 0

527

E_INTERRUPTED = -52

528

E_AGAIN = -28

529

CRT_OPENPGP = 2

530

CRT_RAWPK = 3

531

CLIENT = 2

532

SHUT_RDWR = 0

533

CRD_CERTIFICATE = 1

534

E_NO_CERTIFICATE_FOUND = -49

535

X509_FMT_DER = 0

536

NO_TICKETS = 1<<10

537

ENABLE_RAWPK = 1<<18

538

CTYPE_PEERS = 3

539

KEYID_USE_SHA256 = 1 # gnutls/x509.h

540

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

541

542

# Types

543

class session_int(ctypes.Structure):

544

_fields_ = []

545

session_t = ctypes.POINTER(session_int)

546

547

class certificate_credentials_st(ctypes.Structure):

548

_fields_ = []

549

certificate_credentials_t = ctypes.POINTER(

550

certificate_credentials_st)

551

certificate_type_t = ctypes.c_int

552

553

class datum_t(ctypes.Structure):

554

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

555

('size', ctypes.c_uint)]

556

557

class openpgp_crt_int(ctypes.Structure):

558

_fields_ = []

559

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

560

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

561

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

562

credentials_type_t = ctypes.c_int

563

transport_ptr_t = ctypes.c_void_p

564

close_request_t = ctypes.c_int

565

566

# Exceptions

567

class Error(Exception):

568

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

569

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

570

# code is passed, convert it to a string with

571

# gnutls.strerror()

572

self.code = code

573

if message is None and code is not None:

574

message = gnutls.strerror(code)

575

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

576

message, *args)

577

578

class CertificateSecurityError(Error):

579

pass

580

581

# Classes

582

class Credentials:

583

def __init__(self):

584

self._c_object = gnutls.certificate_credentials_t()

585

gnutls.certificate_allocate_credentials(

586

ctypes.byref(self._c_object))

587

self.type = gnutls.CRD_CERTIFICATE

588

589

def __del__(self):

590

gnutls.certificate_free_credentials(self._c_object)

591

592

class ClientSession:

593

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

594

self._c_object = gnutls.session_t()

595

gnutls_flags = gnutls.CLIENT

596

if gnutls.check_version(b"3.5.6"):

597

gnutls_flags |= gnutls.NO_TICKETS

598

if gnutls.has_rawpk:

599

gnutls_flags |= gnutls.ENABLE_RAWPK

600

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

601

del gnutls_flags

602

gnutls.set_default_priority(self._c_object)

603

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

604

gnutls.handshake_set_private_extensions(self._c_object,

605

True)

606

self.socket = socket

607

if credentials is None:

608

credentials = gnutls.Credentials()

609

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

610

ctypes.cast(credentials._c_object,

611

ctypes.c_void_p))

612

self.credentials = credentials

613

614

def __del__(self):

615

gnutls.deinit(self._c_object)

616

617

def handshake(self):

618

return gnutls.handshake(self._c_object)

619

620

def send(self, data):

621

data = bytes(data)

622

data_len = len(data)

623

while data_len > 0:

624

data_len -= gnutls.record_send(self._c_object,

625

data[-data_len:],

626

data_len)

627

628

def bye(self):

629

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

630

631

# Error handling functions

632

def _error_code(result):

633

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

634

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

635

if result >= 0:

636

return result

637

if result == gnutls.E_NO_CERTIFICATE_FOUND:

638

raise gnutls.CertificateSecurityError(code=result)

639

raise gnutls.Error(code=result)

640

641

def _retry_on_error(result, func, arguments):

642

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

643

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

644

while result < 0:

645

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

646

return _error_code(result)

647

result = func(*arguments)

648

return result

649

650

# Unless otherwise indicated, the function declarations below are

651

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

652

653

# Functions

654

priority_set_direct = _library.gnutls_priority_set_direct

655

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

656

ctypes.POINTER(ctypes.c_char_p)]

657

priority_set_direct.restype = _error_code

658

659

init = _library.gnutls_init

660

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

661

init.restype = _error_code

662

663

set_default_priority = _library.gnutls_set_default_priority

664

set_default_priority.argtypes = [session_t]

665

set_default_priority.restype = _error_code

666

667

record_send = _library.gnutls_record_send

668

record_send.argtypes = [session_t, ctypes.c_void_p,

669

ctypes.c_size_t]

670

record_send.restype = ctypes.c_ssize_t

671

record_send.errcheck = _retry_on_error

672

673

certificate_allocate_credentials = (

674

_library.gnutls_certificate_allocate_credentials)

675

certificate_allocate_credentials.argtypes = [

676

ctypes.POINTER(certificate_credentials_t)]

677

certificate_allocate_credentials.restype = _error_code

678

679

certificate_free_credentials = (

680

_library.gnutls_certificate_free_credentials)

681

certificate_free_credentials.argtypes = [

682

certificate_credentials_t]

683

certificate_free_credentials.restype = None

684

685

handshake_set_private_extensions = (

686

_library.gnutls_handshake_set_private_extensions)

687

handshake_set_private_extensions.argtypes = [session_t,

688

ctypes.c_int]

689

handshake_set_private_extensions.restype = None

690

691

credentials_set = _library.gnutls_credentials_set

692

credentials_set.argtypes = [session_t, credentials_type_t,

693

ctypes.c_void_p]

694

credentials_set.restype = _error_code

695

696

strerror = _library.gnutls_strerror

697

strerror.argtypes = [ctypes.c_int]

698

strerror.restype = ctypes.c_char_p

699

700

certificate_type_get = _library.gnutls_certificate_type_get

701

certificate_type_get.argtypes = [session_t]

702

certificate_type_get.restype = _error_code

703

704

certificate_get_peers = _library.gnutls_certificate_get_peers

705

certificate_get_peers.argtypes = [session_t,

706

ctypes.POINTER(ctypes.c_uint)]

707

certificate_get_peers.restype = ctypes.POINTER(datum_t)

708

709

global_set_log_level = _library.gnutls_global_set_log_level

710

global_set_log_level.argtypes = [ctypes.c_int]

711

global_set_log_level.restype = None

712

713

global_set_log_function = _library.gnutls_global_set_log_function

714

global_set_log_function.argtypes = [log_func]

715

global_set_log_function.restype = None

716

717

deinit = _library.gnutls_deinit

718

deinit.argtypes = [session_t]

719

deinit.restype = None

720

721

handshake = _library.gnutls_handshake

722

handshake.argtypes = [session_t]

723

handshake.restype = _error_code

724

handshake.errcheck = _retry_on_error

725

726

transport_set_ptr = _library.gnutls_transport_set_ptr

727

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

728

transport_set_ptr.restype = None

729

730

bye = _library.gnutls_bye

731

bye.argtypes = [session_t, close_request_t]

732

bye.restype = _error_code

733

bye.errcheck = _retry_on_error

734

735

check_version = _library.gnutls_check_version

736

check_version.argtypes = [ctypes.c_char_p]

737

check_version.restype = ctypes.c_char_p

738

739

_need_version = b"3.3.0"

740

if check_version(_need_version) is None:

741

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

742

.format(_need_version))

743

744

_tls_rawpk_version = b"3.6.6"

745

has_rawpk = bool(check_version(_tls_rawpk_version))

746

747

if has_rawpk:

748

# Types

749

class pubkey_st(ctypes.Structure):

750

_fields = []

751

pubkey_t = ctypes.POINTER(pubkey_st)

752

753

x509_crt_fmt_t = ctypes.c_int

754

755

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

756

pubkey_init = _library.gnutls_pubkey_init

757

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

758

pubkey_init.restype = _error_code

759

760

pubkey_import = _library.gnutls_pubkey_import

761

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

762

x509_crt_fmt_t]

763

pubkey_import.restype = _error_code

764

765

pubkey_get_key_id = _library.gnutls_pubkey_get_key_id

766

pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,

767

ctypes.POINTER(ctypes.c_ubyte),

768

ctypes.POINTER(ctypes.c_size_t)]

769

pubkey_get_key_id.restype = _error_code

770

771

pubkey_deinit = _library.gnutls_pubkey_deinit

772

pubkey_deinit.argtypes = [pubkey_t]

773

pubkey_deinit.restype = None

774

else:

775

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

776

777

openpgp_crt_init = _library.gnutls_openpgp_crt_init

778

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

779

openpgp_crt_init.restype = _error_code

780

781

openpgp_crt_import = _library.gnutls_openpgp_crt_import

782

openpgp_crt_import.argtypes = [openpgp_crt_t,

783

ctypes.POINTER(datum_t),

784

openpgp_crt_fmt_t]

785

openpgp_crt_import.restype = _error_code

786

787

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

788

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

789

ctypes.POINTER(ctypes.c_uint)]

790

openpgp_crt_verify_self.restype = _error_code

791

792

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

793

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

794

openpgp_crt_deinit.restype = None

795

796

openpgp_crt_get_fingerprint = (

797

_library.gnutls_openpgp_crt_get_fingerprint)

798

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

799

ctypes.c_void_p,

800

ctypes.POINTER(

801

ctypes.c_size_t)]

802

openpgp_crt_get_fingerprint.restype = _error_code

803

804

if check_version(b"3.6.4"):

805

certificate_type_get2 = _library.gnutls_certificate_type_get2

806

certificate_type_get2.argtypes = [session_t, ctypes.c_int]

807

certificate_type_get2.restype = _error_code

808

809

# Remove non-public functions

810

del _error_code, _retry_on_error

811

812

813

def call_pipe(connection, # : multiprocessing.Connection

814

func, *args, **kwargs):

815

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

816

817

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

818

return value on the provided multiprocessing.Connection.

819

"""

820

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

821

connection.close()

822

823

824

class Client:

415

class Client(object):

825

416

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

826

417

827

418

Attributes:

828

419

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

829

420

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

830

421

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

831

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

832

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

833

running.

834

checker_callback_tag: a GLib event source tag, or None

422

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

423

to see if the client lives.

424

'None' if no process is running.

425

checker_callback_tag: a gobject event source tag, or None

835

426

checker_command: string; External command which is run to check

836

427

if client lives. %() expansions are done at

837

428

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

838

429

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

839

checker_initiator_tag: a GLib event source tag, or None

430

checker_initiator_tag: a gobject event source tag, or None

840

431

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

841

432

client_structure: Object describing what attributes a client has

842

433

and is used for storing the client at exit

843

434

current_checker_command: string; current running checker_command

844

disable_initiator_tag: a GLib event source tag, or None

435

disable_initiator_tag: a gobject event source tag, or None

845

436

enabled: bool()

846

437

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

847

uniquely identify an OpenPGP client

848

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

849

a client using raw public keys

438

uniquely identify the client

850

439

host: string; available for use by the checker command

851

440

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

852

441

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

854

443

last_checker_status: integer between 0 and 255 reflecting exit

855

444

status of last checker. -1 reflects crashed

856

445

checker, -2 means no checker completed yet.

857

last_checker_signal: The signal which killed the last checker, if

858

last_checker_status is -1

859

446

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

860

447

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

861

448

D-Bus identifiers

868

455

disabled, or None

869

456

server_settings: The server_settings dict from main()

870

457

"""

871

458

872

459

runtime_expansions = ("approval_delay", "approval_duration",

873

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

460

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

874

461

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

875

462

"last_approval_request", "last_checked_ok",

876

463

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

885

472

"approved_by_default": "True",

886

473

"enabled": "True",

887

474

}

888

475

889

476

@staticmethod

890

477

def config_parser(config):

891

478

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

898

485

for client_name in config.sections():

899

486

section = dict(config.items(client_name))

900

487

client = settings[client_name] = {}

901

488

902

489

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

903

490

# Reformat values from string types to Python types

904

491

client["approved_by_default"] = config.getboolean(

905

492

client_name, "approved_by_default")

906

493

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

907

494

"enabled")

908

909

# Uppercase and remove spaces from key_id and fingerprint

910

# for later comparison purposes with return value from the

911

# key_id() and fingerprint() functions

912

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

913

.replace(" ", ""))

495

496

# Uppercase and remove spaces from fingerprint for later

497

# comparison purposes with return value from the

498

# fingerprint() function

914

499

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

915

500

.replace(" ", ""))

916

501

if "secret" in section:

917

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

918

.encode("utf-8"),

919

"base64")

502

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

920

503

elif "secfile" in section:

921

504

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

922

505

(section["secfile"])),

937

520

client["last_approval_request"] = None

938

521

client["last_checked_ok"] = None

939

522

client["last_checker_status"] = -2

940

523

941

524

return settings

942

943

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

525

526

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

944

527

self.name = name

945

528

if server_settings is None:

946

529

server_settings = {}

948

531

# adding all client settings

949

532

for setting, value in settings.items():

950

533

setattr(self, setting, value)

951

534

952

535

if self.enabled:

953

536

if not hasattr(self, "last_enabled"):

954

537

self.last_enabled = datetime.datetime.utcnow()

958

541

else:

959

542

self.last_enabled = None

960

543

self.expires = None

961

544

962

545

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

963

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

964

546

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

965

547

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

966

548

datetime.datetime.utcnow())

967

549

968

550

# attributes specific for this server instance

969

551

self.checker = None

970

552

self.checker_initiator_tag = None

976

558

self.changedstate = multiprocessing_manager.Condition(

977

559

multiprocessing_manager.Lock())

978

560

self.client_structure = [attr

979

for attr in self.__dict__.keys()

561

for attr in self.__dict__.iterkeys()

980

562

if not attr.startswith("_")]

981

563

self.client_structure.append("client_structure")

982

564

983

565

for name, t in inspect.getmembers(

984

566

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

985

567

if not name.startswith("_"):

986

568

self.client_structure.append(name)

987

569

988

570

# Send notice to process children that client state has changed

989

571

def send_changedstate(self):

990

572

with self.changedstate:

991

573

self.changedstate.notify_all()

992

574

993

575

def enable(self):

994

576

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

995

577

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

1000

582

self.last_enabled = datetime.datetime.utcnow()

1001

583

self.init_checker()

1002

584

self.send_changedstate()

1003

585

1004

586

def disable(self, quiet=True):

1005

587

"""Disable this client."""

1006

588

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

1008

590

if not quiet:

1009

591

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

1010

592

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

1011

GLib.source_remove(self.disable_initiator_tag)

593

gobject.source_remove(self.disable_initiator_tag)

1012

594

self.disable_initiator_tag = None

1013

595

self.expires = None

1014

596

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

1015

GLib.source_remove(self.checker_initiator_tag)

597

gobject.source_remove(self.checker_initiator_tag)

1016

598

self.checker_initiator_tag = None

1017

599

self.stop_checker()

1018

600

self.enabled = False

1019

601

if not quiet:

1020

602

self.send_changedstate()

1021

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

603

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

1022

604

return False

1023

605

1024

606

def __del__(self):

1025

607

self.disable()

1026

608

1027

609

def init_checker(self):

1028

610

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

1029

611

# and every interval from then on.

1030

612

if self.checker_initiator_tag is not None:

1031

GLib.source_remove(self.checker_initiator_tag)

1032

self.checker_initiator_tag = GLib.timeout_add(

613

gobject.source_remove(self.checker_initiator_tag)

614

self.checker_initiator_tag = gobject.timeout_add(

1033

615

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

1034

616

self.start_checker)

1035

617

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

1036

618

if self.disable_initiator_tag is not None:

1037

GLib.source_remove(self.disable_initiator_tag)

1038

self.disable_initiator_tag = GLib.timeout_add(

619

gobject.source_remove(self.disable_initiator_tag)

620

self.disable_initiator_tag = gobject.timeout_add(

1039

621

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

1040

622

# Also start a new checker *right now*.

1041

623

self.start_checker()

1042

1043

def checker_callback(self, source, condition, connection,

1044

command):

624

625

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

1045

626

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

1046

# Read return code from connection (see call_pipe)

1047

returncode = connection.recv()

1048

connection.close()

1049

self.checker.join()

1050

627

self.checker_callback_tag = None

1051

628

self.checker = None

1052

1053

if returncode >= 0:

1054

self.last_checker_status = returncode

1055

self.last_checker_signal = None

629

if os.WIFEXITED(condition):

630

self.last_checker_status = os.WEXITSTATUS(condition)

1056

631

if self.last_checker_status == 0:

1057

632

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

1058

633

vars(self))

1061

636

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

1062

637

else:

1063

638

self.last_checker_status = -1

1064

self.last_checker_signal = -returncode

1065

639

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

1066

640

vars(self))

1067

return False

1068

641

1069

642

def checked_ok(self):

1070

643

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

1071

644

self.last_checked_ok = datetime.datetime.utcnow()

1072

645

self.last_checker_status = 0

1073

self.last_checker_signal = None

1074

646

self.bump_timeout()

1075

647

1076

648

def bump_timeout(self, timeout=None):

1077

649

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

1078

650

if timeout is None:

1079

651

timeout = self.timeout

1080

652

if self.disable_initiator_tag is not None:

1081

GLib.source_remove(self.disable_initiator_tag)

653

gobject.source_remove(self.disable_initiator_tag)

1082

654

self.disable_initiator_tag = None

1083

655

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

1084

self.disable_initiator_tag = GLib.timeout_add(

656

self.disable_initiator_tag = gobject.timeout_add(

1085

657

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

1086

658

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

1087

659

1088

660

def need_approval(self):

1089

661

self.last_approval_request = datetime.datetime.utcnow()

1090

662

1091

663

def start_checker(self):

1092

664

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

1093

665

1094

666

If a checker already exists, leave it running and do

1095

667

nothing."""

1096

668

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

1101

673

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

1102

674

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

1103

675

# should be.

1104

1105

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

1106

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

1107

self.checker.join()

1108

self.checker = None

676

677

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

678

try:

679

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

680

except AttributeError:

681

pass

682

except OSError as error:

683

if error.errno != errno.ECHILD:

684

raise

685

else:

686

if pid:

687

logger.warning("Checker was a zombie")

688

gobject.source_remove(self.checker_callback_tag)

689

self.checker_callback(pid, status,

690

self.current_checker_command)

1109

691

# Start a new checker if needed

1110

692

if self.checker is None:

1111

693

# Escape attributes for the shell

1112

694

escaped_attrs = {

1113

695

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

1114

for attr in self.runtime_expansions}

696

for attr in self.runtime_expansions }

1115

697

try:

1116

698

command = self.checker_command % escaped_attrs

1117

699

except TypeError as error:

1120

702

exc_info=error)

1121

703

return True # Try again later

1122

704

self.current_checker_command = command

1123

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

1124

self.name)

1125

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

1126

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

1127

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

1128

# always replaced by /dev/null.)

1129

# The exception is when not debugging but nevertheless

1130

# running in the foreground; use the previously

1131

# created wnull.

1132

popen_args = {"close_fds": True,

1133

"shell": True,

1134

"cwd": "/"}

1135

if (not self.server_settings["debug"]

1136

and self.server_settings["foreground"]):

1137

popen_args.update({"stdout": wnull,

1138

"stderr": wnull})

1139

pipe = multiprocessing.Pipe(duplex=False)

1140

self.checker = multiprocessing.Process(

1141

target=call_pipe,

1142

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

1143

kwargs=popen_args)

1144

self.checker.start()

1145

self.checker_callback_tag = GLib.io_add_watch(

1146

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

1147

self.checker_callback, pipe[0], command)

1148

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

705

try:

706

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

707

self.name)

708

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

709

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

710

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

711

# always replaced by /dev/null.)

712

# The exception is when not debugging but nevertheless

713

# running in the foreground; use the previously

714

# created wnull.

715

popen_args = {}

716

if (not self.server_settings["debug"]

717

and self.server_settings["foreground"]):

718

popen_args.update({"stdout": wnull,

719

"stderr": wnull })

720

self.checker = subprocess.Popen(command,

721

close_fds=True,

722

shell=True,

723

cwd="/",

724

**popen_args)

725

except OSError as error:

726

logger.error("Failed to start subprocess",

727

exc_info=error)

728

return True

729

self.checker_callback_tag = gobject.child_watch_add(

730

self.checker.pid, self.checker_callback, data=command)

731

# The checker may have completed before the gobject

732

# watch was added. Check for this.

733

try:

734

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

735

except OSError as error:

736

if error.errno == errno.ECHILD:

737

# This should never happen

738

logger.error("Child process vanished",

739

exc_info=error)

740

return True

741

raise

742

if pid:

743

gobject.source_remove(self.checker_callback_tag)

744

self.checker_callback(pid, status, command)

745

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

1149

746

return True

1150

747

1151

748

def stop_checker(self):

1152

749

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

1153

750

if self.checker_callback_tag:

1154

GLib.source_remove(self.checker_callback_tag)

751

gobject.source_remove(self.checker_callback_tag)

1155

752

self.checker_callback_tag = None

1156

753

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

1157

754

return

1158

755

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

1159

self.checker.terminate()

756

try:

757

self.checker.terminate()

758

#time.sleep(0.5)

759

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

760

# self.checker.kill()

761

except OSError as error:

762

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

763

raise

1160

764

self.checker = None

1161

765

1162

766

1166

770

byte_arrays=False):

1167

771

"""Decorators for marking methods of a DBusObjectWithProperties to

1168

772

become properties on the D-Bus.

1169

773

1170

774

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

1171

775

and with one argument by "Set".

1172

776

1173

777

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

1174

778

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

1175

779

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

1179

783

if byte_arrays and signature != "ay":

1180

784

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

1181

785

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

1182

786

1183

787

def decorator(func):

1184

788

func._dbus_is_property = True

1185

789

func._dbus_interface = dbus_interface

1188

792

func._dbus_name = func.__name__

1189

793

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

1190

794

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

1191

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

795

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1192

796

return func

1193

797

1194

798

return decorator

1195

799

1196

800

1197

801

def dbus_interface_annotations(dbus_interface):

1198

802

"""Decorator for marking functions returning interface annotations

1199

803

1200

804

Usage:

1201

805

1202

806

@dbus_interface_annotations("org.example.Interface")

1203

807

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

1204

808

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

1205

809

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

1206

810

"false"}

1207

811

"""

1208

812

1209

813

def decorator(func):

1210

814

func._dbus_is_interface = True

1211

815

func._dbus_interface = dbus_interface

1212

816

func._dbus_name = dbus_interface

1213

817

return func

1214

818

1215

819

return decorator

1216

820

1217

821

1218

822

def dbus_annotations(annotations):

1219

823

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

1220

824

Usage:

1221

825

1222

826

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

1223

827

"org.freedesktop.DBus.Property."

1224

828

"EmitsChangedSignal": "false"})

1226

830

access="r")

1227

831

def Property_dbus_property(self):

1228

832

return dbus.Boolean(False)

1229

1230

See also the DBusObjectWithAnnotations class.

1231

833

"""

1232

834

1233

835

def decorator(func):

1234

836

func._dbus_annotations = annotations

1235

837

return func

1236

838

1237

839

return decorator

1238

840

1239

841

1255

857

pass

1256

858

1257

859

1258

class DBusObjectWithAnnotations(dbus.service.Object):

1259

"""A D-Bus object with annotations.

1260

1261

Classes inheriting from this can use the dbus_annotations

1262

decorator to add annotations to methods or signals.

860

class DBusObjectWithProperties(dbus.service.Object):

861

"""A D-Bus object with properties.

862

863

Classes inheriting from this can use the dbus_service_property

864

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

865

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

1263

866

"""

1264

867

1265

868

@staticmethod

1266

869

def _is_dbus_thing(thing):

1267

870

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

1268

871

1269

872

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

1270

873

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

1271

874

"""

1272

875

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

1273

876

False)

1274

877

1275

878

def _get_all_dbus_things(self, thing):

1276

879

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

1277

880

"""

1280

883

for cls in self.__class__.__mro__

1281

884

for name, athing in

1282

885

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

1283

1284

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1285

out_signature="s",

1286

path_keyword='object_path',

1287

connection_keyword='connection')

1288

def Introspect(self, object_path, connection):

1289

"""Overloading of standard D-Bus method.

1290

1291

Inserts annotation tags on methods and signals.

1292

"""

1293

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

1294

connection)

1295

try:

1296

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

1297

1298

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

1299

# Add annotation tags

1300

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

1301

for tag in if_tag.getElementsByTagName(typ):

1302

annots = dict()

1303

for name, prop in (self.

1304

_get_all_dbus_things(typ)):

1305

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

1306

and prop._dbus_interface

1307

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

1308

annots.update(getattr(

1309

prop, "_dbus_annotations", {}))

1310

for name, value in annots.items():

1311

ann_tag = document.createElement(

1312

"annotation")

1313

ann_tag.setAttribute("name", name)

1314

ann_tag.setAttribute("value", value)

1315

tag.appendChild(ann_tag)

1316

# Add interface annotation tags

1317

for annotation, value in dict(

1318

itertools.chain.from_iterable(

1319

annotations().items()

1320

for name, annotations

1321

in self._get_all_dbus_things("interface")

1322

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

1323

)).items():

1324

ann_tag = document.createElement("annotation")

1325

ann_tag.setAttribute("name", annotation)

1326

ann_tag.setAttribute("value", value)

1327

if_tag.appendChild(ann_tag)

1328

# Fix argument name for the Introspect method itself

1329

if (if_tag.getAttribute("name")

1330

== dbus.INTROSPECTABLE_IFACE):

1331

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

1332

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

1333

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

1334

if (arg.getAttribute("direction")

1335

== "out"):

1336

arg.setAttribute("name",

1337

"xml_data")

1338

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

1339

document.unlink()

1340

except (AttributeError, xml.dom.DOMException,

1341

xml.parsers.expat.ExpatError) as error:

1342

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

1343

exc_info=error)

1344

return xmlstring

1345

1346

1347

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1348

"""A D-Bus object with properties.

1349

1350

Classes inheriting from this can use the dbus_service_property

1351

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

1352

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

1353

"""

1354

886

1355

887

def _get_dbus_property(self, interface_name, property_name):

1356

888

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

1357

889

property with the specified name and interface.

1362

894

if (value._dbus_name == property_name

1363

895

and value._dbus_interface == interface_name):

1364

896

return value.__get__(self)

1365

897

1366

898

# No such property

1367

899

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

1368

900

self.dbus_object_path, interface_name, property_name))

1369

1370

@classmethod

1371

def _get_all_interface_names(cls):

1372

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

1373

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

1374

"_dbus_interface", None)

1375

for x in (inspect.getmro(cls))

1376

for attr in dir(x))

1377

if name is not None)

1378

901

1379

902

@dbus.service.method(dbus.PROPERTIES_IFACE,

1380

903

in_signature="ss",

1381

904

out_signature="v")

1389

912

if not hasattr(value, "variant_level"):

1390

913

return value

1391

914

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

1392

915

1393

916

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

1394

917

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

1395

918

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

1407

930

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

1408

931

for byte in value))

1409

932

prop(value)

1410

933

1411

934

@dbus.service.method(dbus.PROPERTIES_IFACE,

1412

935

in_signature="s",

1413

936

out_signature="a{sv}")

1414

937

def GetAll(self, interface_name):

1415

938

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

1416

939

standard.

1417

940

1418

941

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

1419

942

"""

1420

943

properties = {}

1431

954

properties[name] = value

1432

955

continue

1433

956

properties[name] = type(value)(

1434

value, variant_level=value.variant_level + 1)

957

value, variant_level = value.variant_level + 1)

1435

958

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

1436

959

1437

960

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

1438

961

def PropertiesChanged(self, interface_name, changed_properties,

1439

962

invalidated_properties):

1441

964

standard.

1442

965

"""

1443

966

pass

1444

967

1445

968

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1446

969

out_signature="s",

1447

970

path_keyword='object_path',

1448

971

connection_keyword='connection')

1449

972

def Introspect(self, object_path, connection):

1450

973

"""Overloading of standard D-Bus method.

1451

974

1452

975

Inserts property tags and interface annotation tags.

1453

976

"""

1454

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1455

object_path,

1456

connection)

977

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

978

connection)

1457

979

try:

1458

980

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

1459

981

1460

982

def make_tag(document, name, prop):

1461

983

e = document.createElement("property")

1462

984

e.setAttribute("name", name)

1463

985

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

1464

986

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

1465

987

return e

1466

988

1467

989

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

1468

990

# Add property tags

1469

991

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

1472

994

if prop._dbus_interface

1473

995

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

1474

996

if_tag.appendChild(tag)

1475

# Add annotation tags for properties

1476

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

1477

annots = dict()

1478

for name, prop in self._get_all_dbus_things(

1479

"property"):

1480

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

1481

and prop._dbus_interface

1482

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

1483

annots.update(getattr(

1484

prop, "_dbus_annotations", {}))

1485

for name, value in annots.items():

1486

ann_tag = document.createElement(

1487

"annotation")

1488

ann_tag.setAttribute("name", name)

1489

ann_tag.setAttribute("value", value)

1490

tag.appendChild(ann_tag)

997

# Add annotation tags

998

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

999

for tag in if_tag.getElementsByTagName(typ):

1000

annots = dict()

1001

for name, prop in (self.

1002

_get_all_dbus_things(typ)):

1003

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

1004

and prop._dbus_interface

1005

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

1006

annots.update(getattr(

1007

prop, "_dbus_annotations", {}))

1008

for name, value in annots.items():

1009

ann_tag = document.createElement(

1010

"annotation")

1011

ann_tag.setAttribute("name", name)

1012

ann_tag.setAttribute("value", value)

1013

tag.appendChild(ann_tag)

1014

# Add interface annotation tags

1015

for annotation, value in dict(

1016

itertools.chain.from_iterable(

1017

annotations().items()

1018

for name, annotations

1019

in self._get_all_dbus_things("interface")

1020

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

1021

)).items():

1022

ann_tag = document.createElement("annotation")

1023

ann_tag.setAttribute("name", annotation)

1024

ann_tag.setAttribute("value", value)

1025

if_tag.appendChild(ann_tag)

1491

1026

# Add the names to the return values for the

1492

1027

# "org.freedesktop.DBus.Properties" methods

1493

1028

if (if_tag.getAttribute("name")

1512

1047

return xmlstring

1513

1048

1514

1049

1515

try:

1516

dbus.OBJECT_MANAGER_IFACE

1517

except AttributeError:

1518

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

1519

1520

1521

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1522

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

1523

1524

Classes inheriting from this exposes the standard

1525

GetManagedObjects call and the InterfacesAdded and

1526

InterfacesRemoved signals on the standard

1527

"org.freedesktop.DBus.ObjectManager" interface.

1528

1529

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

1530

manually.

1531

"""

1532

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1533

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

1534

def GetManagedObjects(self):

1535

"""This function must be overridden"""

1536

raise NotImplementedError()

1537

1538

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1539

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

1540

def InterfacesAdded(self, object_path, interfaces_and_properties):

1541

pass

1542

1543

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

1544

def InterfacesRemoved(self, object_path, interfaces):

1545

pass

1546

1547

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1548

out_signature="s",

1549

path_keyword='object_path',

1550

connection_keyword='connection')

1551

def Introspect(self, object_path, connection):

1552

"""Overloading of standard D-Bus method.

1553

1554

Override return argument name of GetManagedObjects to be

1555

"objpath_interfaces_and_properties"

1556

"""

1557

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1558

object_path,

1559

connection)

1560

try:

1561

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

1562

1563

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

1564

# Fix argument name for the GetManagedObjects method

1565

if (if_tag.getAttribute("name")

1566

== dbus.OBJECT_MANAGER_IFACE):

1567

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

1568

if (cn.getAttribute("name")

1569

== "GetManagedObjects"):

1570

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

1571

if (arg.getAttribute("direction")

1572

== "out"):

1573

arg.setAttribute(

1574

"name",

1575

"objpath_interfaces"

1576

"_and_properties")

1577

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

1578

document.unlink()

1579

except (AttributeError, xml.dom.DOMException,

1580

xml.parsers.expat.ExpatError) as error:

1581

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

1582

exc_info=error)

1583

return xmlstring

1584

1585

1586

1050

def datetime_to_dbus(dt, variant_level=0):

1587

1051

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

1588

1052

if dt is None:

1589

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

1053

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

1590

1054

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

1591

1055

1592

1056

1595

1059

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

1596

1060

interface names according to the "alt_interface_names" mapping.

1597

1061

Usage:

1598

1062

1599

1063

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

1600

1064

"net.example.AlternateInterface"})

1601

1065

class SampleDBusObject(dbus.service.Object):

1602

1066

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

1603

1067

def SampleDBusMethod():

1604

1068

pass

1605

1069

1606

1070

The above "SampleDBusMethod" on "SampleDBusObject" will be

1607

1071

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

1608

1072

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

1609

1073

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

1610

1074

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

1611

1075

1612

1076

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

1613

1077

(from DBusObjectWithProperties) and interfaces (from the

1614

1078

dbus_interface_annotations decorator).

1615

1079

"""

1616

1080

1617

1081

def wrapper(cls):

1618

1082

for orig_interface_name, alt_interface_name in (

1619

1083

alt_interface_names.items()):

1636

1100

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

1637

1101

# Extract the original non-method undecorated

1638

1102

# function by black magic

1639

if sys.version_info.major == 2:

1640

nonmethod_func = (dict(

1641

zip(attribute.func_code.co_freevars,

1642

attribute.__closure__))

1643

["func"].cell_contents)

1644

else:

1645

nonmethod_func = (dict(

1646

zip(attribute.__code__.co_freevars,

1647

attribute.__closure__))

1648

["func"].cell_contents)

1103

nonmethod_func = (dict(

1104

zip(attribute.func_code.co_freevars,

1105

attribute.__closure__))

1106

["func"].cell_contents)

1649

1107

# Create a new, but exactly alike, function

1650

1108

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

1651

1109

# with the alternate D-Bus interface name

1652

new_function = copy_function(nonmethod_func)

1653

1110

new_function = (dbus.service.signal(

1654

alt_interface,

1655

attribute._dbus_signature)(new_function))

1111

alt_interface, attribute._dbus_signature)

1112

(types.FunctionType(

1113

nonmethod_func.func_code,

1114

nonmethod_func.func_globals,

1115

nonmethod_func.func_name,

1116

nonmethod_func.func_defaults,

1117

nonmethod_func.func_closure)))

1656

1118

# Copy annotations, if any

1657

1119

try:

1658

1120

new_function._dbus_annotations = dict(

1659

1121

attribute._dbus_annotations)

1660

1122

except AttributeError:

1661

1123

pass

1662

1663

1124

# Define a creator of a function to call both the

1664

1125

# original and alternate functions, so both the

1665

1126

# original and alternate signals gets sent when

1668

1129

"""This function is a scope container to pass

1669

1130

func1 and func2 to the "call_both" function

1670

1131

outside of its arguments"""

1671

1672

@functools.wraps(func2)

1132

1673

1133

def call_both(*args, **kwargs):

1674

1134

"""This function will emit two D-Bus

1675

1135

signals by calling func1 and func2"""

1676

1136

func1(*args, **kwargs)

1677

1137

func2(*args, **kwargs)

1678

# Make wrapper function look like a D-Bus

1679

# signal

1680

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

1681

if name.startswith("_dbus_"):

1682

setattr(call_both, name, attr)

1683

1138

1684

1139

return call_both

1685

1140

# Create the "call_both" function and add it to

1686

1141

# the class

1696

1151

alt_interface,

1697

1152

attribute._dbus_in_signature,

1698

1153

attribute._dbus_out_signature)

1699

(copy_function(attribute)))

1154

(types.FunctionType(attribute.func_code,

1155

attribute.func_globals,

1156

attribute.func_name,

1157

attribute.func_defaults,

1158

attribute.func_closure)))

1700

1159

# Copy annotations, if any

1701

1160

try:

1702

1161

attr[attrname]._dbus_annotations = dict(

1714

1173

attribute._dbus_access,

1715

1174

attribute._dbus_get_args_options

1716

1175

["byte_arrays"])

1717

(copy_function(attribute)))

1176

(types.FunctionType(

1177

attribute.func_code,

1178

attribute.func_globals,

1179

attribute.func_name,

1180

attribute.func_defaults,

1181

attribute.func_closure)))

1718

1182

# Copy annotations, if any

1719

1183

try:

1720

1184

attr[attrname]._dbus_annotations = dict(

1729

1193

# to the class.

1730

1194

attr[attrname] = (

1731

1195

dbus_interface_annotations(alt_interface)

1732

(copy_function(attribute)))

1196

(types.FunctionType(attribute.func_code,

1197

attribute.func_globals,

1198

attribute.func_name,

1199

attribute.func_defaults,

1200

attribute.func_closure)))

1733

1201

if deprecate:

1734

1202

# Deprecate all alternate interfaces

1735

iname = "_AlternateDBusNames_interface_annotation{}"

1203

iname="_AlternateDBusNames_interface_annotation{}"

1736

1204

for interface_name in interface_names:

1737

1205

1738

1206

@dbus_interface_annotations(interface_name)

1739

1207

def func(self):

1740

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

1741

"true"}

1208

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

1209

"true" }

1742

1210

# Find an unused name

1743

1211

for aname in (iname.format(i)

1744

1212

for i in itertools.count()):

1748

1216

if interface_names:

1749

1217

# Replace the class with a new subclass of it with

1750

1218

# methods, signals, etc. as created above.

1751

if sys.version_info.major == 2:

1752

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

1753

(cls, ), attr)

1754

else:

1755

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

1756

(cls, ), attr)

1219

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

1220

(cls, ), attr)

1757

1221

return cls

1758

1222

1759

1223

return wrapper

1760

1224

1761

1225

1763

1227

"se.bsnet.fukt.Mandos"})

1764

1228

class ClientDBus(Client, DBusObjectWithProperties):

1765

1229

"""A Client class using D-Bus

1766

1230

1767

1231

Attributes:

1768

1232

dbus_object_path: dbus.ObjectPath

1769

1233

bus: dbus.SystemBus()

1770

1234

"""

1771

1235

1772

1236

runtime_expansions = (Client.runtime_expansions

1773

1237

+ ("dbus_object_path", ))

1774

1238

1775

1239

_interface = "se.recompile.Mandos.Client"

1776

1240

1777

1241

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

1778

1779

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

1242

1243

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

1780

1244

self.bus = bus

1781

1245

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

1782

1246

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

1788

1252

"/clients/" + client_object_name)

1789

1253

DBusObjectWithProperties.__init__(self, self.bus,

1790

1254

self.dbus_object_path)

1791

1255

1792

1256

def notifychangeproperty(transform_func, dbus_name,

1793

1257

type_func=lambda x: x,

1794

1258

variant_level=1,

1796

1260

_interface=_interface):

1797

1261

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

1798

1262

its changes to DBus.

1799

1263

1800

1264

transform_fun: Function that takes a value and a variant_level

1801

1265

and transforms it to a D-Bus type.

1802

1266

dbus_name: D-Bus name of the variable

1805

1269

variant_level: D-Bus variant level. Default: 1

1806

1270

"""

1807

1271

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

1808

1272

1809

1273

def setter(self, value):

1810

1274

if hasattr(self, "dbus_object_path"):

1811

1275

if (not hasattr(self, attrname) or

1818

1282

else:

1819

1283

dbus_value = transform_func(

1820

1284

type_func(value),

1821

variant_level=variant_level)

1285

variant_level = variant_level)

1822

1286

self.PropertyChanged(dbus.String(dbus_name),

1823

1287

dbus_value)

1824

1288

self.PropertiesChanged(

1825

1289

_interface,

1826

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

1827

dbus_value}),

1290

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

1291

dbus_value }),

1828

1292

dbus.Array())

1829

1293

setattr(self, attrname, value)

1830

1294

1831

1295

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

1832

1296

1833

1297

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1834

1298

approvals_pending = notifychangeproperty(dbus.Boolean,

1835

1299

"ApprovalPending",

1836

type_func=bool)

1300

type_func = bool)

1837

1301

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

1838

1302

last_enabled = notifychangeproperty(datetime_to_dbus,

1839

1303

"LastEnabled")

1840

1304

checker = notifychangeproperty(

1841

1305

dbus.Boolean, "CheckerRunning",

1842

type_func=lambda checker: checker is not None)

1306

type_func = lambda checker: checker is not None)

1843

1307

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1844

1308

"LastCheckedOK")

1845

1309

last_checker_status = notifychangeproperty(dbus.Int16,

1850

1314

"ApprovedByDefault")

1851

1315

approval_delay = notifychangeproperty(

1852

1316

dbus.UInt64, "ApprovalDelay",

1853

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

1317

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

1854

1318

approval_duration = notifychangeproperty(

1855

1319

dbus.UInt64, "ApprovalDuration",

1856

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

1320

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

1857

1321

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

1858

1322

timeout = notifychangeproperty(

1859

1323

dbus.UInt64, "Timeout",

1860

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

1324

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

1861

1325

extended_timeout = notifychangeproperty(

1862

1326

dbus.UInt64, "ExtendedTimeout",

1863

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

1327

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

1864

1328

interval = notifychangeproperty(

1865

1329

dbus.UInt64, "Interval",

1866

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

1330

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

1867

1331

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

1868

1332

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

1869

1333

invalidate_only=True)

1870

1334

1871

1335

del notifychangeproperty

1872

1336

1873

1337

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

1874

1338

try:

1875

1339

self.remove_from_connection()

1878

1342

if hasattr(DBusObjectWithProperties, "__del__"):

1879

1343

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

1880

1344

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

1881

1882

def checker_callback(self, source, condition,

1883

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

1884

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

1885

connection, command, *args,

1886

**kwargs)

1887

exitstatus = self.last_checker_status

1888

if exitstatus >= 0:

1345

1346

def checker_callback(self, pid, condition, command,

1347

*args, **kwargs):

1348

self.checker_callback_tag = None

1349

self.checker = None

1350

if os.WIFEXITED(condition):

1351

exitstatus = os.WEXITSTATUS(condition)

1889

1352

# Emit D-Bus signal

1890

1353

self.CheckerCompleted(dbus.Int16(exitstatus),

1891

# This is specific to GNU libC

1892

dbus.Int64(exitstatus << 8),

1354

dbus.Int64(condition),

1893

1355

dbus.String(command))

1894

1356

else:

1895

1357

# Emit D-Bus signal

1896

1358

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

1897

dbus.Int64(

1898

# This is specific to GNU libC

1899

(exitstatus << 8)

1900

| self.last_checker_signal),

1359

dbus.Int64(condition),

1901

1360

dbus.String(command))

1902

return ret

1903

1361

1362

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

1363

*args, **kwargs)

1364

1904

1365

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

1905

1366

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

1906

1367

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

1910

1371

# Emit D-Bus signal

1911

1372

self.CheckerStarted(self.current_checker_command)

1912

1373

return r

1913

1374

1914

1375

def _reset_approved(self):

1915

1376

self.approved = None

1916

1377

return False

1917

1378

1918

1379

def approve(self, value=True):

1919

1380

self.approved = value

1920

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

1921

* 1000), self._reset_approved)

1381

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

1382

* 1000), self._reset_approved)

1922

1383

self.send_changedstate()

1923

1924

# D-Bus methods, signals & properties

1925

1926

# Interfaces

1927

1928

# Signals

1929

1384

1385

## D-Bus methods, signals & properties

1386

1387

## Interfaces

1388

1389

## Signals

1390

1930

1391

# CheckerCompleted - signal

1931

1392

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

1932

1393

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

1933

1394

"D-Bus signal"

1934

1395

pass

1935

1396

1936

1397

# CheckerStarted - signal

1937

1398

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

1938

1399

def CheckerStarted(self, command):

1939

1400

"D-Bus signal"

1940

1401

pass

1941

1402

1942

1403

# PropertyChanged - signal

1943

1404

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

1944

1405

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

1945

1406

def PropertyChanged(self, property, value):

1946

1407

"D-Bus signal"

1947

1408

pass

1948

1409

1949

1410

# GotSecret - signal

1950

1411

@dbus.service.signal(_interface)

1951

1412

def GotSecret(self):

1954

1415

server to mandos-client

1955

1416

"""

1956

1417

pass

1957

1418

1958

1419

# Rejected - signal

1959

1420

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

1960

1421

def Rejected(self, reason):

1961

1422

"D-Bus signal"

1962

1423

pass

1963

1424

1964

1425

# NeedApproval - signal

1965

1426

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

1966

1427

def NeedApproval(self, timeout, default):

1967

1428

"D-Bus signal"

1968

1429

return self.need_approval()

1969

1970

# Methods

1971

1430

1431

## Methods

1432

1972

1433

# Approve - method

1973

1434

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

1974

1435

def Approve(self, value):

1975

1436

self.approve(value)

1976

1437

1977

1438

# CheckedOK - method

1978

1439

@dbus.service.method(_interface)

1979

1440

def CheckedOK(self):

1980

1441

self.checked_ok()

1981

1442

1982

1443

# Enable - method

1983

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

1984

1444

@dbus.service.method(_interface)

1985

1445

def Enable(self):

1986

1446

"D-Bus method"

1987

1447

self.enable()

1988

1448

1989

1449

# StartChecker - method

1990

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

1991

1450

@dbus.service.method(_interface)

1992

1451

def StartChecker(self):

1993

1452

"D-Bus method"

1994

1453

self.start_checker()

1995

1454

1996

1455

# Disable - method

1997

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

1998

1456

@dbus.service.method(_interface)

1999

1457

def Disable(self):

2000

1458

"D-Bus method"

2001

1459

self.disable()

2002

1460

2003

1461

# StopChecker - method

2004

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

2005

1462

@dbus.service.method(_interface)

2006

1463

def StopChecker(self):

2007

1464

self.stop_checker()

2008

2009

# Properties

2010

1465

1466

## Properties

1467

2011

1468

# ApprovalPending - property

2012

1469

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

2013

1470

def ApprovalPending_dbus_property(self):

2014

1471

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

2015

1472

2016

1473

# ApprovedByDefault - property

2017

1474

@dbus_service_property(_interface,

2018

1475

signature="b",

2021

1478

if value is None: # get

2022

1479

return dbus.Boolean(self.approved_by_default)

2023

1480

self.approved_by_default = bool(value)

2024

1481

2025

1482

# ApprovalDelay - property

2026

1483

@dbus_service_property(_interface,

2027

1484

signature="t",

2031

1488

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

2032

1489

* 1000)

2033

1490

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

2034

1491

2035

1492

# ApprovalDuration - property

2036

1493

@dbus_service_property(_interface,

2037

1494

signature="t",

2041

1498

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

2042

1499

* 1000)

2043

1500

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

2044

1501

2045

1502

# Name - property

2046

@dbus_annotations(

2047

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

2048

1503

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

2049

1504

def Name_dbus_property(self):

2050

1505

return dbus.String(self.name)

2051

2052

# KeyID - property

2053

@dbus_annotations(

2054

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

2055

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

2056

def KeyID_dbus_property(self):

2057

return dbus.String(self.key_id)

2058

1506

2059

1507

# Fingerprint - property

2060

@dbus_annotations(

2061

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

2062

1508

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

2063

1509

def Fingerprint_dbus_property(self):

2064

1510

return dbus.String(self.fingerprint)

2065

1511

2066

1512

# Host - property

2067

1513

@dbus_service_property(_interface,

2068

1514

signature="s",

2071

1517

if value is None: # get

2072

1518

return dbus.String(self.host)

2073

1519

self.host = str(value)

2074

1520

2075

1521

# Created - property

2076

@dbus_annotations(

2077

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

2078

1522

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

2079

1523

def Created_dbus_property(self):

2080

1524

return datetime_to_dbus(self.created)

2081

1525

2082

1526

# LastEnabled - property

2083

1527

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

2084

1528

def LastEnabled_dbus_property(self):

2085

1529

return datetime_to_dbus(self.last_enabled)

2086

1530

2087

1531

# Enabled - property

2088

1532

@dbus_service_property(_interface,

2089

1533

signature="b",

2095

1539

self.enable()

2096

1540

else:

2097

1541

self.disable()

2098

1542

2099

1543

# LastCheckedOK - property

2100

1544

@dbus_service_property(_interface,

2101

1545

signature="s",

2105

1549

self.checked_ok()

2106

1550

return

2107

1551

return datetime_to_dbus(self.last_checked_ok)

2108

1552

2109

1553

# LastCheckerStatus - property

2110

1554

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

2111

1555

def LastCheckerStatus_dbus_property(self):

2112

1556

return dbus.Int16(self.last_checker_status)

2113

1557

2114

1558

# Expires - property

2115

1559

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

2116

1560

def Expires_dbus_property(self):

2117

1561

return datetime_to_dbus(self.expires)

2118

1562

2119

1563

# LastApprovalRequest - property

2120

1564

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

2121

1565

def LastApprovalRequest_dbus_property(self):

2122

1566

return datetime_to_dbus(self.last_approval_request)

2123

1567

2124

1568

# Timeout - property

2125

1569

@dbus_service_property(_interface,

2126

1570

signature="t",

2141

1585

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

2142

1586

is None):

2143

1587

return

2144

GLib.source_remove(self.disable_initiator_tag)

2145

self.disable_initiator_tag = GLib.timeout_add(

1588

gobject.source_remove(self.disable_initiator_tag)

1589

self.disable_initiator_tag = gobject.timeout_add(

2146

1590

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

2147

1591

self.disable)

2148

1592

2149

1593

# ExtendedTimeout - property

2150

1594

@dbus_service_property(_interface,

2151

1595

signature="t",

2155

1599

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

2156

1600

* 1000)

2157

1601

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

2158

1602

2159

1603

# Interval - property

2160

1604

@dbus_service_property(_interface,

2161

1605

signature="t",

2168

1612

return

2169

1613

if self.enabled:

2170

1614

# Reschedule checker run

2171

GLib.source_remove(self.checker_initiator_tag)

2172

self.checker_initiator_tag = GLib.timeout_add(

1615

gobject.source_remove(self.checker_initiator_tag)

1616

self.checker_initiator_tag = gobject.timeout_add(

2173

1617

value, self.start_checker)

2174

self.start_checker() # Start one now, too

2175

1618

self.start_checker() # Start one now, too

1619

2176

1620

# Checker - property

2177

1621

@dbus_service_property(_interface,

2178

1622

signature="s",

2181

1625

if value is None: # get

2182

1626

return dbus.String(self.checker_command)

2183

1627

self.checker_command = str(value)

2184

1628

2185

1629

# CheckerRunning - property

2186

1630

@dbus_service_property(_interface,

2187

1631

signature="b",

2193

1637

self.start_checker()

2194

1638

else:

2195

1639

self.stop_checker()

2196

1640

2197

1641

# ObjectPath - property

2198

@dbus_annotations(

2199

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

2200

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

2201

1642

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

2202

1643

def ObjectPath_dbus_property(self):

2203

return self.dbus_object_path # is already a dbus.ObjectPath

2204

1644

return self.dbus_object_path # is already a dbus.ObjectPath

1645

2205

1646

# Secret = property

2206

@dbus_annotations(

2207

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

2208

"invalidates"})

2209

1647

@dbus_service_property(_interface,

2210

1648

signature="ay",

2211

1649

access="write",

2212

1650

byte_arrays=True)

2213

1651

def Secret_dbus_property(self, value):

2214

1652

self.secret = bytes(value)

2215

1653

2216

1654

del _interface

2217

1655

2218

1656

2219

class ProxyClient:

2220

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

1657

class ProxyClient(object):

1658

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

2221

1659

self._pipe = child_pipe

2222

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

1660

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

2223

1661

if not self._pipe.recv():

2224

raise KeyError(key_id or fpr)

2225

1662

raise KeyError()

1663

2226

1664

def __getattribute__(self, name):

2227

1665

if name == '_pipe':

2228

1666

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

2231

1669

if data[0] == 'data':

2232

1670

return data[1]

2233

1671

if data[0] == 'function':

2234

1672

2235

1673

def func(*args, **kwargs):

2236

1674

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

2237

1675

return self._pipe.recv()[1]

2238

1676

2239

1677

return func

2240

1678

2241

1679

def __setattr__(self, name, value):

2242

1680

if name == '_pipe':

2243

1681

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

2246

1684

2247

1685

class ClientHandler(socketserver.BaseRequestHandler, object):

2248

1686

"""A class to handle client connections.

2249

1687

2250

1688

Instantiated once for each connection to handle it.

2251

1689

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

2252

1690

2253

1691

def handle(self):

2254

1692

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

2255

1693

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

2256

1694

str(self.client_address))

2257

1695

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

2258

1696

self.server.child_pipe.fileno())

2259

2260

session = gnutls.ClientSession(self.request)

2261

2262

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

2263

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

2264

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

2265

# "+DHE-DSS"))

1697

1698

session = gnutls.connection.ClientSession(

1699

self.request, gnutls.connection .X509Credentials())

1700

1701

# Note: gnutls.connection.X509Credentials is really a

1702

# generic GnuTLS certificate credentials object so long as

1703

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

1704

# here despite using OpenPGP certificates.

1705

1706

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

1707

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

1708

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

1709

# "+DHE-DSS"))

2266

1710

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

2267

1711

priority = self.server.gnutls_priority

2268

1712

if priority is None:

2269

1713

priority = "NORMAL"

2270

gnutls.priority_set_direct(session._c_object,

2271

priority.encode("utf-8"),

2272

None)

2273

1714

gnutls.library.functions.gnutls_priority_set_direct(

1715

session._c_object, priority, None)

1716

2274

1717

# Start communication using the Mandos protocol

2275

1718

# Get protocol number

2276

1719

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

2281

1724

except (ValueError, IndexError, RuntimeError) as error:

2282

1725

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

2283

1726

return

2284

1727

2285

1728

# Start GnuTLS connection

2286

1729

try:

2287

1730

session.handshake()

2288

except gnutls.Error as error:

1731

except gnutls.errors.GNUTLSError as error:

2289

1732

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

2290

1733

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

2291

1734

# established. Just abandon the request.

2292

1735

return

2293

1736

logger.debug("Handshake succeeded")

2294

1737

2295

1738

approval_required = False

2296

1739

try:

2297

if gnutls.has_rawpk:

2298

fpr = b""

2299

try:

2300

key_id = self.key_id(

2301

self.peer_certificate(session))

2302

except (TypeError, gnutls.Error) as error:

2303

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

2304

return

2305

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

2306

2307

else:

2308

key_id = b""

2309

try:

2310

fpr = self.fingerprint(

2311

self.peer_certificate(session))

2312

except (TypeError, gnutls.Error) as error:

2313

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

2314

return

2315

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

2316

2317

try:

2318

client = ProxyClient(child_pipe, key_id, fpr,

1740

try:

1741

fpr = self.fingerprint(

1742

self.peer_certificate(session))

1743

except (TypeError,

1744

gnutls.errors.GNUTLSError) as error:

1745

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

1746

return

1747

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

1748

1749

try:

1750

client = ProxyClient(child_pipe, fpr,

2319

1751

self.client_address)

2320

1752

except KeyError:

2321

1753

return

2322

1754

2323

1755

if client.approval_delay:

2324

1756

delay = client.approval_delay

2325

1757

client.approvals_pending += 1

2326

1758

approval_required = True

2327

1759

2328

1760

while True:

2329

1761

if not client.enabled:

2330

1762

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

2333

1765

# Emit D-Bus signal

2334

1766

client.Rejected("Disabled")

2335

1767

return

2336

1768

2337

1769

if client.approved or not client.approval_delay:

2338

# We are approved or approval is disabled

1770

#We are approved or approval is disabled

2339

1771

break

2340

1772

elif client.approved is None:

2341

1773

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

2352

1784

# Emit D-Bus signal

2353

1785

client.Rejected("Denied")

2354

1786

return

2355

2356

# wait until timeout or approved

1787

1788

#wait until timeout or approved

2357

1789

time = datetime.datetime.now()

2358

1790

client.changedstate.acquire()

2359

1791

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

2372

1804

break

2373

1805

else:

2374

1806

delay -= time2 - time

2375

2376

try:

2377

session.send(client.secret)

2378

except gnutls.Error as error:

2379

logger.warning("gnutls send failed",

2380

exc_info=error)

2381

return

2382

1807

1808

sent_size = 0

1809

while sent_size < len(client.secret):

1810

try:

1811

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

1812

except gnutls.errors.GNUTLSError as error:

1813

logger.warning("gnutls send failed",

1814

exc_info=error)

1815

return

1816

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

1817

len(client.secret) - (sent_size

1818

+ sent))

1819

sent_size += sent

1820

2383

1821

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

2384

1822

# bump the timeout using extended_timeout

2385

1823

client.bump_timeout(client.extended_timeout)

2386

1824

if self.server.use_dbus:

2387

1825

# Emit D-Bus signal

2388

1826

client.GotSecret()

2389

1827

2390

1828

finally:

2391

1829

if approval_required:

2392

1830

client.approvals_pending -= 1

2393

1831

try:

2394

1832

session.bye()

2395

except gnutls.Error as error:

1833

except gnutls.errors.GNUTLSError as error:

2396

1834

logger.warning("GnuTLS bye failed",

2397

1835

exc_info=error)

2398

1836

2399

1837

@staticmethod

2400

1838

def peer_certificate(session):

2401

"Return the peer's certificate as a bytestring"

2402

try:

2403

cert_type = gnutls.certificate_type_get2(session._c_object,

2404

gnutls.CTYPE_PEERS)

2405

except AttributeError:

2406

cert_type = gnutls.certificate_type_get(session._c_object)

2407

if gnutls.has_rawpk:

2408

valid_cert_types = frozenset((gnutls.CRT_RAWPK,))

2409

else:

2410

valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))

2411

# If not a valid certificate type...

2412

if cert_type not in valid_cert_types:

2413

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

2414

valid_cert_types)

2415

# ...return invalid data

2416

return b""

1839

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

1840

# If not an OpenPGP certificate...

1841

if (gnutls.library.functions.gnutls_certificate_type_get(

1842

session._c_object)

1843

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1844

# ...do the normal thing

1845

return session.peer_certificate

2417

1846

list_size = ctypes.c_uint(1)

2418

cert_list = (gnutls.certificate_get_peers

1847

cert_list = (gnutls.library.functions

1848

.gnutls_certificate_get_peers

2419

1849

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

2420

1850

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

2421

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

1851

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

1852

" certificate")

2422

1853

if list_size.value == 0:

2423

1854

return None

2424

1855

cert = cert_list[0]

2425

1856

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

2426

2427

@staticmethod

2428

def key_id(certificate):

2429

"Convert a certificate bytestring to a hexdigit key ID"

2430

# New GnuTLS "datum" with the public key

2431

datum = gnutls.datum_t(

2432

ctypes.cast(ctypes.c_char_p(certificate),

2433

ctypes.POINTER(ctypes.c_ubyte)),

2434

ctypes.c_uint(len(certificate)))

2435

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

2436

# New empty GnuTLS certificate

2437

pubkey = gnutls.pubkey_t()

2438

gnutls.pubkey_init(ctypes.byref(pubkey))

2439

# Import the raw public key into the certificate

2440

gnutls.pubkey_import(pubkey,

2441

ctypes.byref(datum),

2442

gnutls.X509_FMT_DER)

2443

# New buffer for the key ID

2444

buf = ctypes.create_string_buffer(32)

2445

buf_len = ctypes.c_size_t(len(buf))

2446

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

2447

gnutls.pubkey_get_key_id(pubkey,

2448

gnutls.KEYID_USE_SHA256,

2449

ctypes.cast(ctypes.byref(buf),

2450

ctypes.POINTER(ctypes.c_ubyte)),

2451

ctypes.byref(buf_len))

2452

# Deinit the certificate

2453

gnutls.pubkey_deinit(pubkey)

2454

2455

# Convert the buffer to a Python bytestring

2456

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

2457

# Convert the bytestring to hexadecimal notation

2458

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

2459

return hex_key_id

2460

1857

2461

1858

@staticmethod

2462

1859

def fingerprint(openpgp):

2463

1860

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2464

1861

# New GnuTLS "datum" with the OpenPGP public key

2465

datum = gnutls.datum_t(

1862

datum = gnutls.library.types.gnutls_datum_t(

2466

1863

ctypes.cast(ctypes.c_char_p(openpgp),

2467

1864

ctypes.POINTER(ctypes.c_ubyte)),

2468

1865

ctypes.c_uint(len(openpgp)))

2469

1866

# New empty GnuTLS certificate

2470

crt = gnutls.openpgp_crt_t()

2471

gnutls.openpgp_crt_init(ctypes.byref(crt))

1867

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1868

gnutls.library.functions.gnutls_openpgp_crt_init(

1869

ctypes.byref(crt))

2472

1870

# Import the OpenPGP public key into the certificate

2473

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

2474

gnutls.OPENPGP_FMT_RAW)

1871

gnutls.library.functions.gnutls_openpgp_crt_import(

1872

crt, ctypes.byref(datum),

1873

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

2475

1874

# Verify the self signature in the key

2476

1875

crtverify = ctypes.c_uint()

2477

gnutls.openpgp_crt_verify_self(crt, 0,

2478

ctypes.byref(crtverify))

1876

gnutls.library.functions.gnutls_openpgp_crt_verify_self(

1877

crt, 0, ctypes.byref(crtverify))

2479

1878

if crtverify.value != 0:

2480

gnutls.openpgp_crt_deinit(crt)

2481

raise gnutls.CertificateSecurityError(code

2482

=crtverify.value)

1879

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1880

raise gnutls.errors.CertificateSecurityError(

1881

"Verify failed")

2483

1882

# New buffer for the fingerprint

2484

1883

buf = ctypes.create_string_buffer(20)

2485

1884

buf_len = ctypes.c_size_t()

2486

1885

# Get the fingerprint from the certificate into the buffer

2487

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

2488

ctypes.byref(buf_len))

1886

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(

1887

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

2489

1888

# Deinit the certificate

2490

gnutls.openpgp_crt_deinit(crt)

1889

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2491

1890

# Convert the buffer to a Python bytestring

2492

1891

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

2493

1892

# Convert the bytestring to hexadecimal notation

2495

1894

return hex_fpr

2496

1895

2497

1896

2498

class MultiprocessingMixIn:

1897

class MultiprocessingMixIn(object):

2499

1898

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

2500

1899

2501

1900

def sub_process_main(self, request, address):

2502

1901

try:

2503

1902

self.finish_request(request, address)

2504

1903

except Exception:

2505

1904

self.handle_error(request, address)

2506

1905

self.close_request(request)

2507

1906

2508

1907

def process_request(self, request, address):

2509

1908

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

2510

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

2511

args=(request, address))

1909

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

1910

args = (request, address))

2512

1911

proc.start()

2513

1912

return proc

2514

1913

2515

1914

2516

class MultiprocessingMixInWithPipe(MultiprocessingMixIn):

1915

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2517

1916

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

2518

1917

2519

1918

def process_request(self, request, client_address):

2520

1919

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

2521

1920

2522

1921

This function creates a new pipe in self.pipe

2523

1922

"""

2524

1923

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2525

1924

2526

1925

proc = MultiprocessingMixIn.process_request(self, request,

2527

1926

client_address)

2528

1927

self.child_pipe.close()

2529

1928

self.add_pipe(parent_pipe, proc)

2530

1929

2531

1930

def add_pipe(self, parent_pipe, proc):

2532

1931

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

2533

1932

raise NotImplementedError()

2534

1933

2535

1934

2536

1935

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2537

socketserver.TCPServer):

1936

socketserver.TCPServer, object):

2538

1937

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

2539

1938

2540

1939

Attributes:

2541

1940

enabled: Boolean; whether this server is activated yet

2542

1941

interface: None or a network interface name (string)

2543

1942

use_ipv6: Boolean; to use IPv6 or not

2544

1943

"""

2545

1944

2546

1945

def __init__(self, server_address, RequestHandlerClass,

2547

1946

interface=None,

2548

1947

use_ipv6=True,

2558

1957

self.socketfd = socketfd

2559

1958

# Save the original socket.socket() function

2560

1959

self.socket_socket = socket.socket

2561

2562

1960

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

2563

#

1961

#

2564

1962

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

2565

1963

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

2566

1964

# patching socket.socket.)

2567

#

1965

#

2568

1966

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

2569

1967

@functools.wraps(socket.socket)

2570

1968

def socket_wrapper(*args, **kwargs):

2582

1980

# socket_wrapper(), if socketfd was set.

2583

1981

socketserver.TCPServer.__init__(self, server_address,

2584

1982

RequestHandlerClass)

2585

1983

2586

1984

def server_bind(self):

2587

1985

"""This overrides the normal server_bind() function

2588

1986

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

2589

1987

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

2590

global SO_BINDTODEVICE

2591

1988

if self.interface is not None:

2592

1989

if SO_BINDTODEVICE is None:

2593

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

2594

# common enough.

2595

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

2596

SO_BINDTODEVICE = 25

2597

try:

2598

self.socket.setsockopt(

2599

socket.SOL_SOCKET, SO_BINDTODEVICE,

2600

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

2601

except socket.error as error:

2602

if error.errno == errno.EPERM:

2603

logger.error("No permission to bind to"

2604

" interface %s", self.interface)

2605

elif error.errno == errno.ENOPROTOOPT:

2606

logger.error("SO_BINDTODEVICE not available;"

2607

" cannot bind to interface %s",

2608

self.interface)

2609

elif error.errno == errno.ENODEV:

2610

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

2611

" cannot bind", self.interface)

2612

else:

2613

raise

1990

logger.error("SO_BINDTODEVICE does not exist;"

1991

" cannot bind to interface %s",

1992

self.interface)

1993

else:

1994

try:

1995

self.socket.setsockopt(

1996

socket.SOL_SOCKET, SO_BINDTODEVICE,

1997

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

1998

except socket.error as error:

1999

if error.errno == errno.EPERM:

2000

logger.error("No permission to bind to"

2001

" interface %s", self.interface)

2002

elif error.errno == errno.ENOPROTOOPT:

2003

logger.error("SO_BINDTODEVICE not available;"

2004

" cannot bind to interface %s",

2005

self.interface)

2006

elif error.errno == errno.ENODEV:

2007

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

2008

" cannot bind", self.interface)

2009

else:

2010

raise

2614

2011

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

2615

2012

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

2616

if self.server_address[1]:

2617

self.allow_reuse_address = True

2618

2013

if not self.server_address[0]:

2619

2014

if self.address_family == socket.AF_INET6:

2620

any_address = "::" # in6addr_any

2015

any_address = "::" # in6addr_any

2621

2016

else:

2622

any_address = "0.0.0.0" # INADDR_ANY

2017

any_address = "0.0.0.0" # INADDR_ANY

2623

2018

self.server_address = (any_address,

2624

2019

self.server_address[1])

2625

2020

elif not self.server_address[1]:

2635

2030

2636

2031

class MandosServer(IPv6_TCPServer):

2637

2032

"""Mandos server.

2638

2033

2639

2034

Attributes:

2640

2035

clients: set of Client objects

2641

2036

gnutls_priority GnuTLS priority string

2642

2037

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

2643

2644

Assumes a GLib.MainLoop event loop.

2038

2039

Assumes a gobject.MainLoop event loop.

2645

2040

"""

2646

2041

2647

2042

def __init__(self, server_address, RequestHandlerClass,

2648

2043

interface=None,

2649

2044

use_ipv6=True,

2659

2054

self.gnutls_priority = gnutls_priority

2660

2055

IPv6_TCPServer.__init__(self, server_address,

2661

2056

RequestHandlerClass,

2662

interface=interface,

2663

use_ipv6=use_ipv6,

2664

socketfd=socketfd)

2665

2057

interface = interface,

2058

use_ipv6 = use_ipv6,

2059

socketfd = socketfd)

2060

2666

2061

def server_activate(self):

2667

2062

if self.enabled:

2668

2063

return socketserver.TCPServer.server_activate(self)

2669

2064

2670

2065

def enable(self):

2671

2066

self.enabled = True

2672

2067

2673

2068

def add_pipe(self, parent_pipe, proc):

2674

2069

# Call "handle_ipc" for both data and EOF events

2675

GLib.io_add_watch(

2070

gobject.io_add_watch(

2676

2071

parent_pipe.fileno(),

2677

GLib.IO_IN | GLib.IO_HUP,

2072

gobject.IO_IN | gobject.IO_HUP,

2678

2073

functools.partial(self.handle_ipc,

2679

parent_pipe=parent_pipe,

2680

proc=proc))

2681

2074

parent_pipe = parent_pipe,

2075

proc = proc))

2076

2682

2077

def handle_ipc(self, source, condition,

2683

2078

parent_pipe=None,

2684

proc=None,

2079

proc = None,

2685

2080

client_object=None):

2686

2081

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

2687

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

2082

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

2688

2083

# Wait for other process to exit

2689

2084

proc.join()

2690

2085

return False

2691

2086

2692

2087

# Read a request from the child

2693

2088

request = parent_pipe.recv()

2694

2089

command = request[0]

2695

2090

2696

2091

if command == 'init':

2697

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

2698

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

2699

address = request[3]

2700

2701

for c in self.clients.values():

2702

if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":

2703

continue

2704

if key_id and c.key_id == key_id:

2705

client = c

2706

break

2707

if fpr and c.fingerprint == fpr:

2092

fpr = request[1]

2093

address = request[2]

2094

2095

for c in self.clients.itervalues():

2096

if c.fingerprint == fpr:

2708

2097

client = c

2709

2098

break

2710

2099

else:

2711

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

2712

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

2100

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

2101

"dress: %s", fpr, address)

2713

2102

if self.use_dbus:

2714

2103

# Emit D-Bus signal

2715

mandos_dbus_service.ClientNotFound(key_id or fpr,

2104

mandos_dbus_service.ClientNotFound(fpr,

2716

2105

address[0])

2717

2106

parent_pipe.send(False)

2718

2107

return False

2719

2720

GLib.io_add_watch(

2108

2109

gobject.io_add_watch(

2721

2110

parent_pipe.fileno(),

2722

GLib.IO_IN | GLib.IO_HUP,

2111

gobject.IO_IN | gobject.IO_HUP,

2723

2112

functools.partial(self.handle_ipc,

2724

parent_pipe=parent_pipe,

2725

proc=proc,

2726

client_object=client))

2113

parent_pipe = parent_pipe,

2114

proc = proc,

2115

client_object = client))

2727

2116

parent_pipe.send(True)

2728

2117

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

2729

2118

# same fileno

2732

2121

funcname = request[1]

2733

2122

args = request[2]

2734

2123

kwargs = request[3]

2735

2124

2736

2125

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

2737

2126

funcname)(*args,

2738

2127

**kwargs)))

2739

2128

2740

2129

if command == 'getattr':

2741

2130

attrname = request[1]

2742

if isinstance(client_object.__getattribute__(attrname),

2743

collections.Callable):

2131

if callable(client_object.__getattribute__(attrname)):

2744

2132

parent_pipe.send(('function', ))

2745

2133

else:

2746

2134

parent_pipe.send((

2747

2135

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

2748

2136

2749

2137

if command == 'setattr':

2750

2138

attrname = request[1]

2751

2139

value = request[2]

2752

2140

setattr(client_object, attrname, value)

2753

2141

2754

2142

return True

2755

2143

2756

2144

2757

2145

def rfc3339_duration_to_delta(duration):

2758

2146

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

2759

2147

2760

2148

>>> rfc3339_duration_to_delta("P7D")

2761

2149

datetime.timedelta(7)

2762

2150

>>> rfc3339_duration_to_delta("PT60S")

2772

2160

>>> rfc3339_duration_to_delta("P1DT3M20S")

2773

2161

datetime.timedelta(1, 200)

2774

2162

"""

2775

2163

2776

2164

# Parsing an RFC 3339 duration with regular expressions is not

2777

2165

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

2778

2166

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

2779

2167

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

2780

2168

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

2781

2169

# avoid excessive use of external libraries.

2782

2170

2783

2171

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

2172

Token = collections.namedtuple("Token",

2173

("regexp", # To match token; if

2174

# "value" is not None,

2175

# must have a "group"

2176

# containing digits

2177

"value", # datetime.timedelta or

2178

# None

2179

"followers")) # Tokens valid after

2180

# this token

2784

2181

Token = collections.namedtuple("Token", (

2785

2182

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

2786

2183

# a "group" containing digits

2818

2215

frozenset((token_year, token_month,

2819

2216

token_day, token_time,

2820

2217

token_week)))

2821

# Define starting values:

2822

# Value so far

2823

value = datetime.timedelta()

2218

# Define starting values

2219

value = datetime.timedelta() # Value so far

2824

2220

found_token = None

2825

# Following valid tokens

2826

followers = frozenset((token_duration, ))

2827

# String left to parse

2828

s = duration

2221

followers = frozenset((token_duration,)) # Following valid tokens

2222

s = duration # String left to parse

2829

2223

# Loop until end token is found

2830

2224

while found_token is not token_end:

2831

2225

# Search for any currently valid tokens

2847

2241

break

2848

2242

else:

2849

2243

# No currently valid tokens were found

2850

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

2851

.format(duration))

2244

raise ValueError("Invalid RFC 3339 duration")

2852

2245

# End token found

2853

2246

return value

2854

2247

2855

2248

2856

2249

def string_to_delta(interval):

2857

2250

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

2858

2251

2859

2252

>>> string_to_delta('7d')

2860

2253

datetime.timedelta(7)

2861

2254

>>> string_to_delta('60s')

2869

2262

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

2870

2263

datetime.timedelta(0, 330)

2871

2264

"""

2872

2265

2873

2266

try:

2874

2267

return rfc3339_duration_to_delta(interval)

2875

2268

except ValueError:

2876

2269

pass

2877

2270

2878

2271

timevalue = datetime.timedelta(0)

2879

2272

for s in interval.split():

2880

2273

try:

2898

2291

return timevalue

2899

2292

2900

2293

2901

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

2294

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

2902

2295

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

2903

2296

2904

2297

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

2905

2298

if os.fork():

2906

2299

sys.exit()

2924

2317

2925

2318

2926

2319

def main():

2927

2320

2928

2321

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

2929

2322

# Parsing of options, both command line and config file

2930

2323

2931

2324

parser = argparse.ArgumentParser()

2932

2325

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

2933

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

2326

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

2934

2327

help="show version number and exit")

2935

2328

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

2936

2329

help="Bind to interface IF")

2972

2365

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

2973

2366

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

2974

2367

default=None)

2975

2368

2976

2369

options = parser.parse_args()

2977

2370

2978

2371

if options.check:

2979

2372

import doctest

2980

2373

fail_count, test_count = doctest.testmod()

2981

2374

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

2982

2375

2983

2376

# Default values for config file for server-global settings

2984

if gnutls.has_rawpk:

2985

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

2986

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

2987

else:

2988

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

2989

":+SIGN-DSA-SHA256")

2990

server_defaults = {"interface": "",

2991

"address": "",

2992

"port": "",

2993

"debug": "False",

2994

"priority": priority,

2995

"servicename": "Mandos",

2996

"use_dbus": "True",

2997

"use_ipv6": "True",

2998

"debuglevel": "",

2999

"restore": "True",

3000

"socket": "",

3001

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

3002

"foreground": "False",

3003

"zeroconf": "True",

3004

}

3005

del priority

3006

2377

server_defaults = { "interface": "",

2378

"address": "",

2379

"port": "",

2380

"debug": "False",

2381

"priority":

2382

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

2383

":+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

2384

"servicename": "Mandos",

2385

"use_dbus": "True",

2386

"use_ipv6": "True",

2387

"debuglevel": "",

2388

"restore": "True",

2389

"socket": "",

2390

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

2391

"foreground": "False",

2392

"zeroconf": "True",

2393

}

2394

3007

2395

# Parse config file for server-global settings

3008

server_config = configparser.ConfigParser(server_defaults)

2396

server_config = configparser.SafeConfigParser(server_defaults)

3009

2397

del server_defaults

3010

2398

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

3011

# Convert the ConfigParser object to a dict

2399

# Convert the SafeConfigParser object to a dict

3012

2400

server_settings = server_config.defaults()

3013

2401

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

3014

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

3015

"foreground", "zeroconf"):

2402

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

3016

2403

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

3017

2404

option)

3018

2405

if server_settings["port"]:

3028

2415

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

3029

2416

["socket"])

3030

2417

del server_config

3031

2418

3032

2419

# Override the settings from the config file with command line

3033

2420

# options, if set.

3034

2421

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

3052

2439

if server_settings["debug"]:

3053

2440

server_settings["foreground"] = True

3054

2441

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

3055

2442

3056

2443

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

3057

2444

3058

2445

if (not server_settings["zeroconf"]

3059

2446

and not (server_settings["port"]

3060

2447

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

3061

2448

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

3062

2449

3063

2450

# For convenience

3064

2451

debug = server_settings["debug"]

3065

2452

debuglevel = server_settings["debuglevel"]

3069

2456

stored_state_file)

3070

2457

foreground = server_settings["foreground"]

3071

2458

zeroconf = server_settings["zeroconf"]

3072

2459

3073

2460

if debug:

3074

2461

initlogger(debug, logging.DEBUG)

3075

2462

else:

3078

2465

else:

3079

2466

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

3080

2467

initlogger(debug, level)

3081

2468

3082

2469

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

3083

2470

syslogger.setFormatter(

3084

2471

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

3085

2472

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

3086

2473

server_settings["servicename"])))

3087

2474

3088

2475

# Parse config file with clients

3089

client_config = configparser.ConfigParser(Client.client_defaults)

2476

client_config = configparser.SafeConfigParser(Client

2477

.client_defaults)

3090

2478

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

3091

2479

"clients.conf"))

3092

2480

3093

2481

global mandos_dbus_service

3094

2482

mandos_dbus_service = None

3095

2483

3096

2484

socketfd = None

3097

2485

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

3098

2486

socketfd = server_settings["socket"]

3110

2498

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

3111

2499

pidfile = None

3112

2500

try:

3113

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

2501

pidfile = open(pidfilename, "w")

3114

2502

except IOError as e:

3115

2503

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

3116

2504

exc_info=e)

3117

3118

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

3119

("mandos", "mandos"),

3120

("nobody", "nogroup")):

2505

2506

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

3121

2507

try:

3122

2508

uid = pwd.getpwnam(name).pw_uid

3123

gid = pwd.getpwnam(group).pw_gid

2509

gid = pwd.getpwnam(name).pw_gid

3124

2510

break

3125

2511

except KeyError:

3126

2512

continue

3130

2516

try:

3131

2517

os.setgid(gid)

3132

2518

os.setuid(uid)

3133

if debug:

3134

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

3135

gid))

3136

2519

except OSError as error:

3137

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

3138

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

3139

2520

if error.errno != errno.EPERM:

3140

2521

raise

3141

2522

3142

2523

if debug:

3143

2524

# Enable all possible GnuTLS debugging

3144

2525

3145

2526

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

3146

2527

# - GnuTLS manual

3147

gnutls.global_set_log_level(11)

3148

3149

@gnutls.log_func

2528

gnutls.library.functions.gnutls_global_set_log_level(11)

2529

2530

@gnutls.library.types.gnutls_log_func

3150

2531

def debug_gnutls(level, string):

3151

2532

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

3152

3153

gnutls.global_set_log_function(debug_gnutls)

3154

2533

2534

gnutls.library.functions.gnutls_global_set_log_function(

2535

debug_gnutls)

2536

3155

2537

# Redirect stdin so all checkers get /dev/null

3156

2538

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

3157

2539

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

3158

2540

if null > 2:

3159

2541

os.close(null)

3160

2542

3161

2543

# Need to fork before connecting to D-Bus

3162

2544

if not foreground:

3163

2545

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

3164

2546

daemon()

3165

3166

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

3167

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

3168

# need to inform GLib that threads will be used.

3169

GLib.threads_init()

3170

2547

2548

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

2549

# need to inform gobject that threads will be used.

2550

gobject.threads_init()

2551

3171

2552

global main_loop

3172

2553

# From the Avahi example code

3173

2554

DBusGMainLoop(set_as_default=True)

3174

main_loop = GLib.MainLoop()

2555

main_loop = gobject.MainLoop()

3175

2556

bus = dbus.SystemBus()

3176

2557

# End of Avahi example code

3177

2558

if use_dbus:

3182

2563

old_bus_name = dbus.service.BusName(

3183

2564

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

3184

2565

do_not_queue=True)

3185

except dbus.exceptions.DBusException as e:

2566

except dbus.exceptions.NameExistsException as e:

3186

2567

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

3187

2568

use_dbus = False

3188

2569

server_settings["use_dbus"] = False

3190

2571

if zeroconf:

3191

2572

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3192

2573

service = AvahiServiceToSyslog(

3193

name=server_settings["servicename"],

3194

servicetype="_mandos._tcp",

3195

protocol=protocol,

3196

bus=bus)

2574

name = server_settings["servicename"],

2575

servicetype = "_mandos._tcp",

2576

protocol = protocol,

2577

bus = bus)

3197

2578

if server_settings["interface"]:

3198

2579

service.interface = if_nametoindex(

3199

2580

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

3200

2581

3201

2582

global multiprocessing_manager

3202

2583

multiprocessing_manager = multiprocessing.Manager()

3203

2584

3204

2585

client_class = Client

3205

2586

if use_dbus:

3206

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

3207

2587

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

2588

3208

2589

client_settings = Client.config_parser(client_config)

3209

2590

old_client_settings = {}

3210

2591

clients_data = {}

3211

2592

3212

2593

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

3213

2594

global wnull

3214

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

2595

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

3215

2596

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

3216

2597

# mode

3217

2598

if debug or not foreground:

3218

2599

wnull.close()

3219

2600

3220

2601

# Get client data and settings from last running state.

3221

2602

if server_settings["restore"]:

3222

2603

try:

3223

2604

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

3224

if sys.version_info.major == 2:

3225

clients_data, old_client_settings = pickle.load(

3226

stored_state)

3227

else:

3228

bytes_clients_data, bytes_old_client_settings = (

3229

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

3230

# Fix bytes to strings

3231

# clients_data

3232

# .keys()

3233

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

3234

if isinstance(key, bytes)

3235

else key): value

3236

for key, value in

3237

bytes_clients_data.items()}

3238

del bytes_clients_data

3239

for key in clients_data:

3240

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

3241

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

3242

for k, v in

3243

clients_data[key].items()}

3244

clients_data[key] = value

3245

# .client_structure

3246

value["client_structure"] = [

3247

(s.decode("utf-8")

3248

if isinstance(s, bytes)

3249

else s) for s in

3250

value["client_structure"]]

3251

# .name & .host

3252

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

3253

if isinstance(value[k], bytes):

3254

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

3255

if "key_id" not in value:

3256

value["key_id"] = ""

3257

elif "fingerprint" not in value:

3258

value["fingerprint"] = ""

3259

# old_client_settings

3260

# .keys()

3261

old_client_settings = {

3262

(key.decode("utf-8")

3263

if isinstance(key, bytes)

3264

else key): value

3265

for key, value in

3266

bytes_old_client_settings.items()}

3267

del bytes_old_client_settings

3268

# .host

3269

for value in old_client_settings.values():

3270

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

3271

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

3272

.decode("utf-8"))

2605

clients_data, old_client_settings = pickle.load(

2606

stored_state)

3273

2607

os.remove(stored_state_path)

3274

2608

except IOError as e:

3275

2609

if e.errno == errno.ENOENT:

3283

2617

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

3284

2618

"EOFError:",

3285

2619

exc_info=e)

3286

2620

3287

2621

with PGPEngine() as pgp:

3288

2622

for client_name, client in clients_data.items():

3289

2623

# Skip removed clients

3290

2624

if client_name not in client_settings:

3291

2625

continue

3292

2626

3293

2627

# Decide which value to use after restoring saved state.

3294

2628

# We have three different values: Old config file,

3295

2629

# new config file, and saved state.

3306

2640

client[name] = value

3307

2641

except KeyError:

3308

2642

pass

3309

2643

3310

2644

# Clients who has passed its expire date can still be

3311

# enabled if its last checker was successful. A Client

2645

# enabled if its last checker was successful. Clients

3312

2646

# whose checker succeeded before we stored its state is

3313

2647

# assumed to have successfully run all checkers during

3314

2648

# downtime.

3345

2679

client_name))

3346

2680

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

3347

2681

["secret"])

3348

2682

3349

2683

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

3350

2684

for client_name in (set(old_client_settings)

3351

2685

- set(client_settings)):

3353

2687

for client_name in (set(client_settings)

3354

2688

- set(old_client_settings)):

3355

2689

clients_data[client_name] = client_settings[client_name]

3356

2690

3357

2691

# Create all client objects

3358

2692

for client_name, client in clients_data.items():

3359

2693

tcp_server.clients[client_name] = client_class(

3360

name=client_name,

3361

settings=client,

3362

server_settings=server_settings)

3363

2694

name = client_name,

2695

settings = client,

2696

server_settings = server_settings)

2697

3364

2698

if not tcp_server.clients:

3365

2699

logger.warning("No clients defined")

3366

2700

3367

2701

if not foreground:

3368

2702

if pidfile is not None:

3369

pid = os.getpid()

3370

2703

try:

3371

2704

with pidfile:

3372

print(pid, file=pidfile)

2705

pid = os.getpid()

2706

pidfile.write("{}\n".format(pid).encode("utf-8"))

3373

2707

except IOError:

3374

2708

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

3375

2709

pidfilename, pid)

3376

2710

del pidfile

3377

2711

del pidfilename

3378

3379

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

3380

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3381

lambda: main_loop.quit() and False)

3382

2712

2713

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

2714

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

2715

3383

2716

if use_dbus:

3384

2717

3385

2718

@alternate_dbus_interfaces(

3386

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

3387

class MandosDBusService(DBusObjectWithObjectManager):

2719

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

2720

class MandosDBusService(DBusObjectWithProperties):

3388

2721

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

3389

2722

3390

2723

def __init__(self):

3391

2724

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

3392

2725

3393

2726

_interface = "se.recompile.Mandos"

3394

2727

2728

@dbus_interface_annotations(_interface)

2729

def _foo(self):

2730

return {

2731

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

2732

"false" }

2733

3395

2734

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

3396

2735

def ClientAdded(self, objpath):

3397

2736

"D-Bus signal"

3398

2737

pass

3399

2738

3400

2739

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

3401

def ClientNotFound(self, key_id, address):

2740

def ClientNotFound(self, fingerprint, address):

3402

2741

"D-Bus signal"

3403

2742

pass

3404

3405

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

3406

"true"})

2743

3407

2744

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

3408

2745

def ClientRemoved(self, objpath, name):

3409

2746

"D-Bus signal"

3410

2747

pass

3411

3412

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

3413

"true"})

2748

3414

2749

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

3415

2750

def GetAllClients(self):

3416

2751

"D-Bus method"

3417

2752

return dbus.Array(c.dbus_object_path for c in

3418

tcp_server.clients.values())

3419

3420

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

3421

"true"})

2753

tcp_server.clients.itervalues())

2754

3422

2755

@dbus.service.method(_interface,

3423

2756

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

3424

2757

def GetAllClientsWithProperties(self):

3425

2758

"D-Bus method"

3426

2759

return dbus.Dictionary(

3427

{c.dbus_object_path: c.GetAll(

3428

"se.recompile.Mandos.Client")

3429

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

2760

{ c.dbus_object_path: c.GetAll("")

2761

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

3430

2762

signature="oa{sv}")

3431

2763

3432

2764

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

3433

2765

def RemoveClient(self, object_path):

3434

2766

"D-Bus method"

3435

for c in tcp_server.clients.values():

2767

for c in tcp_server.clients.itervalues():

3436

2768

if c.dbus_object_path == object_path:

3437

2769

del tcp_server.clients[c.name]

3438

2770

c.remove_from_connection()

3439

# Don't signal the disabling

2771

# Don't signal anything except ClientRemoved

3440

2772

c.disable(quiet=True)

3441

# Emit D-Bus signal for removal

3442

self.client_removed_signal(c)

2773

# Emit D-Bus signal

2774

self.ClientRemoved(object_path, c.name)

3443

2775

return

3444

2776

raise KeyError(object_path)

3445

2777

3446

2778

del _interface

3447

3448

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3449

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

3450

def GetManagedObjects(self):

3451

"""D-Bus method"""

3452

return dbus.Dictionary(

3453

{client.dbus_object_path:

3454

dbus.Dictionary(

3455

{interface: client.GetAll(interface)

3456

for interface in

3457

client._get_all_interface_names()})

3458

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

3459

3460

def client_added_signal(self, client):

3461

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

3462

if use_dbus:

3463

# New standard signal

3464

self.InterfacesAdded(

3465

client.dbus_object_path,

3466

dbus.Dictionary(

3467

{interface: client.GetAll(interface)

3468

for interface in

3469

client._get_all_interface_names()}))

3470

# Old signal

3471

self.ClientAdded(client.dbus_object_path)

3472

3473

def client_removed_signal(self, client):

3474

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

3475

if use_dbus:

3476

# New standard signal

3477

self.InterfacesRemoved(

3478

client.dbus_object_path,

3479

client._get_all_interface_names())

3480

# Old signal

3481

self.ClientRemoved(client.dbus_object_path,

3482

client.name)

3483

2779

3484

2780

mandos_dbus_service = MandosDBusService()

3485

3486

# Save modules to variables to exempt the modules from being

3487

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

3488

mp = multiprocessing

3489

wn = wnull

3490

2781

3491

2782

def cleanup():

3492

2783

"Cleanup function; run on exit"

3493

2784

if zeroconf:

3494

2785

service.cleanup()

3495

3496

mp.active_children()

3497

wn.close()

2786

2787

multiprocessing.active_children()

2788

wnull.close()

3498

2789

if not (tcp_server.clients or client_settings):

3499

2790

return

3500

2791

3501

2792

# Store client before exiting. Secrets are encrypted with key

3502

2793

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

3503

2794

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

3504

2795

clients = {}

3505

2796

with PGPEngine() as pgp:

3506

for client in tcp_server.clients.values():

2797

for client in tcp_server.clients.itervalues():

3507

2798

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

3508

2799

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

3509

2800

key)

3510

2801

client_dict = {}

3511

2802

3512

2803

# A list of attributes that can not be pickled

3513

2804

# + secret.

3514

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

3515

"checker", "server_settings"}

2805

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

2806

"checker", "server_settings" }

3516

2807

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

3517

2808

.Object):

3518

2809

exclude.add(name)

3519

2810

3520

2811

client_dict["encrypted_secret"] = (client

3521

2812

.encrypted_secret)

3522

2813

for attr in client.client_structure:

3523

2814

if attr not in exclude:

3524

2815

client_dict[attr] = getattr(client, attr)

3525

2816

3526

2817

clients[client.name] = client_dict

3527

2818

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

3528

2819

3529

2820

try:

3530

2821

with tempfile.NamedTemporaryFile(

3531

2822

mode='wb',

3533

2824

prefix='clients-',

3534

2825

dir=os.path.dirname(stored_state_path),

3535

2826

delete=False) as stored_state:

3536

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

3537

protocol=2)

2827

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

3538

2828

tempname = stored_state.name

3539

2829

os.rename(tempname, stored_state_path)

3540

2830

except (IOError, OSError) as e:

3550

2840

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

3551

2841

exc_info=e)

3552

2842

raise

3553

2843

3554

2844

# Delete all clients, and settings from config

3555

2845

while tcp_server.clients:

3556

2846

name, client = tcp_server.clients.popitem()

3557

2847

if use_dbus:

3558

2848

client.remove_from_connection()

3559

# Don't signal the disabling

2849

# Don't signal anything except ClientRemoved

3560

2850

client.disable(quiet=True)

3561

# Emit D-Bus signal for removal

3562

2851

if use_dbus:

3563

mandos_dbus_service.client_removed_signal(client)

2852

# Emit D-Bus signal

2853

mandos_dbus_service.ClientRemoved(

2854

client.dbus_object_path, client.name)

3564

2855

client_settings.clear()

3565

2856

3566

2857

atexit.register(cleanup)

3567

3568

for client in tcp_server.clients.values():

2858

2859

for client in tcp_server.clients.itervalues():

3569

2860

if use_dbus:

3570

# Emit D-Bus signal for adding

3571

mandos_dbus_service.client_added_signal(client)

2861

# Emit D-Bus signal

2862

mandos_dbus_service.ClientAdded(client.dbus_object_path)

3572

2863

# Need to initiate checking of clients

3573

2864

if client.enabled:

3574

2865

client.init_checker()

3575

2866

3576

2867

tcp_server.enable()

3577

2868

tcp_server.server_activate()

3578

2869

3579

2870

# Find out what port we got

3580

2871

if zeroconf:

3581

2872

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

3586

2877

else: # IPv4

3587

2878

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

3588

2879

*tcp_server.socket.getsockname())

3589

3590

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

3591

2880

2881

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

2882

3592

2883

try:

3593

2884

if zeroconf:

3594

2885

# From the Avahi example code

3599

2890

cleanup()

3600

2891

sys.exit(1)

3601

2892

# End of Avahi example code

3602

3603

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

3604

lambda *args, **kwargs:

3605

(tcp_server.handle_request

3606

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

3607

2893

2894

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

2895

lambda *args, **kwargs:

2896

(tcp_server.handle_request

2897

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

2898

3608

2899

logger.debug("Starting main loop")

3609

2900

main_loop.run()

3610

2901

except AvahiError as error: