/mandos/release : revision 237.7.810

1

#!/usr/bin/python

2

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

3

#

1

#!/usr/bin/python3 -bI

2

# -*- coding: utf-8; lexical-binding: t -*-

3

#

4

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

5

#

5

#

6

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

7

# service publisher, downloaded from

8

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

9

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

10

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

11

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

12

#

12

#

13

# Everything else is

14

15

16

#

17

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

18

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

14

15

16

#

17

# This file is part of Mandos.

18

#

19

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

20

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

19

21

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

20

22

# (at your option) any later version.

21

23

#

22

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

23

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

24

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

25

# WITHOUT ANY WARRANTY; without even the implied warranty of

24

26

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

25

27

# GNU General Public License for more details.

26

#

28

#

27

29

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

28

# along with this program. If not, see

29

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

30

#

30

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

31

#

31

32

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

32

#

33

#

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

39

except ImportError:

40

pass

41

42

import sys

43

import unittest

44

import argparse

45

import logging

46

import os

42

47

try:

43

48

import SocketServer as socketserver

44

49

except ImportError:

45

50

import socketserver

46

51

import socket

47

import argparse

48

52

import datetime

49

53

import errno

50

54

try:

51

55

import ConfigParser as configparser

52

56

except ImportError:

53

57

import configparser

54

import sys

55

58

import re

56

import os

57

59

import signal

58

60

import subprocess

59

61

import atexit

60

62

import stat

61

import logging

62

63

import logging.handlers

63

64

import pwd

64

65

import contextlib

76

77

import itertools

77

78

import collections

78

79

import codecs

80

import random

81

import shlex

79

82

80

83

import dbus

81

84

import dbus.service

82

try:

83

from gi.repository import GObject

84

except ImportError:

85

import gobject as GObject

85

import gi

86

from gi.repository import GLib

86

87

from dbus.mainloop.glib import DBusGMainLoop

87

88

import ctypes

88

89

import ctypes.util

89

90

import xml.dom.minidom

90

91

import inspect

91

92

try:

93

if sys.version_info.major == 2:

94

__metaclass__ = type

95

str = unicode

96

input = raw_input

97

98

# Add collections.abc.Callable if it does not exist

99

try:

100

collections.abc.Callable

101

except AttributeError:

102

class abc:

103

Callable = collections.Callable

104

collections.abc = abc

105

del abc

106

107

# Add shlex.quote if it does not exist

108

try:

109

shlex.quote

110

except AttributeError:

111

shlex.quote = re.escape

112

113

# Show warnings by default

114

if not sys.warnoptions:

115

import warnings

116

warnings.simplefilter("default")

117

118

# Try to find the value of SO_BINDTODEVICE:

119

try:

120

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

121

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

93

122

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

94

123

except AttributeError:

95

124

try:

125

# This is where SO_BINDTODEVICE was up to and including Python

126

# 2.6, and also 3.2:

96

127

from IN import SO_BINDTODEVICE

97

128

except ImportError:

98

SO_BINDTODEVICE = None

99

100

if sys.version_info.major == 2:

101

str = unicode

102

103

version = "1.7.5"

129

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

130

# Try running the C preprocessor:

131

try:

132

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

133

"/dev/stdin"],

134

stdin=subprocess.PIPE,

135

stdout=subprocess.PIPE)

136

stdout = cc.communicate(

137

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

138

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

139

except (OSError, ValueError, IndexError):

140

# No value found

141

SO_BINDTODEVICE = None

142

143

if sys.version_info < (3, 2):

144

configparser.Configparser = configparser.SafeConfigParser

145

146

version = "1.8.15"

104

147

stored_state_file = "clients.pickle"

105

148

106

logger = logging.getLogger()

149

log = logging.getLogger(os.path.basename(sys.argv[0]))

150

logging.captureWarnings(True) # Show warnings via the logging system

107

151

syslogger = None

108

152

109

153

try:

110

154

if_nametoindex = ctypes.cdll.LoadLibrary(

111

155

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

112

156

except (OSError, AttributeError):

113

157

114

158

def if_nametoindex(interface):

115

159

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

116

160

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

139

183

140

184

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

141

185

"""init logger and add loglevel"""

142

186

143

187

global syslogger

144

188

syslogger = (logging.handlers.SysLogHandler(

145

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

146

address = "/dev/log"))

189

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

190

address="/dev/log"))

147

191

syslogger.setFormatter(logging.Formatter

148

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

149

' %(message)s'))

150

logger.addHandler(syslogger)

151

192

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

193

" %(message)s"))

194

log.addHandler(syslogger)

195

152

196

if debug:

153

197

console = logging.StreamHandler()

154

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

155

' [%(process)d]:'

156

' %(levelname)s:'

157

' %(message)s'))

158

logger.addHandler(console)

159

logger.setLevel(level)

198

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

199

" [%(process)d]:"

200

" %(levelname)s:"

201

" %(message)s"))

202

log.addHandler(console)

203

log.setLevel(level)

160

204

161

205

162

206

class PGPError(Exception):

164

208

pass

165

209

166

210

167

class PGPEngine(object):

211

class PGPEngine:

168

212

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

169

213

170

214

def __init__(self):

171

215

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

172

216

self.gpg = "gpg"

174

218

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

175

219

for line in output.splitlines():

176

220

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

177

if name == "gpg":

221

if name == b"gpg":

178

222

self.gpg = path

179

223

break

180

224

except OSError as e:

181

225

if e.errno != errno.ENOENT:

182

226

raise

183

self.gnupgargs = ['--batch',

184

'--homedir', self.tempdir,

185

'--force-mdc',

186

'--quiet',

187

'--no-use-agent']

188

227

self.gnupgargs = ["--batch",

228

"--homedir", self.tempdir,

229

"--force-mdc",

230

"--quiet"]

231

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

232

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

233

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

234

189

235

def __enter__(self):

190

236

return self

191

237

192

238

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

193

239

self._cleanup()

194

240

return False

195

241

196

242

def __del__(self):

197

243

self._cleanup()

198

244

199

245

def _cleanup(self):

200

246

if self.tempdir is not None:

201

247

# Delete contents of tempdir

202

248

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

203

topdown = False):

249

topdown=False):

204

250

for filename in files:

205

251

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

206

252

for dirname in dirs:

208

254

# Remove tempdir

209

255

os.rmdir(self.tempdir)

210

256

self.tempdir = None

211

257

212

258

def password_encode(self, password):

213

259

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

214

260

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

219

265

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

220

266

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

221

267

return encoded

222

268

223

269

def encrypt(self, data, password):

224

270

passphrase = self.password_encode(password)

225

271

with tempfile.NamedTemporaryFile(

226

272

dir=self.tempdir) as passfile:

227

273

passfile.write(passphrase)

228

274

passfile.flush()

229

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

230

'--passphrase-file',

275

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

276

"--passphrase-file",

231

277

passfile.name]

232

278

+ self.gnupgargs,

233

stdin = subprocess.PIPE,

234

stdout = subprocess.PIPE,

235

stderr = subprocess.PIPE)

236

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

279

stdin=subprocess.PIPE,

280

stdout=subprocess.PIPE,

281

stderr=subprocess.PIPE)

282

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

237

283

if proc.returncode != 0:

238

284

raise PGPError(err)

239

285

return ciphertext

240

286

241

287

def decrypt(self, data, password):

242

288

passphrase = self.password_encode(password)

243

289

with tempfile.NamedTemporaryFile(

244

dir = self.tempdir) as passfile:

290

dir=self.tempdir) as passfile:

245

291

passfile.write(passphrase)

246

292

passfile.flush()

247

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

248

'--passphrase-file',

293

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

294

"--passphrase-file",

249

295

passfile.name]

250

296

+ self.gnupgargs,

251

stdin = subprocess.PIPE,

252

stdout = subprocess.PIPE,

253

stderr = subprocess.PIPE)

254

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

297

stdin=subprocess.PIPE,

298

stdout=subprocess.PIPE,

299

stderr=subprocess.PIPE)

300

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

255

301

if proc.returncode != 0:

256

302

raise PGPError(err)

257

303

return decrypted_plaintext

258

304

305

259

306

# Pretend that we have an Avahi module

260

class Avahi(object):

261

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

262

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

263

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

264

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

265

PROTO_INET = 0 # avahi-common/address.h

266

PROTO_INET6 = 1 # avahi-common/address.h

307

class avahi:

308

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

309

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

310

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

311

PROTO_INET = 0 # avahi-common/address.h

312

PROTO_INET6 = 1 # avahi-common/address.h

267

313

DBUS_NAME = "org.freedesktop.Avahi"

268

314

DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"

269

315

DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"

270

316

DBUS_PATH_SERVER = "/"

271

def string_array_to_txt_array(self, t):

317

318

@staticmethod

319

def string_array_to_txt_array(t):

272

320

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

273

321

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

274

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

275

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

276

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

277

SERVER_INVALID = 0 # avahi-common/defs.h

278

SERVER_REGISTERING = 1 # avahi-common/defs.h

279

SERVER_RUNNING = 2 # avahi-common/defs.h

280

SERVER_COLLISION = 3 # avahi-common/defs.h

281

SERVER_FAILURE = 4 # avahi-common/defs.h

282

avahi = Avahi()

322

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

323

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

324

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

325

SERVER_INVALID = 0 # avahi-common/defs.h

326

SERVER_REGISTERING = 1 # avahi-common/defs.h

327

SERVER_RUNNING = 2 # avahi-common/defs.h

328

SERVER_COLLISION = 3 # avahi-common/defs.h

329

SERVER_FAILURE = 4 # avahi-common/defs.h

330

283

331

284

332

class AvahiError(Exception):

285

333

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

296

344

pass

297

345

298

346

299

class AvahiService(object):

347

class AvahiService:

300

348

"""An Avahi (Zeroconf) service.

301

349

302

350

Attributes:

303

351

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

304

352

Used to optionally bind to the specified interface.

305

name: string; Example: 'Mandos'

306

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

353

name: string; Example: "Mandos"

354

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

307

355

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

308

356

port: integer; what port to announce

309

357

TXT: list of strings; TXT record for the service

316

364

server: D-Bus Server

317

365

bus: dbus.SystemBus()

318

366

"""

319

367

320

368

def __init__(self,

321

interface = avahi.IF_UNSPEC,

322

name = None,

323

servicetype = None,

324

port = None,

325

TXT = None,

326

domain = "",

327

host = "",

328

max_renames = 32768,

329

protocol = avahi.PROTO_UNSPEC,

330

bus = None):

369

interface=avahi.IF_UNSPEC,

370

name=None,

371

servicetype=None,

372

port=None,

373

TXT=None,

374

domain="",

375

host="",

376

max_renames=32768,

377

protocol=avahi.PROTO_UNSPEC,

378

bus=None):

331

379

self.interface = interface

332

380

self.name = name

333

381

self.type = servicetype

342

390

self.server = None

343

391

self.bus = bus

344

392

self.entry_group_state_changed_match = None

345

393

346

394

def rename(self, remove=True):

347

395

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

348

396

if self.rename_count >= self.max_renames:

349

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

350

" after %i retries, exiting.",

351

self.rename_count)

397

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

398

" after %i retries, exiting.",

399

self.rename_count)

352

400

raise AvahiServiceError("Too many renames")

353

401

self.name = str(

354

402

self.server.GetAlternativeServiceName(self.name))

355

403

self.rename_count += 1

356

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

357

self.name)

404

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

405

self.name)

358

406

if remove:

359

407

self.remove()

360

408

try:

362

410

except dbus.exceptions.DBusException as error:

363

411

if (error.get_dbus_name()

364

412

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

365

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

413

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

366

414

return self.rename(remove=False)

367

415

else:

368

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

416

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

369

417

self.cleanup()

370

418

os._exit(1)

371

419

372

420

def remove(self):

373

421

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

374

422

if self.entry_group_state_changed_match is not None:

376

424

self.entry_group_state_changed_match = None

377

425

if self.group is not None:

378

426

self.group.Reset()

379

427

380

428

def add(self):

381

429

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

382

430

self.remove()

387

435

avahi.DBUS_INTERFACE_ENTRY_GROUP)

388

436

self.entry_group_state_changed_match = (

389

437

self.group.connect_to_signal(

390

'StateChanged', self.entry_group_state_changed))

391

logger.debug("Adding Zeroconf service '%s' of type '%s' ...",

392

self.name, self.type)

438

"StateChanged", self.entry_group_state_changed))

439

log.debug("Adding Zeroconf service '%s' of type '%s' ...",

440

self.name, self.type)

393

441

self.group.AddService(

394

442

self.interface,

395

443

self.protocol,

399

447

dbus.UInt16(self.port),

400

448

avahi.string_array_to_txt_array(self.TXT))

401

449

self.group.Commit()

402

450

403

451

def entry_group_state_changed(self, state, error):

404

452

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

405

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

406

453

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

454

407

455

if state == avahi.ENTRY_GROUP_ESTABLISHED:

408

logger.debug("Zeroconf service established.")

456

log.debug("Zeroconf service established.")

409

457

elif state == avahi.ENTRY_GROUP_COLLISION:

410

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

458

log.info("Zeroconf service name collision.")

411

459

self.rename()

412

460

elif state == avahi.ENTRY_GROUP_FAILURE:

413

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

414

str(error))

461

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

462

str(error))

415

463

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

416

464

417

465

def cleanup(self):

418

466

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

419

467

if self.group is not None:

424

472

pass

425

473

self.group = None

426

474

self.remove()

427

475

428

476

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

429

477

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

430

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

478

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

431

479

bad_states = {

432

480

avahi.SERVER_INVALID: "Zeroconf server invalid",

433

481

avahi.SERVER_REGISTERING: None,

437

485

if state in bad_states:

438

486

if bad_states[state] is not None:

439

487

if error is None:

440

logger.error(bad_states[state])

488

log.error(bad_states[state])

441

489

else:

442

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

490

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

443

491

self.cleanup()

444

492

elif state == avahi.SERVER_RUNNING:

445

493

try:

447

495

except dbus.exceptions.DBusException as error:

448

496

if (error.get_dbus_name()

449

497

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

450

logger.info("Local Zeroconf service name"

451

" collision.")

498

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

452

499

return self.rename(remove=False)

453

500

else:

454

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

501

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

455

502

self.cleanup()

456

503

os._exit(1)

457

504

else:

458

505

if error is None:

459

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

506

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

460

507

else:

461

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

462

508

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

509

463

510

def activate(self):

464

511

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

465

512

if self.server is None:

476

523

class AvahiServiceToSyslog(AvahiService):

477

524

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

478

525

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

479

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

526

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

527

**kwargs)

480

528

syslogger.setFormatter(logging.Formatter(

481

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

529

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

482

530

.format(self.name)))

483

531

return ret

484

532

533

485

534

# Pretend that we have a GnuTLS module

486

class GnuTLS(object):

487

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

488

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

489

490

_library = ctypes.cdll.LoadLibrary(

491

ctypes.util.find_library("gnutls"))

492

_need_version = b"3.3.0"

493

def __init__(self):

494

# Need to use class name "GnuTLS" here, since this method is

495

# called before the assignment to the "gnutls" global variable

496

# happens.

497

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

498

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

499

.format(self._need_version))

500

535

class gnutls:

536

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

537

538

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

539

if library is None:

540

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

541

_library = ctypes.cdll.LoadLibrary(library)

542

del library

543

501

544

# Unless otherwise indicated, the constants and types below are

502

545

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

503

546

504

547

# Constants

505

548

E_SUCCESS = 0

506

549

E_INTERRUPTED = -52

507

550

E_AGAIN = -28

508

551

CRT_OPENPGP = 2

552

CRT_RAWPK = 3

509

553

CLIENT = 2

510

554

SHUT_RDWR = 0

511

555

CRD_CERTIFICATE = 1

512

556

E_NO_CERTIFICATE_FOUND = -49

557

X509_FMT_DER = 0

558

NO_TICKETS = 1<<10

559

ENABLE_RAWPK = 1<<18

560

CTYPE_PEERS = 3

561

KEYID_USE_SHA256 = 1 # gnutls/x509.h

513

562

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

514

563

515

564

# Types

516

class session_int(ctypes.Structure):

565

class _session_int(ctypes.Structure):

517

566

_fields_ = []

518

session_t = ctypes.POINTER(session_int)

567

session_t = ctypes.POINTER(_session_int)

568

519

569

class certificate_credentials_st(ctypes.Structure):

520

570

_fields_ = []

521

571

certificate_credentials_t = ctypes.POINTER(

522

572

certificate_credentials_st)

523

573

certificate_type_t = ctypes.c_int

574

524

575

class datum_t(ctypes.Structure):

525

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

526

('size', ctypes.c_uint)]

527

class openpgp_crt_int(ctypes.Structure):

576

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

577

("size", ctypes.c_uint)]

578

579

class _openpgp_crt_int(ctypes.Structure):

528

580

_fields_ = []

529

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

530

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

581

openpgp_crt_t = ctypes.POINTER(_openpgp_crt_int)

582

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

531

583

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

532

584

credentials_type_t = ctypes.c_int

533

585

transport_ptr_t = ctypes.c_void_p

534

586

close_request_t = ctypes.c_int

535

587

536

588

# Exceptions

537

589

class Error(Exception):

538

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

539

# exception might be raised from within GnuTLS.__init__,

540

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

541

# global variable has happened.

542

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

590

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

543

591

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

544

592

# code is passed, convert it to a string with

545

593

# gnutls.strerror()

546

594

self.code = code

547

595

if message is None and code is not None:

548

message = GnuTLS.strerror(code)

549

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

596

message = gnutls.strerror(code).decode(

597

"utf-8", errors="replace")

598

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

550

599

message, *args)

551

600

552

601

class CertificateSecurityError(Error):

553

602

pass

554

603

604

class PointerTo:

605

def __init__(self, cls):

606

self.cls = cls

607

608

def from_param(self, obj):

609

if not isinstance(obj, self.cls):

610

raise TypeError("Not of type {}: {!r}"

611

.format(self.cls.__name__, obj))

612

return ctypes.byref(obj.from_param(obj))

613

614

class CastToVoidPointer:

615

def __init__(self, cls):

616

self.cls = cls

617

618

def from_param(self, obj):

619

if not isinstance(obj, self.cls):

620

raise TypeError("Not of type {}: {!r}"

621

.format(self.cls.__name__, obj))

622

return ctypes.cast(obj.from_param(obj), ctypes.c_void_p)

623

624

class With_from_param:

625

@classmethod

626

def from_param(cls, obj):

627

return obj._as_parameter_

628

555

629

# Classes

556

class Credentials(object):

630

class Credentials(With_from_param):

557

631

def __init__(self):

558

self._c_object = gnutls.certificate_credentials_t()

559

gnutls.certificate_allocate_credentials(

560

ctypes.byref(self._c_object))

632

self._as_parameter_ = gnutls.certificate_credentials_t()

633

gnutls.certificate_allocate_credentials(self)

561

634

self.type = gnutls.CRD_CERTIFICATE

562

635

563

636

def __del__(self):

564

gnutls.certificate_free_credentials(self._c_object)

565

566

class ClientSession(object):

567

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

568

self._c_object = gnutls.session_t()

569

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

570

gnutls.set_default_priority(self._c_object)

571

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

572

gnutls.handshake_set_private_extensions(self._c_object,

573

True)

637

gnutls.certificate_free_credentials(self)

638

639

class ClientSession(With_from_param):

640

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

641

self._as_parameter_ = gnutls.session_t()

642

gnutls_flags = gnutls.CLIENT

643

if gnutls.check_version(b"3.5.6"):

644

gnutls_flags |= gnutls.NO_TICKETS

645

if gnutls.has_rawpk:

646

gnutls_flags |= gnutls.ENABLE_RAWPK

647

gnutls.init(self, gnutls_flags)

648

del gnutls_flags

649

gnutls.set_default_priority(self)

650

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

651

gnutls.handshake_set_private_extensions(self, True)

574

652

self.socket = socket

575

653

if credentials is None:

576

654

credentials = gnutls.Credentials()

577

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

578

ctypes.cast(credentials._c_object,

579

ctypes.c_void_p))

655

gnutls.credentials_set(self, credentials.type,

656

credentials)

580

657

self.credentials = credentials

581

658

582

659

def __del__(self):

583

gnutls.deinit(self._c_object)

584

660

gnutls.deinit(self)

661

585

662

def handshake(self):

586

return gnutls.handshake(self._c_object)

587

663

return gnutls.handshake(self)

664

588

665

def send(self, data):

589

666

data = bytes(data)

590

667

data_len = len(data)

591

668

while data_len > 0:

592

data_len -= gnutls.record_send(self._c_object,

593

data[-data_len:],

669

data_len -= gnutls.record_send(self, data[-data_len:],

594

670

data_len)

595

671

596

672

def bye(self):

597

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

598

673

return gnutls.bye(self, gnutls.SHUT_RDWR)

674

599

675

# Error handling functions

600

676

def _error_code(result):

601

677

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

602

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

603

if result >= 0:

678

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

679

if result >= gnutls.E_SUCCESS:

604

680

return result

605

681

if result == gnutls.E_NO_CERTIFICATE_FOUND:

606

raise gnutls.CertificateSecurityError(code = result)

607

raise gnutls.Error(code = result)

608

609

def _retry_on_error(result, func, arguments):

682

raise gnutls.CertificateSecurityError(code=result)

683

raise gnutls.Error(code=result)

684

685

def _retry_on_error(result, func, arguments,

686

_error_code=_error_code):

610

687

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

611

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

612

while result < 0:

688

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

689

while result < gnutls.E_SUCCESS:

613

690

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

614

691

return _error_code(result)

615

692

result = func(*arguments)

616

693

return result

617

694

618

695

# Unless otherwise indicated, the function declarations below are

619

696

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

620

697

621

698

# Functions

622

699

priority_set_direct = _library.gnutls_priority_set_direct

623

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

700

priority_set_direct.argtypes = [ClientSession, ctypes.c_char_p,

624

701

ctypes.POINTER(ctypes.c_char_p)]

625

702

priority_set_direct.restype = _error_code

626

703

627

704

init = _library.gnutls_init

628

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

705

init.argtypes = [PointerTo(ClientSession), ctypes.c_int]

629

706

init.restype = _error_code

630

707

631

708

set_default_priority = _library.gnutls_set_default_priority

632

set_default_priority.argtypes = [session_t]

709

set_default_priority.argtypes = [ClientSession]

633

710

set_default_priority.restype = _error_code

634

711

635

712

record_send = _library.gnutls_record_send

636

record_send.argtypes = [session_t, ctypes.c_void_p,

713

record_send.argtypes = [ClientSession, ctypes.c_void_p,

637

714

ctypes.c_size_t]

638

715

record_send.restype = ctypes.c_ssize_t

639

716

record_send.errcheck = _retry_on_error

640

717

641

718

certificate_allocate_credentials = (

642

719

_library.gnutls_certificate_allocate_credentials)

643

720

certificate_allocate_credentials.argtypes = [

644

ctypes.POINTER(certificate_credentials_t)]

721

PointerTo(Credentials)]

645

722

certificate_allocate_credentials.restype = _error_code

646

723

647

724

certificate_free_credentials = (

648

725

_library.gnutls_certificate_free_credentials)

649

certificate_free_credentials.argtypes = [certificate_credentials_t]

726

certificate_free_credentials.argtypes = [Credentials]

650

727

certificate_free_credentials.restype = None

651

728

652

729

handshake_set_private_extensions = (

653

730

_library.gnutls_handshake_set_private_extensions)

654

handshake_set_private_extensions.argtypes = [session_t,

731

handshake_set_private_extensions.argtypes = [ClientSession,

655

732

ctypes.c_int]

656

733

handshake_set_private_extensions.restype = None

657

734

658

735

credentials_set = _library.gnutls_credentials_set

659

credentials_set.argtypes = [session_t, credentials_type_t,

660

ctypes.c_void_p]

736

credentials_set.argtypes = [ClientSession, credentials_type_t,

737

CastToVoidPointer(Credentials)]

661

738

credentials_set.restype = _error_code

662

739

663

740

strerror = _library.gnutls_strerror

664

741

strerror.argtypes = [ctypes.c_int]

665

742

strerror.restype = ctypes.c_char_p

666

743

667

744

certificate_type_get = _library.gnutls_certificate_type_get

668

certificate_type_get.argtypes = [session_t]

745

certificate_type_get.argtypes = [ClientSession]

669

746

certificate_type_get.restype = _error_code

670

747

671

748

certificate_get_peers = _library.gnutls_certificate_get_peers

672

certificate_get_peers.argtypes = [session_t,

749

certificate_get_peers.argtypes = [ClientSession,

673

750

ctypes.POINTER(ctypes.c_uint)]

674

751

certificate_get_peers.restype = ctypes.POINTER(datum_t)

675

752

676

753

global_set_log_level = _library.gnutls_global_set_log_level

677

754

global_set_log_level.argtypes = [ctypes.c_int]

678

755

global_set_log_level.restype = None

679

756

680

757

global_set_log_function = _library.gnutls_global_set_log_function

681

758

global_set_log_function.argtypes = [log_func]

682

759

global_set_log_function.restype = None

683

760

684

761

deinit = _library.gnutls_deinit

685

deinit.argtypes = [session_t]

762

deinit.argtypes = [ClientSession]

686

763

deinit.restype = None

687

764

688

765

handshake = _library.gnutls_handshake

689

handshake.argtypes = [session_t]

690

handshake.restype = _error_code

766

handshake.argtypes = [ClientSession]

767

handshake.restype = ctypes.c_int

691

768

handshake.errcheck = _retry_on_error

692

769

693

770

transport_set_ptr = _library.gnutls_transport_set_ptr

694

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

771

transport_set_ptr.argtypes = [ClientSession, transport_ptr_t]

695

772

transport_set_ptr.restype = None

696

773

697

774

bye = _library.gnutls_bye

698

bye.argtypes = [session_t, close_request_t]

699

bye.restype = _error_code

775

bye.argtypes = [ClientSession, close_request_t]

776

bye.restype = ctypes.c_int

700

777

bye.errcheck = _retry_on_error

701

778

702

779

check_version = _library.gnutls_check_version

703

780

check_version.argtypes = [ctypes.c_char_p]

704

781

check_version.restype = ctypes.c_char_p

705

706

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

707

708

openpgp_crt_init = _library.gnutls_openpgp_crt_init

709

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

710

openpgp_crt_init.restype = _error_code

711

712

openpgp_crt_import = _library.gnutls_openpgp_crt_import

713

openpgp_crt_import.argtypes = [openpgp_crt_t,

714

ctypes.POINTER(datum_t),

715

openpgp_crt_fmt_t]

716

openpgp_crt_import.restype = _error_code

717

718

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

719

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

720

ctypes.POINTER(ctypes.c_uint)]

721

openpgp_crt_verify_self.restype = _error_code

722

723

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

724

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

725

openpgp_crt_deinit.restype = None

726

727

openpgp_crt_get_fingerprint = (

728

_library.gnutls_openpgp_crt_get_fingerprint)

729

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

730

ctypes.c_void_p,

731

ctypes.POINTER(

732

ctypes.c_size_t)]

733

openpgp_crt_get_fingerprint.restype = _error_code

734

782

783

_need_version = b"3.3.0"

784

if check_version(_need_version) is None:

785

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

786

.format(_need_version))

787

788

_tls_rawpk_version = b"3.6.6"

789

has_rawpk = bool(check_version(_tls_rawpk_version))

790

791

if has_rawpk:

792

# Types

793

class pubkey_st(ctypes.Structure):

794

_fields = []

795

pubkey_t = ctypes.POINTER(pubkey_st)

796

797

x509_crt_fmt_t = ctypes.c_int

798

799

# All the function declarations below are from

800

# gnutls/abstract.h

801

pubkey_init = _library.gnutls_pubkey_init

802

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

803

pubkey_init.restype = _error_code

804

805

pubkey_import = _library.gnutls_pubkey_import

806

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

807

x509_crt_fmt_t]

808

pubkey_import.restype = _error_code

809

810

pubkey_get_key_id = _library.gnutls_pubkey_get_key_id

811

pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,

812

ctypes.POINTER(ctypes.c_ubyte),

813

ctypes.POINTER(ctypes.c_size_t)]

814

pubkey_get_key_id.restype = _error_code

815

816

pubkey_deinit = _library.gnutls_pubkey_deinit

817

pubkey_deinit.argtypes = [pubkey_t]

818

pubkey_deinit.restype = None

819

else:

820

# All the function declarations below are from

821

# gnutls/openpgp.h

822

823

openpgp_crt_init = _library.gnutls_openpgp_crt_init

824

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

825

openpgp_crt_init.restype = _error_code

826

827

openpgp_crt_import = _library.gnutls_openpgp_crt_import

828

openpgp_crt_import.argtypes = [openpgp_crt_t,

829

ctypes.POINTER(datum_t),

830

openpgp_crt_fmt_t]

831

openpgp_crt_import.restype = _error_code

832

833

openpgp_crt_verify_self = \

834

_library.gnutls_openpgp_crt_verify_self

835

openpgp_crt_verify_self.argtypes = [

836

openpgp_crt_t,

837

ctypes.c_uint,

838

ctypes.POINTER(ctypes.c_uint),

839

]

840

openpgp_crt_verify_self.restype = _error_code

841

842

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

843

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

844

openpgp_crt_deinit.restype = None

845

846

openpgp_crt_get_fingerprint = (

847

_library.gnutls_openpgp_crt_get_fingerprint)

848

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

849

ctypes.c_void_p,

850

ctypes.POINTER(

851

ctypes.c_size_t)]

852

openpgp_crt_get_fingerprint.restype = _error_code

853

854

if check_version(b"3.6.4"):

855

certificate_type_get2 = _library.gnutls_certificate_type_get2

856

certificate_type_get2.argtypes = [ClientSession, ctypes.c_int]

857

certificate_type_get2.restype = _error_code

858

735

859

# Remove non-public functions

736

860

del _error_code, _retry_on_error

737

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

738

gnutls = GnuTLS()

861

739

862

740

863

def call_pipe(connection, # : multiprocessing.Connection

741

864

func, *args, **kwargs):

742

865

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

743

866

744

867

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

745

868

return value on the provided multiprocessing.Connection.

746

869

"""

747

870

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

748

871

connection.close()

749

872

750

class Client(object):

873

874

class Client:

751

875

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

752

876

753

877

Attributes:

754

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

878

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

755

879

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

756

880

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

757

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

758

to see if the client lives.

759

'None' if no process is running.

760

checker_callback_tag: a GObject event source tag, or None

881

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

882

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

883

running.

884

checker_callback_tag: a GLib event source tag, or None

761

885

checker_command: string; External command which is run to check

762

886

if client lives. %() expansions are done at

763

887

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

764

888

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

765

checker_initiator_tag: a GObject event source tag, or None

889

checker_initiator_tag: a GLib event source tag, or None

766

890

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

767

891

client_structure: Object describing what attributes a client has

768

892

and is used for storing the client at exit

769

893

current_checker_command: string; current running checker_command

770

disable_initiator_tag: a GObject event source tag, or None

894

disable_initiator_tag: a GLib event source tag, or None

771

895

enabled: bool()

772

896

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

773

uniquely identify the client

897

uniquely identify an OpenPGP client

898

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

899

a client using raw public keys

774

900

host: string; available for use by the checker command

775

901

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

776

902

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

792

918

disabled, or None

793

919

server_settings: The server_settings dict from main()

794

920

"""

795

921

796

922

runtime_expansions = ("approval_delay", "approval_duration",

797

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

923

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

798

924

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

799

925

"last_approval_request", "last_checked_ok",

800

926

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

809

935

"approved_by_default": "True",

810

936

"enabled": "True",

811

937

}

812

938

813

939

@staticmethod

814

940

def config_parser(config):

815

941

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

822

948

for client_name in config.sections():

823

949

section = dict(config.items(client_name))

824

950

client = settings[client_name] = {}

825

951

826

952

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

827

953

# Reformat values from string types to Python types

828

954

client["approved_by_default"] = config.getboolean(

829

955

client_name, "approved_by_default")

830

956

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

831

957

"enabled")

832

833

# Uppercase and remove spaces from fingerprint for later

834

# comparison purposes with return value from the

835

# fingerprint() function

958

959

# Uppercase and remove spaces from key_id and fingerprint

960

# for later comparison purposes with return value from the

961

# key_id() and fingerprint() functions

962

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

963

.replace(" ", ""))

836

964

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

837

965

.replace(" ", ""))

838

966

if "secret" in section:

859

987

client["last_approval_request"] = None

860

988

client["last_checked_ok"] = None

861

989

client["last_checker_status"] = -2

862

990

863

991

return settings

864

865

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

992

993

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

866

994

self.name = name

867

995

if server_settings is None:

868

996

server_settings = {}

870

998

# adding all client settings

871

999

for setting, value in settings.items():

872

1000

setattr(self, setting, value)

873

1001

874

1002

if self.enabled:

875

1003

if not hasattr(self, "last_enabled"):

876

1004

self.last_enabled = datetime.datetime.utcnow()

880

1008

else:

881

1009

self.last_enabled = None

882

1010

self.expires = None

883

884

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

885

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

1011

1012

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

1013

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

1014

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

886

1015

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

887

1016

datetime.datetime.utcnow())

888

1017

889

1018

# attributes specific for this server instance

890

1019

self.checker = None

891

1020

self.checker_initiator_tag = None

900

1029

for attr in self.__dict__.keys()

901

1030

if not attr.startswith("_")]

902

1031

self.client_structure.append("client_structure")

903

1032

904

1033

for name, t in inspect.getmembers(

905

1034

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

906

1035

if not name.startswith("_"):

907

1036

self.client_structure.append(name)

908

1037

909

1038

# Send notice to process children that client state has changed

910

1039

def send_changedstate(self):

911

1040

with self.changedstate:

912

1041

self.changedstate.notify_all()

913

1042

914

1043

def enable(self):

915

1044

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

916

1045

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

921

1050

self.last_enabled = datetime.datetime.utcnow()

922

1051

self.init_checker()

923

1052

self.send_changedstate()

924

1053

925

1054

def disable(self, quiet=True):

926

1055

"""Disable this client."""

927

1056

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

928

1057

return False

929

1058

if not quiet:

930

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

1059

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

931

1060

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

932

GObject.source_remove(self.disable_initiator_tag)

1061

GLib.source_remove(self.disable_initiator_tag)

933

1062

self.disable_initiator_tag = None

934

1063

self.expires = None

935

1064

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

936

GObject.source_remove(self.checker_initiator_tag)

1065

GLib.source_remove(self.checker_initiator_tag)

937

1066

self.checker_initiator_tag = None

938

1067

self.stop_checker()

939

1068

self.enabled = False

940

1069

if not quiet:

941

1070

self.send_changedstate()

942

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

1071

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

943

1072

return False

944

1073

945

1074

def __del__(self):

946

1075

self.disable()

947

1076

948

1077

def init_checker(self):

949

1078

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

950

1079

# and every interval from then on.

951

1080

if self.checker_initiator_tag is not None:

952

GObject.source_remove(self.checker_initiator_tag)

953

self.checker_initiator_tag = GObject.timeout_add(

954

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

1081

GLib.source_remove(self.checker_initiator_tag)

1082

self.checker_initiator_tag = GLib.timeout_add(

1083

random.randrange(int(self.interval.total_seconds() * 1000

1084

+ 1)),

955

1085

self.start_checker)

956

1086

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

957

1087

if self.disable_initiator_tag is not None:

958

GObject.source_remove(self.disable_initiator_tag)

959

self.disable_initiator_tag = GObject.timeout_add(

1088

GLib.source_remove(self.disable_initiator_tag)

1089

self.disable_initiator_tag = GLib.timeout_add(

960

1090

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

961

1091

# Also start a new checker *right now*.

962

1092

self.start_checker()

963

1093

964

1094

def checker_callback(self, source, condition, connection,

965

1095

command):

966

1096

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

967

self.checker_callback_tag = None

968

self.checker = None

969

1097

# Read return code from connection (see call_pipe)

970

1098

returncode = connection.recv()

971

1099

connection.close()

972

1100

if self.checker is not None:

1101

self.checker.join()

1102

self.checker_callback_tag = None

1103

self.checker = None

1104

973

1105

if returncode >= 0:

974

1106

self.last_checker_status = returncode

975

1107

self.last_checker_signal = None

976

1108

if self.last_checker_status == 0:

977

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

978

vars(self))

1109

log.info("Checker for %(name)s succeeded", vars(self))

979

1110

self.checked_ok()

980

1111

else:

981

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

1112

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

982

1113

else:

983

1114

self.last_checker_status = -1

984

1115

self.last_checker_signal = -returncode

985

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

986

vars(self))

1116

log.warning("Checker for %(name)s crashed?", vars(self))

987

1117

return False

988

1118

989

1119

def checked_ok(self):

990

1120

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

991

1121

self.last_checked_ok = datetime.datetime.utcnow()

992

1122

self.last_checker_status = 0

993

1123

self.last_checker_signal = None

994

1124

self.bump_timeout()

995

1125

996

1126

def bump_timeout(self, timeout=None):

997

1127

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

998

1128

if timeout is None:

999

1129

timeout = self.timeout

1000

1130

if self.disable_initiator_tag is not None:

1001

GObject.source_remove(self.disable_initiator_tag)

1131

GLib.source_remove(self.disable_initiator_tag)

1002

1132

self.disable_initiator_tag = None

1003

1133

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

1004

self.disable_initiator_tag = GObject.timeout_add(

1134

self.disable_initiator_tag = GLib.timeout_add(

1005

1135

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

1006

1136

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

1007

1137

1008

1138

def need_approval(self):

1009

1139

self.last_approval_request = datetime.datetime.utcnow()

1010

1140

1011

1141

def start_checker(self):

1012

1142

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

1013

1143

1014

1144

If a checker already exists, leave it running and do

1015

1145

nothing."""

1016

1146

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

1021

1151

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

1022

1152

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

1023

1153

# should be.

1024

1154

1025

1155

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

1026

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

1156

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

1027

1157

self.checker.join()

1028

1158

self.checker = None

1029

1159

# Start a new checker if needed

1030

1160

if self.checker is None:

1031

1161

# Escape attributes for the shell

1032

1162

escaped_attrs = {

1033

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

1034

for attr in self.runtime_expansions }

1163

attr: shlex.quote(str(getattr(self, attr)))

1164

for attr in self.runtime_expansions}

1035

1165

try:

1036

1166

command = self.checker_command % escaped_attrs

1037

1167

except TypeError as error:

1038

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

1039

self.checker_command,

1040

exc_info=error)

1168

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

1169

self.checker_command, exc_info=error)

1041

1170

return True # Try again later

1042

1171

self.current_checker_command = command

1043

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

1044

self.name)

1172

log.info("Starting checker %r for %s", command, self.name)

1045

1173

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

1046

1174

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

1047

1175

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

1049

1177

# The exception is when not debugging but nevertheless

1050

1178

# running in the foreground; use the previously

1051

1179

# created wnull.

1052

popen_args = { "close_fds": True,

1053

"shell": True,

1054

"cwd": "/" }

1180

popen_args = {"close_fds": True,

1181

"shell": True,

1182

"cwd": "/"}

1055

1183

if (not self.server_settings["debug"]

1056

1184

and self.server_settings["foreground"]):

1057

1185

popen_args.update({"stdout": wnull,

1058

"stderr": wnull })

1059

pipe = multiprocessing.Pipe(duplex = False)

1186

"stderr": wnull})

1187

pipe = multiprocessing.Pipe(duplex=False)

1060

1188

self.checker = multiprocessing.Process(

1061

target = call_pipe,

1062

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

1063

kwargs = popen_args)

1189

target=call_pipe,

1190

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

1191

kwargs=popen_args)

1064

1192

self.checker.start()

1065

self.checker_callback_tag = GObject.io_add_watch(

1066

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

1193

self.checker_callback_tag = GLib.io_add_watch(

1194

GLib.IOChannel.unix_new(pipe[0].fileno()),

1195

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

1067

1196

self.checker_callback, pipe[0], command)

1068

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

1197

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

1069

1198

return True

1070

1199

1071

1200

def stop_checker(self):

1072

1201

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

1073

1202

if self.checker_callback_tag:

1074

GObject.source_remove(self.checker_callback_tag)

1203

GLib.source_remove(self.checker_callback_tag)

1075

1204

self.checker_callback_tag = None

1076

1205

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

1077

1206

return

1078

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

1207

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

1079

1208

self.checker.terminate()

1080

1209

self.checker = None

1081

1210

1086

1215

byte_arrays=False):

1087

1216

"""Decorators for marking methods of a DBusObjectWithProperties to

1088

1217

become properties on the D-Bus.

1089

1218

1090

1219

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

1091

1220

and with one argument by "Set".

1092

1221

1093

1222

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

1094

1223

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

1095

1224

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

1099

1228

if byte_arrays and signature != "ay":

1100

1229

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

1101

1230

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

1102

1231

1103

1232

def decorator(func):

1104

1233

func._dbus_is_property = True

1105

1234

func._dbus_interface = dbus_interface

1108

1237

func._dbus_name = func.__name__

1109

1238

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

1110

1239

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

1111

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1240

func._dbus_get_args_options = {"byte_arrays": byte_arrays}

1112

1241

return func

1113

1242

1114

1243

return decorator

1115

1244

1116

1245

1117

1246

def dbus_interface_annotations(dbus_interface):

1118

1247

"""Decorator for marking functions returning interface annotations

1119

1248

1120

1249

Usage:

1121

1250

1122

1251

@dbus_interface_annotations("org.example.Interface")

1123

1252

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

1124

1253

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

1125

1254

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

1126

1255

"false"}

1127

1256

"""

1128

1257

1129

1258

def decorator(func):

1130

1259

func._dbus_is_interface = True

1131

1260

func._dbus_interface = dbus_interface

1132

1261

func._dbus_name = dbus_interface

1133

1262

return func

1134

1263

1135

1264

return decorator

1136

1265

1137

1266

1138

1267

def dbus_annotations(annotations):

1139

1268

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

1140

1269

Usage:

1141

1270

1142

1271

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

1143

1272

"org.freedesktop.DBus.Property."

1144

1273

"EmitsChangedSignal": "false"})

1146

1275

access="r")

1147

1276

def Property_dbus_property(self):

1148

1277

return dbus.Boolean(False)

1149

1278

1150

1279

See also the DBusObjectWithAnnotations class.

1151

1280

"""

1152

1281

1153

1282

def decorator(func):

1154

1283

func._dbus_annotations = annotations

1155

1284

return func

1156

1285

1157

1286

return decorator

1158

1287

1159

1288

1177

1306

1178

1307

class DBusObjectWithAnnotations(dbus.service.Object):

1179

1308

"""A D-Bus object with annotations.

1180

1309

1181

1310

Classes inheriting from this can use the dbus_annotations

1182

1311

decorator to add annotations to methods or signals.

1183

1312

"""

1184

1313

1185

1314

@staticmethod

1186

1315

def _is_dbus_thing(thing):

1187

1316

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

1188

1317

1189

1318

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

1190

1319

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

1191

1320

"""

1192

1321

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

1193

1322

False)

1194

1323

1195

1324

def _get_all_dbus_things(self, thing):

1196

1325

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

1197

1326

"""

1200

1329

for cls in self.__class__.__mro__

1201

1330

for name, athing in

1202

1331

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

1203

1332

1204

1333

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1205

out_signature = "s",

1206

path_keyword = 'object_path',

1207

connection_keyword = 'connection')

1334

out_signature="s",

1335

path_keyword="object_path",

1336

connection_keyword="connection")

1208

1337

def Introspect(self, object_path, connection):

1209

1338

"""Overloading of standard D-Bus method.

1210

1339

1211

1340

Inserts annotation tags on methods and signals.

1212

1341

"""

1213

1342

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

1214

1343

connection)

1215

1344

try:

1216

1345

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

1217

1346

1218

1347

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

1219

1348

# Add annotation tags

1220

1349

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

1247

1376

if_tag.appendChild(ann_tag)

1248

1377

# Fix argument name for the Introspect method itself

1249

1378

if (if_tag.getAttribute("name")

1250

== dbus.INTROSPECTABLE_IFACE):

1379

== dbus.INTROSPECTABLE_IFACE):

1251

1380

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

1252

1381

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

1253

1382

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

1259

1388

document.unlink()

1260

1389

except (AttributeError, xml.dom.DOMException,

1261

1390

xml.parsers.expat.ExpatError) as error:

1262

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

1263

exc_info=error)

1391

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

1392

exc_info=error)

1264

1393

return xmlstring

1265

1394

1266

1395

1267

1396

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1268

1397

"""A D-Bus object with properties.

1269

1398

1270

1399

Classes inheriting from this can use the dbus_service_property

1271

1400

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

1272

1401

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

1273

1402

"""

1274

1403

1275

1404

def _get_dbus_property(self, interface_name, property_name):

1276

1405

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

1277

1406

property with the specified name and interface.

1282

1411

if (value._dbus_name == property_name

1283

1412

and value._dbus_interface == interface_name):

1284

1413

return value.__get__(self)

1285

1414

1286

1415

# No such property

1287

1416

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

1288

1417

self.dbus_object_path, interface_name, property_name))

1289

1418

1290

1419

@classmethod

1291

1420

def _get_all_interface_names(cls):

1292

1421

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

1295

1424

for x in (inspect.getmro(cls))

1296

1425

for attr in dir(x))

1297

1426

if name is not None)

1298

1427

1299

1428

@dbus.service.method(dbus.PROPERTIES_IFACE,

1300

1429

in_signature="ss",

1301

1430

out_signature="v")

1309

1438

if not hasattr(value, "variant_level"):

1310

1439

return value

1311

1440

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

1312

1441

1313

1442

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

1314

1443

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

1315

1444

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

1324

1453

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

1325

1454

"'ay' signature {!r}"

1326

1455

.format(prop._dbus_signature))

1327

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

1328

for byte in value))

1456

value = dbus.ByteArray(bytes(value))

1329

1457

prop(value)

1330

1458

1331

1459

@dbus.service.method(dbus.PROPERTIES_IFACE,

1332

1460

in_signature="s",

1333

1461

out_signature="a{sv}")

1334

1462

def GetAll(self, interface_name):

1335

1463

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

1336

1464

standard.

1337

1465

1338

1466

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

1339

1467

"""

1340

1468

properties = {}

1351

1479

properties[name] = value

1352

1480

continue

1353

1481

properties[name] = type(value)(

1354

value, variant_level = value.variant_level + 1)

1482

value, variant_level=value.variant_level + 1)

1355

1483

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

1356

1484

1357

1485

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

1358

1486

def PropertiesChanged(self, interface_name, changed_properties,

1359

1487

invalidated_properties):

1361

1489

standard.

1362

1490

"""

1363

1491

pass

1364

1492

1365

1493

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1366

1494

out_signature="s",

1367

path_keyword='object_path',

1368

connection_keyword='connection')

1495

path_keyword="object_path",

1496

connection_keyword="connection")

1369

1497

def Introspect(self, object_path, connection):

1370

1498

"""Overloading of standard D-Bus method.

1371

1499

1372

1500

Inserts property tags and interface annotation tags.

1373

1501

"""

1374

1502

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1376

1504

connection)

1377

1505

try:

1378

1506

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

1379

1507

1380

1508

def make_tag(document, name, prop):

1381

1509

e = document.createElement("property")

1382

1510

e.setAttribute("name", name)

1383

1511

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

1384

1512

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

1385

1513

return e

1386

1514

1387

1515

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

1388

1516

# Add property tags

1389

1517

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

1427

1555

document.unlink()

1428

1556

except (AttributeError, xml.dom.DOMException,

1429

1557

xml.parsers.expat.ExpatError) as error:

1430

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

1431

exc_info=error)

1558

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

1559

exc_info=error)

1432

1560

return xmlstring

1433

1561

1562

1434

1563

try:

1435

1564

dbus.OBJECT_MANAGER_IFACE

1436

1565

except AttributeError:

1437

1566

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

1438

1567

1568

1439

1569

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1440

1570

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

1441

1571

1442

1572

Classes inheriting from this exposes the standard

1443

1573

GetManagedObjects call and the InterfacesAdded and

1444

1574

InterfacesRemoved signals on the standard

1445

1575

"org.freedesktop.DBus.ObjectManager" interface.

1446

1576

1447

1577

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

1448

1578

manually.

1449

1579

"""

1450

1580

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1451

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

1581

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

1452

1582

def GetManagedObjects(self):

1453

1583

"""This function must be overridden"""

1454

1584

raise NotImplementedError()

1455

1585

1456

1586

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1457

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

1587

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

1458

1588

def InterfacesAdded(self, object_path, interfaces_and_properties):

1459

1589

pass

1460

1461

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

1590

1591

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

1462

1592

def InterfacesRemoved(self, object_path, interfaces):

1463

1593

pass

1464

1594

1465

1595

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1466

out_signature = "s",

1467

path_keyword = 'object_path',

1468

connection_keyword = 'connection')

1596

out_signature="s",

1597

path_keyword="object_path",

1598

connection_keyword="connection")

1469

1599

def Introspect(self, object_path, connection):

1470

1600

"""Overloading of standard D-Bus method.

1471

1601

1472

1602

Override return argument name of GetManagedObjects to be

1473

1603

"objpath_interfaces_and_properties"

1474

1604

"""

1477

1607

connection)

1478

1608

try:

1479

1609

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

1480

1610

1481

1611

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

1482

1612

# Fix argument name for the GetManagedObjects method

1483

1613

if (if_tag.getAttribute("name")

1484

== dbus.OBJECT_MANAGER_IFACE):

1614

== dbus.OBJECT_MANAGER_IFACE):

1485

1615

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

1486

1616

if (cn.getAttribute("name")

1487

1617

== "GetManagedObjects"):

1496

1626

document.unlink()

1497

1627

except (AttributeError, xml.dom.DOMException,

1498

1628

xml.parsers.expat.ExpatError) as error:

1499

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

1500

exc_info = error)

1629

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

1630

exc_info=error)

1501

1631

return xmlstring

1502

1632

1633

1503

1634

def datetime_to_dbus(dt, variant_level=0):

1504

1635

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

1505

1636

if dt is None:

1506

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

1637

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

1507

1638

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

1508

1639

1509

1640

1512

1643

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

1513

1644

interface names according to the "alt_interface_names" mapping.

1514

1645

Usage:

1515

1646

1516

1647

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

1517

1648

"net.example.AlternateInterface"})

1518

1649

class SampleDBusObject(dbus.service.Object):

1519

1650

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

1520

1651

def SampleDBusMethod():

1521

1652

pass

1522

1653

1523

1654

The above "SampleDBusMethod" on "SampleDBusObject" will be

1524

1655

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

1525

1656

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

1526

1657

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

1527

1658

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

1528

1659

1529

1660

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

1530

1661

(from DBusObjectWithProperties) and interfaces (from the

1531

1662

dbus_interface_annotations decorator).

1532

1663

"""

1533

1664

1534

1665

def wrapper(cls):

1535

1666

for orig_interface_name, alt_interface_name in (

1536

1667

alt_interface_names.items()):

1576

1707

attribute._dbus_annotations)

1577

1708

except AttributeError:

1578

1709

pass

1710

1579

1711

# Define a creator of a function to call both the

1580

1712

# original and alternate functions, so both the

1581

1713

# original and alternate signals gets sent when

1584

1716

"""This function is a scope container to pass

1585

1717

func1 and func2 to the "call_both" function

1586

1718

outside of its arguments"""

1587

1719

1588

1720

@functools.wraps(func2)

1589

1721

def call_both(*args, **kwargs):

1590

1722

"""This function will emit two D-Bus

1591

1723

signals by calling func1 and func2"""

1592

1724

func1(*args, **kwargs)

1593

1725

func2(*args, **kwargs)

1594

# Make wrapper function look like a D-Bus signal

1726

# Make wrapper function look like a D-Bus

1727

# signal

1595

1728

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

1596

1729

if name.startswith("_dbus_"):

1597

1730

setattr(call_both, name, attr)

1598

1731

1599

1732

return call_both

1600

1733

# Create the "call_both" function and add it to

1601

1734

# the class

1647

1780

(copy_function(attribute)))

1648

1781

if deprecate:

1649

1782

# Deprecate all alternate interfaces

1650

iname="_AlternateDBusNames_interface_annotation{}"

1783

iname = "_AlternateDBusNames_interface_annotation{}"

1651

1784

for interface_name in interface_names:

1652

1785

1653

1786

@dbus_interface_annotations(interface_name)

1654

1787

def func(self):

1655

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

1656

"true" }

1788

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

1789

"true"}

1657

1790

# Find an unused name

1658

1791

for aname in (iname.format(i)

1659

1792

for i in itertools.count()):

1670

1803

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

1671

1804

(cls, ), attr)

1672

1805

return cls

1673

1806

1674

1807

return wrapper

1675

1808

1676

1809

1678

1811

"se.bsnet.fukt.Mandos"})

1679

1812

class ClientDBus(Client, DBusObjectWithProperties):

1680

1813

"""A Client class using D-Bus

1681

1814

1682

1815

Attributes:

1683

1816

dbus_object_path: dbus.ObjectPath

1684

1817

bus: dbus.SystemBus()

1685

1818

"""

1686

1819

1687

1820

runtime_expansions = (Client.runtime_expansions

1688

1821

+ ("dbus_object_path", ))

1689

1822

1690

1823

_interface = "se.recompile.Mandos.Client"

1691

1824

1692

1825

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

1693

1694

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

1826

1827

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

1695

1828

self.bus = bus

1696

1829

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

1697

1830

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

1703

1836

"/clients/" + client_object_name)

1704

1837

DBusObjectWithProperties.__init__(self, self.bus,

1705

1838

self.dbus_object_path)

1706

1839

1707

1840

def notifychangeproperty(transform_func, dbus_name,

1708

1841

type_func=lambda x: x,

1709

1842

variant_level=1,

1711

1844

_interface=_interface):

1712

1845

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

1713

1846

its changes to DBus.

1714

1847

1715

1848

transform_fun: Function that takes a value and a variant_level

1716

1849

and transforms it to a D-Bus type.

1717

1850

dbus_name: D-Bus name of the variable

1720

1853

variant_level: D-Bus variant level. Default: 1

1721

1854

"""

1722

1855

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

1723

1856

1724

1857

def setter(self, value):

1725

1858

if hasattr(self, "dbus_object_path"):

1726

1859

if (not hasattr(self, attrname) or

1733

1866

else:

1734

1867

dbus_value = transform_func(

1735

1868

type_func(value),

1736

variant_level = variant_level)

1869

variant_level=variant_level)

1737

1870

self.PropertyChanged(dbus.String(dbus_name),

1738

1871

dbus_value)

1739

1872

self.PropertiesChanged(

1740

1873

_interface,

1741

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

1742

dbus_value }),

1874

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

1875

dbus_value}),

1743

1876

dbus.Array())

1744

1877

setattr(self, attrname, value)

1745

1878

1746

1879

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

1747

1880

1748

1881

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1749

1882

approvals_pending = notifychangeproperty(dbus.Boolean,

1750

1883

"ApprovalPending",

1751

type_func = bool)

1884

type_func=bool)

1752

1885

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

1753

1886

last_enabled = notifychangeproperty(datetime_to_dbus,

1754

1887

"LastEnabled")

1755

1888

checker = notifychangeproperty(

1756

1889

dbus.Boolean, "CheckerRunning",

1757

type_func = lambda checker: checker is not None)

1890

type_func=lambda checker: checker is not None)

1758

1891

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1759

1892

"LastCheckedOK")

1760

1893

last_checker_status = notifychangeproperty(dbus.Int16,

1765

1898

"ApprovedByDefault")

1766

1899

approval_delay = notifychangeproperty(

1767

1900

dbus.UInt64, "ApprovalDelay",

1768

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

1901

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

1769

1902

approval_duration = notifychangeproperty(

1770

1903

dbus.UInt64, "ApprovalDuration",

1771

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

1904

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

1772

1905

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

1773

1906

timeout = notifychangeproperty(

1774

1907

dbus.UInt64, "Timeout",

1775

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

1908

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

1776

1909

extended_timeout = notifychangeproperty(

1777

1910

dbus.UInt64, "ExtendedTimeout",

1778

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

1911

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

1779

1912

interval = notifychangeproperty(

1780

1913

dbus.UInt64, "Interval",

1781

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

1914

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

1782

1915

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

1783

1916

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

1784

1917

invalidate_only=True)

1785

1918

1786

1919

del notifychangeproperty

1787

1920

1788

1921

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

1789

1922

try:

1790

1923

self.remove_from_connection()

1793

1926

if hasattr(DBusObjectWithProperties, "__del__"):

1794

1927

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

1795

1928

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

1796

1929

1797

1930

def checker_callback(self, source, condition,

1798

1931

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

1799

1932

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

1815

1948

| self.last_checker_signal),

1816

1949

dbus.String(command))

1817

1950

return ret

1818

1951

1819

1952

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

1820

1953

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

1821

1954

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

1825

1958

# Emit D-Bus signal

1826

1959

self.CheckerStarted(self.current_checker_command)

1827

1960

return r

1828

1961

1829

1962

def _reset_approved(self):

1830

1963

self.approved = None

1831

1964

return False

1832

1965

1833

1966

def approve(self, value=True):

1834

1967

self.approved = value

1835

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

1836

* 1000), self._reset_approved)

1968

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

1969

* 1000), self._reset_approved)

1837

1970

self.send_changedstate()

1838

1839

## D-Bus methods, signals & properties

1840

1841

## Interfaces

1842

1843

## Signals

1844

1971

1972

# D-Bus methods, signals & properties

1973

1974

# Interfaces

1975

1976

# Signals

1977

1845

1978

# CheckerCompleted - signal

1846

1979

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

1847

1980

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

1848

1981

"D-Bus signal"

1849

1982

pass

1850

1983

1851

1984

# CheckerStarted - signal

1852

1985

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

1853

1986

def CheckerStarted(self, command):

1854

1987

"D-Bus signal"

1855

1988

pass

1856

1989

1857

1990

# PropertyChanged - signal

1858

1991

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

1859

1992

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

1860

1993

def PropertyChanged(self, property, value):

1861

1994

"D-Bus signal"

1862

1995

pass

1863

1996

1864

1997

# GotSecret - signal

1865

1998

@dbus.service.signal(_interface)

1866

1999

def GotSecret(self):

1869

2002

server to mandos-client

1870

2003

"""

1871

2004

pass

1872

2005

1873

2006

# Rejected - signal

1874

2007

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

1875

2008

def Rejected(self, reason):

1876

2009

"D-Bus signal"

1877

2010

pass

1878

2011

1879

2012

# NeedApproval - signal

1880

2013

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

1881

2014

def NeedApproval(self, timeout, default):

1882

2015

"D-Bus signal"

1883

2016

return self.need_approval()

1884

1885

## Methods

1886

2017

2018

# Methods

2019

1887

2020

# Approve - method

1888

2021

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

1889

2022

def Approve(self, value):

1890

2023

self.approve(value)

1891

2024

1892

2025

# CheckedOK - method

1893

2026

@dbus.service.method(_interface)

1894

2027

def CheckedOK(self):

1895

2028

self.checked_ok()

1896

2029

1897

2030

# Enable - method

1898

2031

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

1899

2032

@dbus.service.method(_interface)

1900

2033

def Enable(self):

1901

2034

"D-Bus method"

1902

2035

self.enable()

1903

2036

1904

2037

# StartChecker - method

1905

2038

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

1906

2039

@dbus.service.method(_interface)

1907

2040

def StartChecker(self):

1908

2041

"D-Bus method"

1909

2042

self.start_checker()

1910

2043

1911

2044

# Disable - method

1912

2045

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

1913

2046

@dbus.service.method(_interface)

1914

2047

def Disable(self):

1915

2048

"D-Bus method"

1916

2049

self.disable()

1917

2050

1918

2051

# StopChecker - method

1919

2052

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

1920

2053

@dbus.service.method(_interface)

1921

2054

def StopChecker(self):

1922

2055

self.stop_checker()

1923

1924

## Properties

1925

2056

2057

# Properties

2058

1926

2059

# ApprovalPending - property

1927

2060

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

1928

2061

def ApprovalPending_dbus_property(self):

1929

2062

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

1930

2063

1931

2064

# ApprovedByDefault - property

1932

2065

@dbus_service_property(_interface,

1933

2066

signature="b",

1936

2069

if value is None: # get

1937

2070

return dbus.Boolean(self.approved_by_default)

1938

2071

self.approved_by_default = bool(value)

1939

2072

1940

2073

# ApprovalDelay - property

1941

2074

@dbus_service_property(_interface,

1942

2075

signature="t",

1946

2079

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

1947

2080

* 1000)

1948

2081

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

1949

2082

1950

2083

# ApprovalDuration - property

1951

2084

@dbus_service_property(_interface,

1952

2085

signature="t",

1956

2089

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

1957

2090

* 1000)

1958

2091

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

1959

2092

1960

2093

# Name - property

1961

2094

@dbus_annotations(

1962

2095

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

1963

2096

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

1964

2097

def Name_dbus_property(self):

1965

2098

return dbus.String(self.name)

1966

2099

2100

# KeyID - property

2101

@dbus_annotations(

2102

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

2103

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

2104

def KeyID_dbus_property(self):

2105

return dbus.String(self.key_id)

2106

1967

2107

# Fingerprint - property

1968

2108

@dbus_annotations(

1969

2109

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

1970

2110

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

1971

2111

def Fingerprint_dbus_property(self):

1972

2112

return dbus.String(self.fingerprint)

1973

2113

1974

2114

# Host - property

1975

2115

@dbus_service_property(_interface,

1976

2116

signature="s",

1979

2119

if value is None: # get

1980

2120

return dbus.String(self.host)

1981

2121

self.host = str(value)

1982

2122

1983

2123

# Created - property

1984

2124

@dbus_annotations(

1985

2125

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

1986

2126

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

1987

2127

def Created_dbus_property(self):

1988

2128

return datetime_to_dbus(self.created)

1989

2129

1990

2130

# LastEnabled - property

1991

2131

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

1992

2132

def LastEnabled_dbus_property(self):

1993

2133

return datetime_to_dbus(self.last_enabled)

1994

2134

1995

2135

# Enabled - property

1996

2136

@dbus_service_property(_interface,

1997

2137

signature="b",

2003

2143

self.enable()

2004

2144

else:

2005

2145

self.disable()

2006

2146

2007

2147

# LastCheckedOK - property

2008

2148

@dbus_service_property(_interface,

2009

2149

signature="s",

2013

2153

self.checked_ok()

2014

2154

return

2015

2155

return datetime_to_dbus(self.last_checked_ok)

2016

2156

2017

2157

# LastCheckerStatus - property

2018

2158

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

2019

2159

def LastCheckerStatus_dbus_property(self):

2020

2160

return dbus.Int16(self.last_checker_status)

2021

2161

2022

2162

# Expires - property

2023

2163

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

2024

2164

def Expires_dbus_property(self):

2025

2165

return datetime_to_dbus(self.expires)

2026

2166

2027

2167

# LastApprovalRequest - property

2028

2168

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

2029

2169

def LastApprovalRequest_dbus_property(self):

2030

2170

return datetime_to_dbus(self.last_approval_request)

2031

2171

2032

2172

# Timeout - property

2033

2173

@dbus_service_property(_interface,

2034

2174

signature="t",

2049

2189

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

2050

2190

is None):

2051

2191

return

2052

GObject.source_remove(self.disable_initiator_tag)

2053

self.disable_initiator_tag = GObject.timeout_add(

2192

GLib.source_remove(self.disable_initiator_tag)

2193

self.disable_initiator_tag = GLib.timeout_add(

2054

2194

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

2055

2195

self.disable)

2056

2196

2057

2197

# ExtendedTimeout - property

2058

2198

@dbus_service_property(_interface,

2059

2199

signature="t",

2063

2203

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

2064

2204

* 1000)

2065

2205

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

2066

2206

2067

2207

# Interval - property

2068

2208

@dbus_service_property(_interface,

2069

2209

signature="t",

2076

2216

return

2077

2217

if self.enabled:

2078

2218

# Reschedule checker run

2079

GObject.source_remove(self.checker_initiator_tag)

2080

self.checker_initiator_tag = GObject.timeout_add(

2219

GLib.source_remove(self.checker_initiator_tag)

2220

self.checker_initiator_tag = GLib.timeout_add(

2081

2221

value, self.start_checker)

2082

self.start_checker() # Start one now, too

2083

2222

self.start_checker() # Start one now, too

2223

2084

2224

# Checker - property

2085

2225

@dbus_service_property(_interface,

2086

2226

signature="s",

2089

2229

if value is None: # get

2090

2230

return dbus.String(self.checker_command)

2091

2231

self.checker_command = str(value)

2092

2232

2093

2233

# CheckerRunning - property

2094

2234

@dbus_service_property(_interface,

2095

2235

signature="b",

2101

2241

self.start_checker()

2102

2242

else:

2103

2243

self.stop_checker()

2104

2244

2105

2245

# ObjectPath - property

2106

2246

@dbus_annotations(

2107

2247

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

2108

2248

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

2109

2249

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

2110

2250

def ObjectPath_dbus_property(self):

2111

return self.dbus_object_path # is already a dbus.ObjectPath

2112

2251

return self.dbus_object_path # is already a dbus.ObjectPath

2252

2113

2253

# Secret = property

2114

2254

@dbus_annotations(

2115

2255

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

2120

2260

byte_arrays=True)

2121

2261

def Secret_dbus_property(self, value):

2122

2262

self.secret = bytes(value)

2123

2263

2124

2264

del _interface

2125

2265

2126

2266

2127

class ProxyClient(object):

2128

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

2267

class ProxyClient:

2268

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

2129

2269

self._pipe = child_pipe

2130

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

2270

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

2131

2271

if not self._pipe.recv():

2132

raise KeyError(fpr)

2133

2272

raise KeyError(key_id or fpr)

2273

2134

2274

def __getattribute__(self, name):

2135

if name == '_pipe':

2275

if name == "_pipe":

2136

2276

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

2137

self._pipe.send(('getattr', name))

2277

self._pipe.send(("getattr", name))

2138

2278

data = self._pipe.recv()

2139

if data[0] == 'data':

2279

if data[0] == "data":

2140

2280

return data[1]

2141

if data[0] == 'function':

2142

2281

if data[0] == "function":

2282

2143

2283

def func(*args, **kwargs):

2144

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

2284

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

2145

2285

return self._pipe.recv()[1]

2146

2286

2147

2287

return func

2148

2288

2149

2289

def __setattr__(self, name, value):

2150

if name == '_pipe':

2290

if name == "_pipe":

2151

2291

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

2152

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

2292

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

2153

2293

2154

2294

2155

2295

class ClientHandler(socketserver.BaseRequestHandler, object):

2156

2296

"""A class to handle client connections.

2157

2297

2158

2298

Instantiated once for each connection to handle it.

2159

2299

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

2160

2300

2161

2301

def handle(self):

2162

2302

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

2163

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

2164

str(self.client_address))

2165

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

2166

self.server.child_pipe.fileno())

2167

2303

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

2304

str(self.client_address))

2305

log.debug("Pipe FD: %d", self.server.child_pipe.fileno())

2306

2168

2307

session = gnutls.ClientSession(self.request)

2169

2170

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

2171

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

2172

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

2173

# "+DHE-DSS"))

2308

2309

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

2310

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

2311

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

2312

# "+DHE-DSS"))

2174

2313

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

2175

2314

priority = self.server.gnutls_priority

2176

2315

if priority is None:

2177

2316

priority = "NORMAL"

2178

gnutls.priority_set_direct(session._c_object, priority,

2179

None)

2180

2317

gnutls.priority_set_direct(session,

2318

priority.encode("utf-8"), None)

2319

2181

2320

# Start communication using the Mandos protocol

2182

2321

# Get protocol number

2183

2322

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

2184

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

2323

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

2185

2324

try:

2186

2325

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

2187

2326

raise RuntimeError(line)

2188

2327

except (ValueError, IndexError, RuntimeError) as error:

2189

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

2328

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

2190

2329

return

2191

2330

2192

2331

# Start GnuTLS connection

2193

2332

try:

2194

2333

session.handshake()

2195

2334

except gnutls.Error as error:

2196

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

2335

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

2197

2336

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

2198

2337

# established. Just abandon the request.

2199

2338

return

2200

logger.debug("Handshake succeeded")

2201

2339

log.debug("Handshake succeeded")

2340

2202

2341

approval_required = False

2203

2342

try:

2204

try:

2205

fpr = self.fingerprint(

2206

self.peer_certificate(session))

2207

except (TypeError, gnutls.Error) as error:

2208

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

2209

return

2210

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

2211

2212

try:

2213

client = ProxyClient(child_pipe, fpr,

2343

if gnutls.has_rawpk:

2344

fpr = b""

2345

try:

2346

key_id = self.key_id(

2347

self.peer_certificate(session))

2348

except (TypeError, gnutls.Error) as error:

2349

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

2350

return

2351

log.debug("Key ID: %s",

2352

key_id.decode("utf-8",

2353

errors="replace"))

2354

2355

else:

2356

key_id = b""

2357

try:

2358

fpr = self.fingerprint(

2359

self.peer_certificate(session))

2360

except (TypeError, gnutls.Error) as error:

2361

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

2362

return

2363

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

2364

2365

try:

2366

client = ProxyClient(child_pipe, key_id, fpr,

2214

2367

self.client_address)

2215

2368

except KeyError:

2216

2369

return

2217

2370

2218

2371

if client.approval_delay:

2219

2372

delay = client.approval_delay

2220

2373

client.approvals_pending += 1

2221

2374

approval_required = True

2222

2375

2223

2376

while True:

2224

2377

if not client.enabled:

2225

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

2226

client.name)

2378

log.info("Client %s is disabled", client.name)

2227

2379

if self.server.use_dbus:

2228

2380

# Emit D-Bus signal

2229

2381

client.Rejected("Disabled")

2230

2382

return

2231

2383

2232

2384

if client.approved or not client.approval_delay:

2233

#We are approved or approval is disabled

2385

# We are approved or approval is disabled

2234

2386

break

2235

2387

elif client.approved is None:

2236

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

2237

client.name)

2388

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

2389

client.name)

2238

2390

if self.server.use_dbus:

2239

2391

# Emit D-Bus signal

2240

2392

client.NeedApproval(

2241

2393

client.approval_delay.total_seconds()

2242

2394

* 1000, client.approved_by_default)

2243

2395

else:

2244

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

2245

client.name)

2396

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

2397

client.name)

2246

2398

if self.server.use_dbus:

2247

2399

# Emit D-Bus signal

2248

2400

client.Rejected("Denied")

2249

2401

return

2250

2251

#wait until timeout or approved

2402

2403

# wait until timeout or approved

2252

2404

time = datetime.datetime.now()

2253

2405

client.changedstate.acquire()

2254

2406

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

2256

2408

time2 = datetime.datetime.now()

2257

2409

if (time2 - time) >= delay:

2258

2410

if not client.approved_by_default:

2259

logger.warning("Client %s timed out while"

2260

" waiting for approval",

2261

client.name)

2411

log.warning("Client %s timed out while"

2412

" waiting for approval",

2413

client.name)

2262

2414

if self.server.use_dbus:

2263

2415

# Emit D-Bus signal

2264

2416

client.Rejected("Approval timed out")

2267

2419

break

2268

2420

else:

2269

2421

delay -= time2 - time

2270

2422

2271

2423

try:

2272

2424

session.send(client.secret)

2273

2425

except gnutls.Error as error:

2274

logger.warning("gnutls send failed",

2275

exc_info = error)

2426

log.warning("gnutls send failed", exc_info=error)

2276

2427

return

2277

2278

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

2428

2429

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

2279

2430

# bump the timeout using extended_timeout

2280

2431

client.bump_timeout(client.extended_timeout)

2281

2432

if self.server.use_dbus:

2282

2433

# Emit D-Bus signal

2283

2434

client.GotSecret()

2284

2435

2285

2436

finally:

2286

2437

if approval_required:

2287

2438

client.approvals_pending -= 1

2288

2439

try:

2289

2440

session.bye()

2290

2441

except gnutls.Error as error:

2291

logger.warning("GnuTLS bye failed",

2292

exc_info=error)

2293

2442

log.warning("GnuTLS bye failed", exc_info=error)

2443

2294

2444

@staticmethod

2295

2445

def peer_certificate(session):

2296

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

2297

# If not an OpenPGP certificate...

2298

if (gnutls.certificate_type_get(session._c_object)

2299

!= gnutls.CRT_OPENPGP):

2446

"Return the peer's certificate as a bytestring"

2447

try:

2448

cert_type = gnutls.certificate_type_get2(

2449

session, gnutls.CTYPE_PEERS)

2450

except AttributeError:

2451

cert_type = gnutls.certificate_type_get(session)

2452

if gnutls.has_rawpk:

2453

valid_cert_types = frozenset((gnutls.CRT_RAWPK,))

2454

else:

2455

valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))

2456

# If not a valid certificate type...

2457

if cert_type not in valid_cert_types:

2458

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

2459

valid_cert_types)

2300

2460

# ...return invalid data

2301

2461

return b""

2302

2462

list_size = ctypes.c_uint(1)

2303

2463

cert_list = (gnutls.certificate_get_peers

2304

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

2464

(session, ctypes.byref(list_size)))

2305

2465

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

2306

2466

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

2307

2467

if list_size.value == 0:

2308

2468

return None

2309

2469

cert = cert_list[0]

2310

2470

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

2311

2471

2472

@staticmethod

2473

def key_id(certificate):

2474

"Convert a certificate bytestring to a hexdigit key ID"

2475

# New GnuTLS "datum" with the public key

2476

datum = gnutls.datum_t(

2477

ctypes.cast(ctypes.c_char_p(certificate),

2478

ctypes.POINTER(ctypes.c_ubyte)),

2479

ctypes.c_uint(len(certificate)))

2480

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

2481

# New empty GnuTLS certificate

2482

pubkey = gnutls.pubkey_t()

2483

gnutls.pubkey_init(ctypes.byref(pubkey))

2484

# Import the raw public key into the certificate

2485

gnutls.pubkey_import(pubkey,

2486

ctypes.byref(datum),

2487

gnutls.X509_FMT_DER)

2488

# New buffer for the key ID

2489

buf = ctypes.create_string_buffer(32)

2490

buf_len = ctypes.c_size_t(len(buf))

2491

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

2492

gnutls.pubkey_get_key_id(

2493

pubkey,

2494

gnutls.KEYID_USE_SHA256,

2495

ctypes.cast(ctypes.byref(buf),

2496

ctypes.POINTER(ctypes.c_ubyte)),

2497

ctypes.byref(buf_len))

2498

# Deinit the certificate

2499

gnutls.pubkey_deinit(pubkey)

2500

2501

# Convert the buffer to a Python bytestring

2502

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

2503

# Convert the bytestring to hexadecimal notation

2504

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

2505

return hex_key_id

2506

2312

2507

@staticmethod

2313

2508

def fingerprint(openpgp):

2314

2509

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2329

2524

ctypes.byref(crtverify))

2330

2525

if crtverify.value != 0:

2331

2526

gnutls.openpgp_crt_deinit(crt)

2332

raise gnutls.CertificateSecurityError("Verify failed")

2527

raise gnutls.CertificateSecurityError(code

2528

=crtverify.value)

2333

2529

# New buffer for the fingerprint

2334

2530

buf = ctypes.create_string_buffer(20)

2335

2531

buf_len = ctypes.c_size_t()

2345

2541

return hex_fpr

2346

2542

2347

2543

2348

class MultiprocessingMixIn(object):

2544

class MultiprocessingMixIn:

2349

2545

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

2350

2546

2351

2547

def sub_process_main(self, request, address):

2352

2548

try:

2353

2549

self.finish_request(request, address)

2354

2550

except Exception:

2355

2551

self.handle_error(request, address)

2356

2552

self.close_request(request)

2357

2553

2358

2554

def process_request(self, request, address):

2359

2555

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

2360

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

2361

args = (request, address))

2556

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

2557

args=(request, address))

2362

2558

proc.start()

2363

2559

return proc

2364

2560

2365

2561

2366

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2562

class MultiprocessingMixInWithPipe(MultiprocessingMixIn):

2367

2563

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

2368

2564

2369

2565

def process_request(self, request, client_address):

2370

2566

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

2371

2567

2372

2568

This function creates a new pipe in self.pipe

2373

2569

"""

2374

2570

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2375

2571

2376

2572

proc = MultiprocessingMixIn.process_request(self, request,

2377

2573

client_address)

2378

2574

self.child_pipe.close()

2379

2575

self.add_pipe(parent_pipe, proc)

2380

2576

2381

2577

def add_pipe(self, parent_pipe, proc):

2382

2578

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

2383

2579

raise NotImplementedError()

2384

2580

2385

2581

2386

2582

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2387

socketserver.TCPServer, object):

2388

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

2389

2583

socketserver.TCPServer):

2584

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

2585

2390

2586

Attributes:

2391

2587

enabled: Boolean; whether this server is activated yet

2392

2588

interface: None or a network interface name (string)

2393

2589

use_ipv6: Boolean; to use IPv6 or not

2394

2590

"""

2395

2591

2396

2592

def __init__(self, server_address, RequestHandlerClass,

2397

2593

interface=None,

2398

2594

use_ipv6=True,

2408

2604

self.socketfd = socketfd

2409

2605

# Save the original socket.socket() function

2410

2606

self.socket_socket = socket.socket

2607

2411

2608

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

2412

#

2609

#

2413

2610

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

2414

2611

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

2415

2612

# patching socket.socket.)

2416

#

2613

#

2417

2614

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

2418

2615

@functools.wraps(socket.socket)

2419

2616

def socket_wrapper(*args, **kwargs):

2431

2628

# socket_wrapper(), if socketfd was set.

2432

2629

socketserver.TCPServer.__init__(self, server_address,

2433

2630

RequestHandlerClass)

2434

2631

2435

2632

def server_bind(self):

2436

2633

"""This overrides the normal server_bind() function

2437

2634

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

2438

2635

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

2636

global SO_BINDTODEVICE

2439

2637

if self.interface is not None:

2440

2638

if SO_BINDTODEVICE is None:

2441

logger.error("SO_BINDTODEVICE does not exist;"

2442

" cannot bind to interface %s",

2443

self.interface)

2444

else:

2445

try:

2446

self.socket.setsockopt(

2447

socket.SOL_SOCKET, SO_BINDTODEVICE,

2448

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

2449

except socket.error as error:

2450

if error.errno == errno.EPERM:

2451

logger.error("No permission to bind to"

2452

" interface %s", self.interface)

2453

elif error.errno == errno.ENOPROTOOPT:

2454

logger.error("SO_BINDTODEVICE not available;"

2455

" cannot bind to interface %s",

2456

self.interface)

2457

elif error.errno == errno.ENODEV:

2458

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

2459

" cannot bind", self.interface)

2460

else:

2461

raise

2639

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

2640

# common enough.

2641

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

2642

SO_BINDTODEVICE = 25

2643

try:

2644

self.socket.setsockopt(

2645

socket.SOL_SOCKET, SO_BINDTODEVICE,

2646

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

2647

except socket.error as error:

2648

if error.errno == errno.EPERM:

2649

log.error("No permission to bind to interface %s",

2650

self.interface)

2651

elif error.errno == errno.ENOPROTOOPT:

2652

log.error("SO_BINDTODEVICE not available; cannot"

2653

" bind to interface %s", self.interface)

2654

elif error.errno == errno.ENODEV:

2655

log.error("Interface %s does not exist, cannot"

2656

" bind", self.interface)

2657

else:

2658

raise

2462

2659

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

2463

2660

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

2661

if self.server_address[1]:

2662

self.allow_reuse_address = True

2464

2663

if not self.server_address[0]:

2465

2664

if self.address_family == socket.AF_INET6:

2466

any_address = "::" # in6addr_any

2665

any_address = "::" # in6addr_any

2467

2666

else:

2468

any_address = "0.0.0.0" # INADDR_ANY

2667

any_address = "0.0.0.0" # INADDR_ANY

2469

2668

self.server_address = (any_address,

2470

2669

self.server_address[1])

2471

2670

elif not self.server_address[1]:

2481

2680

2482

2681

class MandosServer(IPv6_TCPServer):

2483

2682

"""Mandos server.

2484

2683

2485

2684

Attributes:

2486

2685

clients: set of Client objects

2487

2686

gnutls_priority GnuTLS priority string

2488

2687

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

2489

2490

Assumes a GObject.MainLoop event loop.

2688

2689

Assumes a GLib.MainLoop event loop.

2491

2690

"""

2492

2691

2493

2692

def __init__(self, server_address, RequestHandlerClass,

2494

2693

interface=None,

2495

2694

use_ipv6=True,

2505

2704

self.gnutls_priority = gnutls_priority

2506

2705

IPv6_TCPServer.__init__(self, server_address,

2507

2706

RequestHandlerClass,

2508

interface = interface,

2509

use_ipv6 = use_ipv6,

2510

socketfd = socketfd)

2511

2707

interface=interface,

2708

use_ipv6=use_ipv6,

2709

socketfd=socketfd)

2710

2512

2711

def server_activate(self):

2513

2712

if self.enabled:

2514

2713

return socketserver.TCPServer.server_activate(self)

2515

2714

2516

2715

def enable(self):

2517

2716

self.enabled = True

2518

2717

2519

2718

def add_pipe(self, parent_pipe, proc):

2520

2719

# Call "handle_ipc" for both data and EOF events

2521

GObject.io_add_watch(

2522

parent_pipe.fileno(),

2523

GObject.IO_IN | GObject.IO_HUP,

2720

GLib.io_add_watch(

2721

GLib.IOChannel.unix_new(parent_pipe.fileno()),

2722

GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,

2524

2723

functools.partial(self.handle_ipc,

2525

parent_pipe = parent_pipe,

2526

proc = proc))

2527

2724

parent_pipe=parent_pipe,

2725

proc=proc))

2726

2528

2727

def handle_ipc(self, source, condition,

2529

2728

parent_pipe=None,

2530

proc = None,

2729

proc=None,

2531

2730

client_object=None):

2532

2731

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

2533

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

2732

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

2534

2733

# Wait for other process to exit

2535

2734

proc.join()

2536

2735

return False

2537

2736

2538

2737

# Read a request from the child

2539

2738

request = parent_pipe.recv()

2540

2739

command = request[0]

2541

2542

if command == 'init':

2543

fpr = request[1]

2544

address = request[2]

2545

2740

2741

if command == "init":

2742

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

2743

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

2744

address = request[3]

2745

2546

2746

for c in self.clients.values():

2547

if c.fingerprint == fpr:

2747

if key_id == ("E3B0C44298FC1C149AFBF4C8996FB924"

2748

"27AE41E4649B934CA495991B7852B855"):

2749

continue

2750

if key_id and c.key_id == key_id:

2751

client = c

2752

break

2753

if fpr and c.fingerprint == fpr:

2548

2754

client = c

2549

2755

break

2550

2756

else:

2551

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

2552

"dress: %s", fpr, address)

2757

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

2758

" %s", key_id or fpr, address)

2553

2759

if self.use_dbus:

2554

2760

# Emit D-Bus signal

2555

mandos_dbus_service.ClientNotFound(fpr,

2761

mandos_dbus_service.ClientNotFound(key_id or fpr,

2556

2762

address[0])

2557

2763

parent_pipe.send(False)

2558

2764

return False

2559

2560

GObject.io_add_watch(

2561

parent_pipe.fileno(),

2562

GObject.IO_IN | GObject.IO_HUP,

2765

2766

GLib.io_add_watch(

2767

GLib.IOChannel.unix_new(parent_pipe.fileno()),

2768

GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,

2563

2769

functools.partial(self.handle_ipc,

2564

parent_pipe = parent_pipe,

2565

proc = proc,

2566

client_object = client))

2770

parent_pipe=parent_pipe,

2771

proc=proc,

2772

client_object=client))

2567

2773

parent_pipe.send(True)

2568

2774

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

2569

2775

# same fileno

2570

2776

return False

2571

if command == 'funcall':

2777

if command == "funcall":

2572

2778

funcname = request[1]

2573

2779

args = request[2]

2574

2780

kwargs = request[3]

2575

2576

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

2781

2782

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

2577

2783

funcname)(*args,

2578

2784

**kwargs)))

2579

2580

if command == 'getattr':

2785

2786

if command == "getattr":

2581

2787

attrname = request[1]

2582

2788

if isinstance(client_object.__getattribute__(attrname),

2583

collections.Callable):

2584

parent_pipe.send(('function', ))

2789

collections.abc.Callable):

2790

parent_pipe.send(("function", ))

2585

2791

else:

2586

2792

parent_pipe.send((

2587

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

2588

2589

if command == 'setattr':

2793

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

2794

2795

if command == "setattr":

2590

2796

attrname = request[1]

2591

2797

value = request[2]

2592

2798

setattr(client_object, attrname, value)

2593

2799

2594

2800

return True

2595

2801

2596

2802

2597

2803

def rfc3339_duration_to_delta(duration):

2598

2804

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

2599

2600

>>> rfc3339_duration_to_delta("P7D")

2601

datetime.timedelta(7)

2602

>>> rfc3339_duration_to_delta("PT60S")

2603

datetime.timedelta(0, 60)

2604

>>> rfc3339_duration_to_delta("PT60M")

2605

datetime.timedelta(0, 3600)

2606

>>> rfc3339_duration_to_delta("PT24H")

2607

datetime.timedelta(1)

2608

>>> rfc3339_duration_to_delta("P1W")

2609

datetime.timedelta(7)

2610

>>> rfc3339_duration_to_delta("PT5M30S")

2611

datetime.timedelta(0, 330)

2612

>>> rfc3339_duration_to_delta("P1DT3M20S")

2613

datetime.timedelta(1, 200)

2805

2806

>>> timedelta = datetime.timedelta

2807

>>> rfc3339_duration_to_delta("P7D") == timedelta(7)

2808

True

2809

>>> rfc3339_duration_to_delta("PT60S") == timedelta(0, 60)

2810

True

2811

>>> rfc3339_duration_to_delta("PT60M") == timedelta(0, 3600)

2812

True

2813

>>> rfc3339_duration_to_delta("PT24H") == timedelta(1)

2814

True

2815

>>> rfc3339_duration_to_delta("P1W") == timedelta(7)

2816

True

2817

>>> rfc3339_duration_to_delta("PT5M30S") == timedelta(0, 330)

2818

True

2819

>>> rfc3339_duration_to_delta("P1DT3M20S") == timedelta(1, 200)

2820

True

2821

>>> del timedelta

2614

2822

"""

2615

2823

2616

2824

# Parsing an RFC 3339 duration with regular expressions is not

2617

2825

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

2618

2826

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

2619

2827

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

2620

2828

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

2621

2829

# avoid excessive use of external libraries.

2622

2830

2623

2831

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

2624

2832

Token = collections.namedtuple("Token", (

2625

2833

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

2658

2866

frozenset((token_year, token_month,

2659

2867

token_day, token_time,

2660

2868

token_week)))

2661

# Define starting values

2662

value = datetime.timedelta() # Value so far

2869

# Define starting values:

2870

# Value so far

2871

value = datetime.timedelta()

2663

2872

found_token = None

2664

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

2665

s = duration # String left to parse

2873

# Following valid tokens

2874

followers = frozenset((token_duration, ))

2875

# String left to parse

2876

s = duration

2666

2877

# Loop until end token is found

2667

2878

while found_token is not token_end:

2668

2879

# Search for any currently valid tokens

2692

2903

2693

2904

def string_to_delta(interval):

2694

2905

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

2695

2696

>>> string_to_delta('7d')

2697

datetime.timedelta(7)

2698

>>> string_to_delta('60s')

2699

datetime.timedelta(0, 60)

2700

>>> string_to_delta('60m')

2701

datetime.timedelta(0, 3600)

2702

>>> string_to_delta('24h')

2703

datetime.timedelta(1)

2704

>>> string_to_delta('1w')

2705

datetime.timedelta(7)

2706

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

2707

datetime.timedelta(0, 330)

2906

2907

>>> string_to_delta("7d") == datetime.timedelta(7)

2908

True

2909

>>> string_to_delta("60s") == datetime.timedelta(0, 60)

2910

True

2911

>>> string_to_delta("60m") == datetime.timedelta(0, 3600)

2912

True

2913

>>> string_to_delta("24h") == datetime.timedelta(1)

2914

True

2915

>>> string_to_delta("1w") == datetime.timedelta(7)

2916

True

2917

>>> string_to_delta("5m 30s") == datetime.timedelta(0, 330)

2918

True

2708

2919

"""

2709

2920

2710

2921

try:

2711

2922

return rfc3339_duration_to_delta(interval)

2712

2923

except ValueError:

2713

2924

pass

2714

2925

2715

2926

timevalue = datetime.timedelta(0)

2716

2927

for s in interval.split():

2717

2928

try:

2735

2946

return timevalue

2736

2947

2737

2948

2738

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

2949

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

2739

2950

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

2740

2951

2741

2952

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

2742

2953

if os.fork():

2743

2954

sys.exit()

2761

2972

2762

2973

2763

2974

def main():

2764

2975

2765

2976

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

2766

2977

# Parsing of options, both command line and config file

2767

2978

2768

2979

parser = argparse.ArgumentParser()

2769

2980

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

2770

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

2981

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

2771

2982

help="show version number and exit")

2772

2983

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

2773

2984

help="Bind to interface IF")

2809

3020

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

2810

3021

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

2811

3022

default=None)

2812

3023

2813

3024

options = parser.parse_args()

2814

2815

if options.check:

2816

import doctest

2817

fail_count, test_count = doctest.testmod()

2818

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

2819

3025

2820

3026

# Default values for config file for server-global settings

2821

server_defaults = { "interface": "",

2822

"address": "",

2823

"port": "",

2824

"debug": "False",

2825

"priority":

2826

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

2827

":+SIGN-DSA-SHA256",

2828

"servicename": "Mandos",

2829

"use_dbus": "True",

2830

"use_ipv6": "True",

2831

"debuglevel": "",

2832

"restore": "True",

2833

"socket": "",

2834

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

2835

"foreground": "False",

2836

"zeroconf": "True",

2837

}

2838

3027

if gnutls.has_rawpk:

3028

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

3029

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

3030

else:

3031

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

3032

":+SIGN-DSA-SHA256")

3033

server_defaults = {"interface": "",

3034

"address": "",

3035

"port": "",

3036

"debug": "False",

3037

"priority": priority,

3038

"servicename": "Mandos",

3039

"use_dbus": "True",

3040

"use_ipv6": "True",

3041

"debuglevel": "",

3042

"restore": "True",

3043

"socket": "",

3044

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

3045

"foreground": "False",

3046

"zeroconf": "True",

3047

}

3048

del priority

3049

2839

3050

# Parse config file for server-global settings

2840

server_config = configparser.SafeConfigParser(server_defaults)

3051

server_config = configparser.ConfigParser(server_defaults)

2841

3052

del server_defaults

2842

3053

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

2843

# Convert the SafeConfigParser object to a dict

3054

# Convert the ConfigParser object to a dict

2844

3055

server_settings = server_config.defaults()

2845

3056

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

2846

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

3057

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

3058

"foreground", "zeroconf"):

2847

3059

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

2848

3060

option)

2849

3061

if server_settings["port"]:

2859

3071

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

2860

3072

["socket"])

2861

3073

del server_config

2862

3074

2863

3075

# Override the settings from the config file with command line

2864

3076

# options, if set.

2865

3077

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

2883

3095

if server_settings["debug"]:

2884

3096

server_settings["foreground"] = True

2885

3097

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

2886

3098

2887

3099

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

2888

3100

2889

3101

if (not server_settings["zeroconf"]

2890

3102

and not (server_settings["port"]

2891

3103

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

2892

3104

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

2893

3105

2894

3106

# For convenience

2895

3107

debug = server_settings["debug"]

2896

3108

debuglevel = server_settings["debuglevel"]

2900

3112

stored_state_file)

2901

3113

foreground = server_settings["foreground"]

2902

3114

zeroconf = server_settings["zeroconf"]

2903

3115

2904

3116

if debug:

2905

3117

initlogger(debug, logging.DEBUG)

2906

3118

else:

2909

3121

else:

2910

3122

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

2911

3123

initlogger(debug, level)

2912

3124

2913

3125

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

2914

3126

syslogger.setFormatter(

2915

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

2916

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

3127

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

3128

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

2917

3129

server_settings["servicename"])))

2918

3130

2919

3131

# Parse config file with clients

2920

client_config = configparser.SafeConfigParser(Client

2921

.client_defaults)

3132

client_config = configparser.ConfigParser(Client.client_defaults)

2922

3133

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

2923

3134

"clients.conf"))

2924

3135

2925

3136

global mandos_dbus_service

2926

3137

mandos_dbus_service = None

2927

3138

2928

3139

socketfd = None

2929

3140

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

2930

3141

socketfd = server_settings["socket"]

2944

3155

try:

2945

3156

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

2946

3157

except IOError as e:

2947

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

2948

exc_info=e)

2949

3158

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

3159

exc_info=e)

3160

2950

3161

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

2951

3162

("mandos", "mandos"),

2952

3163

("nobody", "nogroup")):

2962

3173

try:

2963

3174

os.setgid(gid)

2964

3175

os.setuid(uid)

2965

if debug:

2966

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

2967

gid))

3176

log.debug("Did setuid/setgid to %s:%s", uid, gid)

2968

3177

except OSError as error:

2969

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

2970

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

3178

log.warning("Failed to setuid/setgid to %s:%s: %s", uid, gid,

3179

os.strerror(error.errno))

2971

3180

if error.errno != errno.EPERM:

2972

3181

raise

2973

3182

2974

3183

if debug:

2975

3184

# Enable all possible GnuTLS debugging

2976

3185

2977

3186

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

2978

3187

# - GnuTLS manual

2979

3188

gnutls.global_set_log_level(11)

2980

3189

2981

3190

@gnutls.log_func

2982

3191

def debug_gnutls(level, string):

2983

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

2984

3192

log.debug("GnuTLS: %s",

3193

string[:-1].decode("utf-8", errors="replace"))

3194

2985

3195

gnutls.global_set_log_function(debug_gnutls)

2986

3196

2987

3197

# Redirect stdin so all checkers get /dev/null

2988

3198

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

2989

3199

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

2990

3200

if null > 2:

2991

3201

os.close(null)

2992

3202

2993

3203

# Need to fork before connecting to D-Bus

2994

3204

if not foreground:

2995

3205

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

2996

3206

daemon()

2997

2998

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

2999

# need to inform GObject that threads will be used.

3000

GObject.threads_init()

3001

3207

3208

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

3209

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

3210

# need to inform GLib that threads will be used.

3211

GLib.threads_init()

3212

3002

3213

global main_loop

3003

3214

# From the Avahi example code

3004

3215

DBusGMainLoop(set_as_default=True)

3005

main_loop = GObject.MainLoop()

3216

main_loop = GLib.MainLoop()

3006

3217

bus = dbus.SystemBus()

3007

3218

# End of Avahi example code

3008

3219

if use_dbus:

3014

3225

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

3015

3226

do_not_queue=True)

3016

3227

except dbus.exceptions.DBusException as e:

3017

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

3228

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

3018

3229

use_dbus = False

3019

3230

server_settings["use_dbus"] = False

3020

3231

tcp_server.use_dbus = False

3021

3232

if zeroconf:

3022

3233

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3023

3234

service = AvahiServiceToSyslog(

3024

name = server_settings["servicename"],

3025

servicetype = "_mandos._tcp",

3026

protocol = protocol,

3027

bus = bus)

3235

name=server_settings["servicename"],

3236

servicetype="_mandos._tcp",

3237

protocol=protocol,

3238

bus=bus)

3028

3239

if server_settings["interface"]:

3029

3240

service.interface = if_nametoindex(

3030

3241

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

3031

3242

3032

3243

global multiprocessing_manager

3033

3244

multiprocessing_manager = multiprocessing.Manager()

3034

3245

3035

3246

client_class = Client

3036

3247

if use_dbus:

3037

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

3038

3248

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

3249

3039

3250

client_settings = Client.config_parser(client_config)

3040

3251

old_client_settings = {}

3041

3252

clients_data = {}

3042

3253

3043

3254

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

3044

3255

global wnull

3045

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

3256

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

3046

3257

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

3047

3258

# mode

3048

3259

if debug or not foreground:

3049

3260

wnull.close()

3050

3261

3051

3262

# Get client data and settings from last running state.

3052

3263

if server_settings["restore"]:

3053

3264

try:

3054

3265

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

3055

if sys.version_info.major == 2:

3266

if sys.version_info.major == 2:

3056

3267

clients_data, old_client_settings = pickle.load(

3057

3268

stored_state)

3058

3269

else:

3059

3270

bytes_clients_data, bytes_old_client_settings = (

3060

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

3061

### Fix bytes to strings

3062

## clients_data

3271

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

3272

# Fix bytes to strings

3273

# clients_data

3063

3274

# .keys()

3064

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

3065

if isinstance(key, bytes)

3066

else key): value

3067

for key, value in

3068

bytes_clients_data.items() }

3275

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

3276

if isinstance(key, bytes)

3277

else key): value

3278

for key, value in

3279

bytes_clients_data.items()}

3069

3280

del bytes_clients_data

3070

3281

for key in clients_data:

3071

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

3072

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

3073

for k, v in

3074

clients_data[key].items() }

3282

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

3283

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

3284

for k, v in

3285

clients_data[key].items()}

3075

3286

clients_data[key] = value

3076

3287

# .client_structure

3077

3288

value["client_structure"] = [

3078

3289

(s.decode("utf-8")

3079

3290

if isinstance(s, bytes)

3080

3291

else s) for s in

3081

value["client_structure"] ]

3082

# .name & .host

3083

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

3292

value["client_structure"]]

3293

# .name, .host, and .checker_command

3294

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

3084

3295

if isinstance(value[k], bytes):

3085

3296

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

3086

## old_client_settings

3297

if "key_id" not in value:

3298

value["key_id"] = ""

3299

elif "fingerprint" not in value:

3300

value["fingerprint"] = ""

3301

# old_client_settings

3087

3302

# .keys()

3088

3303

old_client_settings = {

3089

3304

(key.decode("utf-8")

3090

3305

if isinstance(key, bytes)

3091

3306

else key): value

3092

3307

for key, value in

3093

bytes_old_client_settings.items() }

3308

bytes_old_client_settings.items()}

3094

3309

del bytes_old_client_settings

3095

# .host

3310

# .host and .checker_command

3096

3311

for value in old_client_settings.values():

3097

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

3098

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

3099

.decode("utf-8"))

3312

for attribute in ("host", "checker_command"):

3313

if isinstance(value[attribute], bytes):

3314

value[attribute] = (value[attribute]

3315

.decode("utf-8"))

3100

3316

os.remove(stored_state_path)

3101

3317

except IOError as e:

3102

3318

if e.errno == errno.ENOENT:

3103

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

3104

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

3319

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

3320

" %s", os.strerror(e.errno))

3105

3321

else:

3106

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

3107

exc_info=e)

3322

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

3323

exc_info=e)

3108

3324

raise

3109

3325

except EOFError as e:

3110

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

3111

"EOFError:",

3112

exc_info=e)

3113

3326

log.warning("Could not load persistent state: EOFError:",

3327

exc_info=e)

3328

3114

3329

with PGPEngine() as pgp:

3115

3330

for client_name, client in clients_data.items():

3116

3331

# Skip removed clients

3117

3332

if client_name not in client_settings:

3118

3333

continue

3119

3334

3120

3335

# Decide which value to use after restoring saved state.

3121

3336

# We have three different values: Old config file,

3122

3337

# new config file, and saved state.

3133

3348

client[name] = value

3134

3349

except KeyError:

3135

3350

pass

3136

3351

3137

3352

# Clients who has passed its expire date can still be

3138

3353

# enabled if its last checker was successful. A Client

3139

3354

# whose checker succeeded before we stored its state is

3142

3357

if client["enabled"]:

3143

3358

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

3144

3359

if not client["last_checked_ok"]:

3145

logger.warning(

3146

"disabling client {} - Client never "

3147

"performed a successful checker".format(

3148

client_name))

3360

log.warning("disabling client %s - Client"

3361

" never performed a successful"

3362

" checker", client_name)

3149

3363

client["enabled"] = False

3150

3364

elif client["last_checker_status"] != 0:

3151

logger.warning(

3152

"disabling client {} - Client last"

3153

" checker failed with error code"

3154

" {}".format(

3155

client_name,

3156

client["last_checker_status"]))

3365

log.warning("disabling client %s - Client"

3366

" last checker failed with error"

3367

" code %s", client_name,

3368

client["last_checker_status"])

3157

3369

client["enabled"] = False

3158

3370

else:

3159

3371

client["expires"] = (

3160

3372

datetime.datetime.utcnow()

3161

3373

+ client["timeout"])

3162

logger.debug("Last checker succeeded,"

3163

" keeping {} enabled".format(

3164

client_name))

3374

log.debug("Last checker succeeded, keeping %s"

3375

" enabled", client_name)

3165

3376

try:

3166

3377

client["secret"] = pgp.decrypt(

3167

3378

client["encrypted_secret"],

3168

3379

client_settings[client_name]["secret"])

3169

3380

except PGPError:

3170

3381

# If decryption fails, we use secret from new settings

3171

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

3172

client_name))

3382

log.debug("Failed to decrypt %s old secret",

3383

client_name)

3173

3384

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

3174

3385

["secret"])

3175

3386

3176

3387

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

3177

3388

for client_name in (set(old_client_settings)

3178

3389

- set(client_settings)):

3180

3391

for client_name in (set(client_settings)

3181

3392

- set(old_client_settings)):

3182

3393

clients_data[client_name] = client_settings[client_name]

3183

3394

3184

3395

# Create all client objects

3185

3396

for client_name, client in clients_data.items():

3186

3397

tcp_server.clients[client_name] = client_class(

3187

name = client_name,

3188

settings = client,

3189

server_settings = server_settings)

3190

3398

name=client_name,

3399

settings=client,

3400

server_settings=server_settings)

3401

3191

3402

if not tcp_server.clients:

3192

logger.warning("No clients defined")

3193

3403

log.warning("No clients defined")

3404

3194

3405

if not foreground:

3195

3406

if pidfile is not None:

3196

3407

pid = os.getpid()

3198

3409

with pidfile:

3199

3410

print(pid, file=pidfile)

3200

3411

except IOError:

3201

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

3202

pidfilename, pid)

3412

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

3413

pidfilename, pid)

3203

3414

del pidfile

3204

3415

del pidfilename

3205

3206

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

3207

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

3208

3416

3417

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

3418

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3419

lambda: main_loop.quit() and False)

3420

3209

3421

if use_dbus:

3210

3422

3211

3423

@alternate_dbus_interfaces(

3212

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

3424

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

3213

3425

class MandosDBusService(DBusObjectWithObjectManager):

3214

3426

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

3215

3427

3216

3428

def __init__(self):

3217

3429

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

3218

3430

3219

3431

_interface = "se.recompile.Mandos"

3220

3432

3221

3433

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

3222

3434

def ClientAdded(self, objpath):

3223

3435

"D-Bus signal"

3224

3436

pass

3225

3437

3226

3438

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

3227

def ClientNotFound(self, fingerprint, address):

3439

def ClientNotFound(self, key_id, address):

3228

3440

"D-Bus signal"

3229

3441

pass

3230

3442

3231

3443

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

3232

3444

"true"})

3233

3445

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

3234

3446

def ClientRemoved(self, objpath, name):

3235

3447

"D-Bus signal"

3236

3448

pass

3237

3449

3238

3450

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

3239

3451

"true"})

3240

3452

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

3242

3454

"D-Bus method"

3243

3455

return dbus.Array(c.dbus_object_path for c in

3244

3456

tcp_server.clients.values())

3245

3457

3246

3458

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

3247

3459

"true"})

3248

3460

@dbus.service.method(_interface,

3250

3462

def GetAllClientsWithProperties(self):

3251

3463

"D-Bus method"

3252

3464

return dbus.Dictionary(

3253

{ c.dbus_object_path: c.GetAll(

3465

{c.dbus_object_path: c.GetAll(

3254

3466

"se.recompile.Mandos.Client")

3255

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

3467

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

3256

3468

signature="oa{sv}")

3257

3469

3258

3470

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

3259

3471

def RemoveClient(self, object_path):

3260

3472

"D-Bus method"

3268

3480

self.client_removed_signal(c)

3269

3481

return

3270

3482

raise KeyError(object_path)

3271

3483

3272

3484

del _interface

3273

3485

3274

3486

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3275

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

3487

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

3276

3488

def GetManagedObjects(self):

3277

3489

"""D-Bus method"""

3278

3490

return dbus.Dictionary(

3279

{ client.dbus_object_path:

3280

dbus.Dictionary(

3281

{ interface: client.GetAll(interface)

3282

for interface in

3283

client._get_all_interface_names()})

3284

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

3285

3491

{client.dbus_object_path:

3492

dbus.Dictionary(

3493

{interface: client.GetAll(interface)

3494

for interface in

3495

client._get_all_interface_names()})

3496

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

3497

3286

3498

def client_added_signal(self, client):

3287

3499

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

3288

3500

if use_dbus:

3290

3502

self.InterfacesAdded(

3291

3503

client.dbus_object_path,

3292

3504

dbus.Dictionary(

3293

{ interface: client.GetAll(interface)

3294

for interface in

3295

client._get_all_interface_names()}))

3505

{interface: client.GetAll(interface)

3506

for interface in

3507

client._get_all_interface_names()}))

3296

3508

# Old signal

3297

3509

self.ClientAdded(client.dbus_object_path)

3298

3510

3299

3511

def client_removed_signal(self, client):

3300

3512

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

3301

3513

if use_dbus:

3306

3518

# Old signal

3307

3519

self.ClientRemoved(client.dbus_object_path,

3308

3520

client.name)

3309

3521

3310

3522

mandos_dbus_service = MandosDBusService()

3311

3523

3524

# Save modules to variables to exempt the modules from being

3525

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

3526

mp = multiprocessing

3527

wn = wnull

3528

3312

3529

def cleanup():

3313

3530

"Cleanup function; run on exit"

3314

3531

if zeroconf:

3315

3532

service.cleanup()

3316

3317

multiprocessing.active_children()

3318

wnull.close()

3533

3534

mp.active_children()

3535

wn.close()

3319

3536

if not (tcp_server.clients or client_settings):

3320

3537

return

3321

3538

3322

3539

# Store client before exiting. Secrets are encrypted with key

3323

3540

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

3324

3541

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

3329

3546

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

3330

3547

key)

3331

3548

client_dict = {}

3332

3549

3333

3550

# A list of attributes that can not be pickled

3334

3551

# + secret.

3335

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

3336

"checker", "server_settings" }

3552

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

3553

"checker", "server_settings"}

3337

3554

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

3338

3555

.Object):

3339

3556

exclude.add(name)

3340

3557

3341

3558

client_dict["encrypted_secret"] = (client

3342

3559

.encrypted_secret)

3343

3560

for attr in client.client_structure:

3344

3561

if attr not in exclude:

3345

3562

client_dict[attr] = getattr(client, attr)

3346

3563

3347

3564

clients[client.name] = client_dict

3348

3565

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

3349

3566

3350

3567

try:

3351

3568

with tempfile.NamedTemporaryFile(

3352

mode='wb',

3569

mode="wb",

3353

3570

suffix=".pickle",

3354

prefix='clients-',

3571

prefix="clients-",

3355

3572

dir=os.path.dirname(stored_state_path),

3356

3573

delete=False) as stored_state:

3357

3574

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

3358

protocol = 2)

3575

protocol=2)

3359

3576

tempname = stored_state.name

3360

3577

os.rename(tempname, stored_state_path)

3361

3578

except (IOError, OSError) as e:

3365

3582

except NameError:

3366

3583

pass

3367

3584

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

3368

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

3369

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

3585

log.warning("Could not save persistent state: %s",

3586

os.strerror(e.errno))

3370

3587

else:

3371

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

3372

exc_info=e)

3588

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

3589

exc_info=e)

3373

3590

raise

3374

3591

3375

3592

# Delete all clients, and settings from config

3376

3593

while tcp_server.clients:

3377

3594

name, client = tcp_server.clients.popitem()

3383

3600

if use_dbus:

3384

3601

mandos_dbus_service.client_removed_signal(client)

3385

3602

client_settings.clear()

3386

3603

3387

3604

atexit.register(cleanup)

3388

3605

3389

3606

for client in tcp_server.clients.values():

3390

3607

if use_dbus:

3391

3608

# Emit D-Bus signal for adding

3393

3610

# Need to initiate checking of clients

3394

3611

if client.enabled:

3395

3612

client.init_checker()

3396

3613

3397

3614

tcp_server.enable()

3398

3615

tcp_server.server_activate()

3399

3616

3400

3617

# Find out what port we got

3401

3618

if zeroconf:

3402

3619

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

3403

3620

if use_ipv6:

3404

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

3405

" flowinfo %d, scope_id %d",

3406

*tcp_server.socket.getsockname())

3621

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

3622

" scope_id %d", *tcp_server.socket.getsockname())

3407

3623

else: # IPv4

3408

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

3409

*tcp_server.socket.getsockname())

3410

3411

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

3412

3624

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

3625

*tcp_server.socket.getsockname())

3626

3627

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

3628

3413

3629

try:

3414

3630

if zeroconf:

3415

3631

# From the Avahi example code

3416

3632

try:

3417

3633

service.activate()

3418

3634

except dbus.exceptions.DBusException as error:

3419

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

3635

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

3420

3636

cleanup()

3421

3637

sys.exit(1)

3422

3638

# End of Avahi example code

3423

3424

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

3425

lambda *args, **kwargs:

3426

(tcp_server.handle_request

3427

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

3428

3429

logger.debug("Starting main loop")

3639

3640

GLib.io_add_watch(

3641

GLib.IOChannel.unix_new(tcp_server.fileno()),

3642

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

3643

lambda *args, **kwargs: (tcp_server.handle_request

3644

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

3645

3646

log.debug("Starting main loop")

3430

3647

main_loop.run()

3431

3648

except AvahiError as error:

3432

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

3649

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

3433

3650

cleanup()

3434

3651

sys.exit(1)

3435

3652

except KeyboardInterrupt:

3436

3653

if debug:

3437

3654

print("", file=sys.stderr)

3438

logger.debug("Server received KeyboardInterrupt")

3439

logger.debug("Server exiting")

3655

log.debug("Server received KeyboardInterrupt")

3656

log.debug("Server exiting")

3440

3657

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

3441

3658

cleanup()

3442

3659

3443

3444

if __name__ == '__main__':

3445

main()

3660

3661

def parse_test_args():

3662

# type: () -> argparse.Namespace

3663

parser = argparse.ArgumentParser(add_help=False)

3664

parser.add_argument("--check", action="store_true")

3665

parser.add_argument("--prefix", )

3666

args, unknown_args = parser.parse_known_args()

3667

if args.check:

3668

# Remove test options from sys.argv

3669

sys.argv[1:] = unknown_args

3670

return args

3671

3672

# Add all tests from doctest strings

3673

def load_tests(loader, tests, none):

3674

import doctest

3675

tests.addTests(doctest.DocTestSuite())

3676

return tests

3677

3678

if __name__ == "__main__":

3679

options = parse_test_args()

3680

try:

3681

if options.check:

3682

extra_test_prefix = options.prefix

3683

if extra_test_prefix is not None:

3684

if not (unittest.main(argv=[""], exit=False)

3685

.result.wasSuccessful()):

3686

sys.exit(1)

3687

class ExtraTestLoader(unittest.TestLoader):

3688

testMethodPrefix = extra_test_prefix

3689

# Call using ./scriptname --test [--verbose]

3690

unittest.main(argv=[""], testLoader=ExtraTestLoader())

3691

else:

3692

unittest.main(argv=[""])

3693

else:

3694

main()

3695

finally:

3696

logging.shutdown()

3697

3698

# Local Variables:

3699

# run-tests:

3700

# (lambda (&optional extra)

3701

# (if (not (funcall run-tests-in-test-buffer default-directory

3702

# extra))

3703

# (funcall show-test-buffer-in-test-window)

3704

# (funcall remove-test-window)

3705

# (if extra (message "Extra tests run successfully!"))))

3706

# run-tests-in-test-buffer:

3707

# (lambda (dir &optional extra)

3708

# (with-current-buffer (get-buffer-create "*Test*")

3709

# (setq buffer-read-only nil

3710

# default-directory dir)

3711

# (erase-buffer)

3712

# (compilation-mode))

3713

# (let ((process-result

3714

# (let ((inhibit-read-only t))

3715

# (process-file-shell-command

3716

# (funcall get-command-line extra) nil "*Test*"))))

3717

# (and (numberp process-result)

3718

# (= process-result 0))))

3719

# get-command-line:

3720

# (lambda (&optional extra)

3721

# (let ((quoted-script

3722

# (shell-quote-argument (funcall get-script-name))))

3723

# (format

3724

# (concat "%s --check" (if extra " --prefix=atest" ""))

3725

# quoted-script)))

3726

# get-script-name:

3727

# (lambda ()

3728

# (if (fboundp 'file-local-name)

3729

# (file-local-name (buffer-file-name))

3730

# (or (file-remote-p (buffer-file-name) 'localname)

3731

# (buffer-file-name))))

3732

# remove-test-window:

3733

# (lambda ()

3734

# (let ((test-window (get-buffer-window "*Test*")))

3735

# (if test-window (delete-window test-window))))

3736

# show-test-buffer-in-test-window:

3737

# (lambda ()

3738

# (when (not (get-buffer-window-list "*Test*"))

3739

# (setq next-error-last-buffer (get-buffer "*Test*"))

3740

# (let* ((side (if (>= (window-width) 146) 'right 'bottom))

3741

# (display-buffer-overriding-action

3742

# `((display-buffer-in-side-window) (side . ,side)

3743

# (window-height . fit-window-to-buffer)

3744

# (window-width . fit-window-to-buffer))))

3745

# (display-buffer "*Test*"))))

3746

# eval:

3747

# (progn

3748

# (let* ((run-extra-tests (lambda () (interactive)

3749

# (funcall run-tests t)))

3750

# (inner-keymap `(keymap (116 . ,run-extra-tests))) ; t

3751

# (outer-keymap `(keymap (3 . ,inner-keymap)))) ; C-c

3752

# (setq minor-mode-overriding-map-alist

3753

# (cons `(run-tests . ,outer-keymap)

3754

# minor-mode-overriding-map-alist)))

3755

# (add-hook 'after-save-hook run-tests 90 t))

3756

# End: