/mandos/trunk : revision 237.4.80

1

#!/usr/bin/python3 -bI

2

# -*- mode: python; after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-

3

#

1

#!/usr/bin/python

2

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

3

#

4

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

5

#

5

#

6

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

7

# service publisher, downloaded from

8

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

9

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

10

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

11

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

12

#

12

#

13

# Everything else is

14

15

16

#

17

# This file is part of Mandos.

18

#

19

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

20

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

14

15

16

#

17

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

18

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

21

19

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

22

20

# (at your option) any later version.

23

21

#

24

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

25

# WITHOUT ANY WARRANTY; without even the implied warranty of

22

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

23

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

26

24

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

27

25

# GNU General Public License for more details.

28

#

26

#

29

27

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

30

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

31

#

28

# along with this program. If not, see

29

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

30

#

32

31

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

33

#

32

#

34

33

35

34

from __future__ import (division, absolute_import, print_function,

36

35

unicode_literals)

77

76

import itertools

78

77

import collections

79

78

import codecs

80

import unittest

81

import random

82

import shlex

83

79

84

80

import dbus

85

81

import dbus.service

86

import gi

87

82

from gi.repository import GLib

88

83

from dbus.mainloop.glib import DBusGMainLoop

89

84

import ctypes

91

86

import xml.dom.minidom

92

87

import inspect

93

88

94

if sys.version_info.major == 2:

95

__metaclass__ = type

96

str = unicode

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

89

# Try to find the value of SO_BINDTODEVICE:

119

90

try:

120

91

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

140

111

# No value found

141

112

SO_BINDTODEVICE = None

142

113

143

if sys.version_info < (3, 2):

144

configparser.Configparser = configparser.SafeConfigParser

114

if sys.version_info.major == 2:

115

str = unicode

145

116

146

version = "1.8.9"

117

version = "1.7.10"

147

118

stored_state_file = "clients.pickle"

148

119

149

120

logger = logging.getLogger()

150

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

151

121

syslogger = None

152

122

153

123

try:

154

124

if_nametoindex = ctypes.cdll.LoadLibrary(

155

125

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

156

126

except (OSError, AttributeError):

157

127

158

128

def if_nametoindex(interface):

159

129

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

160

130

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

183

153

184

154

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

185

155

"""init logger and add loglevel"""

186

156

187

157

global syslogger

188

158

syslogger = (logging.handlers.SysLogHandler(

189

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

190

address="/dev/log"))

159

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

160

address = "/dev/log"))

191

161

syslogger.setFormatter(logging.Formatter

192

162

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

193

163

' %(message)s'))

194

164

logger.addHandler(syslogger)

195

165

196

166

if debug:

197

167

console = logging.StreamHandler()

198

168

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

208

178

pass

209

179

210

180

211

class PGPEngine:

181

class PGPEngine(object):

212

182

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

213

183

214

184

def __init__(self):

215

185

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

216

186

self.gpg = "gpg"

218

188

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

219

189

for line in output.splitlines():

220

190

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

221

if name == b"gpg":

191

if name == "gpg":

222

192

self.gpg = path

223

193

break

224

194

except OSError as e:

229

199

'--force-mdc',

230

200

'--quiet']

231

201

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

232

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

202

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

233

203

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

234

204

235

205

def __enter__(self):

236

206

return self

237

207

238

208

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

239

209

self._cleanup()

240

210

return False

241

211

242

212

def __del__(self):

243

213

self._cleanup()

244

214

245

215

def _cleanup(self):

246

216

if self.tempdir is not None:

247

217

# Delete contents of tempdir

248

218

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

249

topdown=False):

219

topdown = False):

250

220

for filename in files:

251

221

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

252

222

for dirname in dirs:

254

224

# Remove tempdir

255

225

os.rmdir(self.tempdir)

256

226

self.tempdir = None

257

227

258

228

def password_encode(self, password):

259

229

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

260

230

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

265

235

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

266

236

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

267

237

return encoded

268

238

269

239

def encrypt(self, data, password):

270

240

passphrase = self.password_encode(password)

271

241

with tempfile.NamedTemporaryFile(

276

246

'--passphrase-file',

277

247

passfile.name]

278

248

+ self.gnupgargs,

279

stdin=subprocess.PIPE,

280

stdout=subprocess.PIPE,

281

stderr=subprocess.PIPE)

282

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

249

stdin = subprocess.PIPE,

250

stdout = subprocess.PIPE,

251

stderr = subprocess.PIPE)

252

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

283

253

if proc.returncode != 0:

284

254

raise PGPError(err)

285

255

return ciphertext

286

256

287

257

def decrypt(self, data, password):

288

258

passphrase = self.password_encode(password)

289

259

with tempfile.NamedTemporaryFile(

290

dir=self.tempdir) as passfile:

260

dir = self.tempdir) as passfile:

291

261

passfile.write(passphrase)

292

262

passfile.flush()

293

263

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

294

264

'--passphrase-file',

295

265

passfile.name]

296

266

+ self.gnupgargs,

297

stdin=subprocess.PIPE,

298

stdout=subprocess.PIPE,

299

stderr=subprocess.PIPE)

300

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

267

stdin = subprocess.PIPE,

268

stdout = subprocess.PIPE,

269

stderr = subprocess.PIPE)

270

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

301

271

if proc.returncode != 0:

302

272

raise PGPError(err)

303

273

return decrypted_plaintext

304

274

305

306

275

# Pretend that we have an Avahi module

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

276

class Avahi(object):

277

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

278

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

279

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

280

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

281

PROTO_INET = 0 # avahi-common/address.h

282

PROTO_INET6 = 1 # avahi-common/address.h

313

283

DBUS_NAME = "org.freedesktop.Avahi"

314

284

DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"

315

285

DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"

316

286

DBUS_PATH_SERVER = "/"

317

318

@staticmethod

319

def string_array_to_txt_array(t):

287

def string_array_to_txt_array(self, t):

320

288

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

321

289

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

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

290

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

291

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

292

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

293

SERVER_INVALID = 0 # avahi-common/defs.h

294

SERVER_REGISTERING = 1 # avahi-common/defs.h

295

SERVER_RUNNING = 2 # avahi-common/defs.h

296

SERVER_COLLISION = 3 # avahi-common/defs.h

297

SERVER_FAILURE = 4 # avahi-common/defs.h

298

avahi = Avahi()

331

299

332

300

class AvahiError(Exception):

333

301

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

344

312

pass

345

313

346

314

347

class AvahiService:

315

class AvahiService(object):

348

316

"""An Avahi (Zeroconf) service.

349

317

350

318

Attributes:

351

319

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

352

320

Used to optionally bind to the specified interface.

364

332

server: D-Bus Server

365

333

bus: dbus.SystemBus()

366

334

"""

367

335

368

336

def __init__(self,

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

337

interface = avahi.IF_UNSPEC,

338

name = None,

339

servicetype = None,

340

port = None,

341

TXT = None,

342

domain = "",

343

host = "",

344

max_renames = 32768,

345

protocol = avahi.PROTO_UNSPEC,

346

bus = None):

379

347

self.interface = interface

380

348

self.name = name

381

349

self.type = servicetype

390

358

self.server = None

391

359

self.bus = bus

392

360

self.entry_group_state_changed_match = None

393

361

394

362

def rename(self, remove=True):

395

363

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

396

364

if self.rename_count >= self.max_renames:

416

384

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

417

385

self.cleanup()

418

386

os._exit(1)

419

387

420

388

def remove(self):

421

389

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

422

390

if self.entry_group_state_changed_match is not None:

424

392

self.entry_group_state_changed_match = None

425

393

if self.group is not None:

426

394

self.group.Reset()

427

395

428

396

def add(self):

429

397

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

430

398

self.remove()

447

415

dbus.UInt16(self.port),

448

416

avahi.string_array_to_txt_array(self.TXT))

449

417

self.group.Commit()

450

418

451

419

def entry_group_state_changed(self, state, error):

452

420

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

453

421

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

454

422

455

423

if state == avahi.ENTRY_GROUP_ESTABLISHED:

456

424

logger.debug("Zeroconf service established.")

457

425

elif state == avahi.ENTRY_GROUP_COLLISION:

461

429

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

462

430

str(error))

463

431

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

464

432

465

433

def cleanup(self):

466

434

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

467

435

if self.group is not None:

472

440

pass

473

441

self.group = None

474

442

self.remove()

475

443

476

444

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

477

445

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

478

446

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

507

475

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

508

476

else:

509

477

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

510

478

511

479

def activate(self):

512

480

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

513

481

if self.server is None:

524

492

class AvahiServiceToSyslog(AvahiService):

525

493

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

526

494

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

527

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

495

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

528

496

syslogger.setFormatter(logging.Formatter(

529

497

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

530

498

.format(self.name)))

531

499

return ret

532

500

533

534

501

# Pretend that we have a GnuTLS module

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

502

class GnuTLS(object):

503

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

504

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

505

506

_library = ctypes.cdll.LoadLibrary(

507

ctypes.util.find_library("gnutls"))

508

_need_version = b"3.3.0"

509

def __init__(self):

510

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

511

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

512

# happens.

513

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

514

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

515

.format(self._need_version))

516

544

517

# Unless otherwise indicated, the constants and types below are

545

518

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

546

519

547

520

# Constants

548

521

E_SUCCESS = 0

549

522

E_INTERRUPTED = -52

550

523

E_AGAIN = -28

551

524

CRT_OPENPGP = 2

552

CRT_RAWPK = 3

553

525

CLIENT = 2

554

526

SHUT_RDWR = 0

555

527

CRD_CERTIFICATE = 1

556

528

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

562

529

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

563

530

564

531

# Types

565

532

class session_int(ctypes.Structure):

566

533

_fields_ = []

567

534

session_t = ctypes.POINTER(session_int)

568

569

535

class certificate_credentials_st(ctypes.Structure):

570

536

_fields_ = []

571

537

certificate_credentials_t = ctypes.POINTER(

572

538

certificate_credentials_st)

573

539

certificate_type_t = ctypes.c_int

574

575

540

class datum_t(ctypes.Structure):

576

541

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

577

542

('size', ctypes.c_uint)]

578

579

543

class openpgp_crt_int(ctypes.Structure):

580

544

_fields_ = []

581

545

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

582

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

546

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

583

547

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

584

548

credentials_type_t = ctypes.c_int

585

549

transport_ptr_t = ctypes.c_void_p

586

550

close_request_t = ctypes.c_int

587

551

588

552

# Exceptions

589

553

class Error(Exception):

590

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

554

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

555

# exception might be raised from within GnuTLS.__init__,

556

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

557

# global variable has happened.

558

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

591

559

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

592

560

# code is passed, convert it to a string with

593

561

# gnutls.strerror()

594

562

self.code = code

595

563

if message is None and code is not None:

596

message = gnutls.strerror(code)

597

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

564

message = GnuTLS.strerror(code)

565

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

598

566

message, *args)

599

567

600

568

class CertificateSecurityError(Error):

601

569

pass

602

570

603

571

# Classes

604

class Credentials:

572

class Credentials(object):

605

573

def __init__(self):

606

574

self._c_object = gnutls.certificate_credentials_t()

607

575

gnutls.certificate_allocate_credentials(

608

576

ctypes.byref(self._c_object))

609

577

self.type = gnutls.CRD_CERTIFICATE

610

578

611

579

def __del__(self):

612

580

gnutls.certificate_free_credentials(self._c_object)

613

614

class ClientSession:

615

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

581

582

class ClientSession(object):

583

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

616

584

self._c_object = gnutls.session_t()

617

gnutls_flags = gnutls.CLIENT

618

if gnutls.check_version(b"3.5.6"):

619

gnutls_flags |= gnutls.NO_TICKETS

620

if gnutls.has_rawpk:

621

gnutls_flags |= gnutls.ENABLE_RAWPK

622

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

623

del gnutls_flags

585

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

624

586

gnutls.set_default_priority(self._c_object)

625

587

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

626

588

gnutls.handshake_set_private_extensions(self._c_object,

632

594

ctypes.cast(credentials._c_object,

633

595

ctypes.c_void_p))

634

596

self.credentials = credentials

635

597

636

598

def __del__(self):

637

599

gnutls.deinit(self._c_object)

638

600

639

601

def handshake(self):

640

602

return gnutls.handshake(self._c_object)

641

603

642

604

def send(self, data):

643

605

data = bytes(data)

644

606

data_len = len(data)

646

608

data_len -= gnutls.record_send(self._c_object,

647

609

data[-data_len:],

648

610

data_len)

649

611

650

612

def bye(self):

651

613

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

652

614

653

615

# Error handling functions

654

616

def _error_code(result):

655

617

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

657

619

if result >= 0:

658

620

return result

659

621

if result == gnutls.E_NO_CERTIFICATE_FOUND:

660

raise gnutls.CertificateSecurityError(code=result)

661

raise gnutls.Error(code=result)

662

622

raise gnutls.CertificateSecurityError(code = result)

623

raise gnutls.Error(code = result)

624

663

625

def _retry_on_error(result, func, arguments):

664

626

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

665

627

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

668

630

return _error_code(result)

669

631

result = func(*arguments)

670

632

return result

671

633

672

634

# Unless otherwise indicated, the function declarations below are

673

635

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

674

636

675

637

# Functions

676

638

priority_set_direct = _library.gnutls_priority_set_direct

677

639

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

678

640

ctypes.POINTER(ctypes.c_char_p)]

679

641

priority_set_direct.restype = _error_code

680

642

681

643

init = _library.gnutls_init

682

644

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

683

645

init.restype = _error_code

684

646

685

647

set_default_priority = _library.gnutls_set_default_priority

686

648

set_default_priority.argtypes = [session_t]

687

649

set_default_priority.restype = _error_code

688

650

689

651

record_send = _library.gnutls_record_send

690

652

record_send.argtypes = [session_t, ctypes.c_void_p,

691

653

ctypes.c_size_t]

692

654

record_send.restype = ctypes.c_ssize_t

693

655

record_send.errcheck = _retry_on_error

694

656

695

657

certificate_allocate_credentials = (

696

658

_library.gnutls_certificate_allocate_credentials)

697

659

certificate_allocate_credentials.argtypes = [

698

660

ctypes.POINTER(certificate_credentials_t)]

699

661

certificate_allocate_credentials.restype = _error_code

700

662

701

663

certificate_free_credentials = (

702

664

_library.gnutls_certificate_free_credentials)

703

certificate_free_credentials.argtypes = [

704

certificate_credentials_t]

665

certificate_free_credentials.argtypes = [certificate_credentials_t]

705

666

certificate_free_credentials.restype = None

706

667

707

668

handshake_set_private_extensions = (

708

669

_library.gnutls_handshake_set_private_extensions)

709

670

handshake_set_private_extensions.argtypes = [session_t,

710

671

ctypes.c_int]

711

672

handshake_set_private_extensions.restype = None

712

673

713

674

credentials_set = _library.gnutls_credentials_set

714

675

credentials_set.argtypes = [session_t, credentials_type_t,

715

676

ctypes.c_void_p]

716

677

credentials_set.restype = _error_code

717

678

718

679

strerror = _library.gnutls_strerror

719

680

strerror.argtypes = [ctypes.c_int]

720

681

strerror.restype = ctypes.c_char_p

721

682

722

683

certificate_type_get = _library.gnutls_certificate_type_get

723

684

certificate_type_get.argtypes = [session_t]

724

685

certificate_type_get.restype = _error_code

725

686

726

687

certificate_get_peers = _library.gnutls_certificate_get_peers

727

688

certificate_get_peers.argtypes = [session_t,

728

689

ctypes.POINTER(ctypes.c_uint)]

729

690

certificate_get_peers.restype = ctypes.POINTER(datum_t)

730

691

731

692

global_set_log_level = _library.gnutls_global_set_log_level

732

693

global_set_log_level.argtypes = [ctypes.c_int]

733

694

global_set_log_level.restype = None

734

695

735

696

global_set_log_function = _library.gnutls_global_set_log_function

736

697

global_set_log_function.argtypes = [log_func]

737

698

global_set_log_function.restype = None

738

699

739

700

deinit = _library.gnutls_deinit

740

701

deinit.argtypes = [session_t]

741

702

deinit.restype = None

742

703

743

704

handshake = _library.gnutls_handshake

744

705

handshake.argtypes = [session_t]

745

706

handshake.restype = _error_code

746

707

handshake.errcheck = _retry_on_error

747

708

748

709

transport_set_ptr = _library.gnutls_transport_set_ptr

749

710

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

750

711

transport_set_ptr.restype = None

751

712

752

713

bye = _library.gnutls_bye

753

714

bye.argtypes = [session_t, close_request_t]

754

715

bye.restype = _error_code

755

716

bye.errcheck = _retry_on_error

756

717

757

718

check_version = _library.gnutls_check_version

758

719

check_version.argtypes = [ctypes.c_char_p]

759

720

check_version.restype = ctypes.c_char_p

760

761

_need_version = b"3.3.0"

762

if check_version(_need_version) is None:

763

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

764

.format(_need_version))

765

766

_tls_rawpk_version = b"3.6.6"

767

has_rawpk = bool(check_version(_tls_rawpk_version))

768

769

if has_rawpk:

770

# Types

771

class pubkey_st(ctypes.Structure):

772

_fields = []

773

pubkey_t = ctypes.POINTER(pubkey_st)

774

775

x509_crt_fmt_t = ctypes.c_int

776

777

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

778

pubkey_init = _library.gnutls_pubkey_init

779

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

780

pubkey_init.restype = _error_code

781

782

pubkey_import = _library.gnutls_pubkey_import

783

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

784

x509_crt_fmt_t]

785

pubkey_import.restype = _error_code

786

787

pubkey_get_key_id = _library.gnutls_pubkey_get_key_id

788

pubkey_get_key_id.argtypes = [pubkey_t, ctypes.c_int,

789

ctypes.POINTER(ctypes.c_ubyte),

790

ctypes.POINTER(ctypes.c_size_t)]

791

pubkey_get_key_id.restype = _error_code

792

793

pubkey_deinit = _library.gnutls_pubkey_deinit

794

pubkey_deinit.argtypes = [pubkey_t]

795

pubkey_deinit.restype = None

796

else:

797

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

798

799

openpgp_crt_init = _library.gnutls_openpgp_crt_init

800

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

801

openpgp_crt_init.restype = _error_code

802

803

openpgp_crt_import = _library.gnutls_openpgp_crt_import

804

openpgp_crt_import.argtypes = [openpgp_crt_t,

805

ctypes.POINTER(datum_t),

806

openpgp_crt_fmt_t]

807

openpgp_crt_import.restype = _error_code

808

809

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

810

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

811

ctypes.POINTER(ctypes.c_uint)]

812

openpgp_crt_verify_self.restype = _error_code

813

814

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

815

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

816

openpgp_crt_deinit.restype = None

817

818

openpgp_crt_get_fingerprint = (

819

_library.gnutls_openpgp_crt_get_fingerprint)

820

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

821

ctypes.c_void_p,

822

ctypes.POINTER(

823

ctypes.c_size_t)]

824

openpgp_crt_get_fingerprint.restype = _error_code

825

826

if check_version(b"3.6.4"):

827

certificate_type_get2 = _library.gnutls_certificate_type_get2

828

certificate_type_get2.argtypes = [session_t, ctypes.c_int]

829

certificate_type_get2.restype = _error_code

830

721

722

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

723

724

openpgp_crt_init = _library.gnutls_openpgp_crt_init

725

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

726

openpgp_crt_init.restype = _error_code

727

728

openpgp_crt_import = _library.gnutls_openpgp_crt_import

729

openpgp_crt_import.argtypes = [openpgp_crt_t,

730

ctypes.POINTER(datum_t),

731

openpgp_crt_fmt_t]

732

openpgp_crt_import.restype = _error_code

733

734

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

735

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

736

ctypes.POINTER(ctypes.c_uint)]

737

openpgp_crt_verify_self.restype = _error_code

738

739

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

740

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

741

openpgp_crt_deinit.restype = None

742

743

openpgp_crt_get_fingerprint = (

744

_library.gnutls_openpgp_crt_get_fingerprint)

745

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

746

ctypes.c_void_p,

747

ctypes.POINTER(

748

ctypes.c_size_t)]

749

openpgp_crt_get_fingerprint.restype = _error_code

750

831

751

# Remove non-public functions

832

752

del _error_code, _retry_on_error

833

753

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

754

gnutls = GnuTLS()

834

755

835

756

def call_pipe(connection, # : multiprocessing.Connection

836

757

func, *args, **kwargs):

837

758

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

838

759

839

760

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

840

761

return value on the provided multiprocessing.Connection.

841

762

"""

842

763

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

843

764

connection.close()

844

765

845

846

class Client:

766

class Client(object):

847

767

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

848

768

849

769

Attributes:

850

770

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

851

771

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

852

772

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

853

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

854

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

855

running.

773

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

774

to see if the client lives.

775

'None' if no process is running.

856

776

checker_callback_tag: a GLib event source tag, or None

857

777

checker_command: string; External command which is run to check

858

778

if client lives. %() expansions are done at

866

786

disable_initiator_tag: a GLib event source tag, or None

867

787

enabled: bool()

868

788

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

869

uniquely identify an OpenPGP client

870

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

871

a client using raw public keys

789

uniquely identify the client

872

790

host: string; available for use by the checker command

873

791

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

874

792

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

890

808

disabled, or None

891

809

server_settings: The server_settings dict from main()

892

810

"""

893

811

894

812

runtime_expansions = ("approval_delay", "approval_duration",

895

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

813

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

896

814

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

897

815

"last_approval_request", "last_checked_ok",

898

816

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

907

825

"approved_by_default": "True",

908

826

"enabled": "True",

909

827

}

910

828

911

829

@staticmethod

912

830

def config_parser(config):

913

831

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

920

838

for client_name in config.sections():

921

839

section = dict(config.items(client_name))

922

840

client = settings[client_name] = {}

923

841

924

842

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

925

843

# Reformat values from string types to Python types

926

844

client["approved_by_default"] = config.getboolean(

927

845

client_name, "approved_by_default")

928

846

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

929

847

"enabled")

930

931

# Uppercase and remove spaces from key_id and fingerprint

932

# for later comparison purposes with return value from the

933

# key_id() and fingerprint() functions

934

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

935

.replace(" ", ""))

848

849

# Uppercase and remove spaces from fingerprint for later

850

# comparison purposes with return value from the

851

# fingerprint() function

936

852

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

937

853

.replace(" ", ""))

938

854

if "secret" in section:

959

875

client["last_approval_request"] = None

960

876

client["last_checked_ok"] = None

961

877

client["last_checker_status"] = -2

962

878

963

879

return settings

964

965

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

880

881

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

966

882

self.name = name

967

883

if server_settings is None:

968

884

server_settings = {}

970

886

# adding all client settings

971

887

for setting, value in settings.items():

972

888

setattr(self, setting, value)

973

889

974

890

if self.enabled:

975

891

if not hasattr(self, "last_enabled"):

976

892

self.last_enabled = datetime.datetime.utcnow()

980

896

else:

981

897

self.last_enabled = None

982

898

self.expires = None

983

899

984

900

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

985

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

986

901

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

987

902

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

988

903

datetime.datetime.utcnow())

989

904

990

905

# attributes specific for this server instance

991

906

self.checker = None

992

907

self.checker_initiator_tag = None

1001

916

for attr in self.__dict__.keys()

1002

917

if not attr.startswith("_")]

1003

918

self.client_structure.append("client_structure")

1004

919

1005

920

for name, t in inspect.getmembers(

1006

921

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

1007

922

if not name.startswith("_"):

1008

923

self.client_structure.append(name)

1009

924

1010

925

# Send notice to process children that client state has changed

1011

926

def send_changedstate(self):

1012

927

with self.changedstate:

1013

928

self.changedstate.notify_all()

1014

929

1015

930

def enable(self):

1016

931

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

1017

932

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

1022

937

self.last_enabled = datetime.datetime.utcnow()

1023

938

self.init_checker()

1024

939

self.send_changedstate()

1025

940

1026

941

def disable(self, quiet=True):

1027

942

"""Disable this client."""

1028

943

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

1042

957

self.send_changedstate()

1043

958

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

1044

959

return False

1045

960

1046

961

def __del__(self):

1047

962

self.disable()

1048

963

1049

964

def init_checker(self):

1050

965

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

1051

966

# and every interval from then on.

1052

967

if self.checker_initiator_tag is not None:

1053

968

GLib.source_remove(self.checker_initiator_tag)

1054

969

self.checker_initiator_tag = GLib.timeout_add(

1055

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

1056

+ 1)),

970

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

1057

971

self.start_checker)

1058

972

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

1059

973

if self.disable_initiator_tag is not None:

1062

976

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

1063

977

# Also start a new checker *right now*.

1064

978

self.start_checker()

1065

979

1066

980

def checker_callback(self, source, condition, connection,

1067

981

command):

1068

982

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

983

self.checker_callback_tag = None

984

self.checker = None

1069

985

# Read return code from connection (see call_pipe)

1070

986

returncode = connection.recv()

1071

987

connection.close()

1072

if self.checker is not None:

1073

self.checker.join()

1074

self.checker_callback_tag = None

1075

self.checker = None

1076

988

1077

989

if returncode >= 0:

1078

990

self.last_checker_status = returncode

1079

991

self.last_checker_signal = None

1089

1001

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

1090

1002

vars(self))

1091

1003

return False

1092

1004

1093

1005

def checked_ok(self):

1094

1006

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

1095

1007

self.last_checked_ok = datetime.datetime.utcnow()

1096

1008

self.last_checker_status = 0

1097

1009

self.last_checker_signal = None

1098

1010

self.bump_timeout()

1099

1011

1100

1012

def bump_timeout(self, timeout=None):

1101

1013

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

1102

1014

if timeout is None:

1108

1020

self.disable_initiator_tag = GLib.timeout_add(

1109

1021

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

1110

1022

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

1111

1023

1112

1024

def need_approval(self):

1113

1025

self.last_approval_request = datetime.datetime.utcnow()

1114

1026

1115

1027

def start_checker(self):

1116

1028

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

1117

1029

1118

1030

If a checker already exists, leave it running and do

1119

1031

nothing."""

1120

1032

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

1125

1037

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

1126

1038

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

1127

1039

# should be.

1128

1040

1129

1041

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

1130

1042

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

1131

1043

self.checker.join()

1134

1046

if self.checker is None:

1135

1047

# Escape attributes for the shell

1136

1048

escaped_attrs = {

1137

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

1138

for attr in self.runtime_expansions}

1049

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

1050

for attr in self.runtime_expansions }

1139

1051

try:

1140

1052

command = self.checker_command % escaped_attrs

1141

1053

except TypeError as error:

1153

1065

# The exception is when not debugging but nevertheless

1154

1066

# running in the foreground; use the previously

1155

1067

# created wnull.

1156

popen_args = {"close_fds": True,

1157

"shell": True,

1158

"cwd": "/"}

1068

popen_args = { "close_fds": True,

1069

"shell": True,

1070

"cwd": "/" }

1159

1071

if (not self.server_settings["debug"]

1160

1072

and self.server_settings["foreground"]):

1161

1073

popen_args.update({"stdout": wnull,

1162

"stderr": wnull})

1163

pipe = multiprocessing.Pipe(duplex=False)

1074

"stderr": wnull })

1075

pipe = multiprocessing.Pipe(duplex = False)

1164

1076

self.checker = multiprocessing.Process(

1165

target=call_pipe,

1166

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

1167

kwargs=popen_args)

1077

target = call_pipe,

1078

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

1079

kwargs = popen_args)

1168

1080

self.checker.start()

1169

1081

self.checker_callback_tag = GLib.io_add_watch(

1170

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

1171

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

1082

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

1172

1083

self.checker_callback, pipe[0], command)

1173

1084

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

1174

1085

return True

1175

1086

1176

1087

def stop_checker(self):

1177

1088

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

1178

1089

if self.checker_callback_tag:

1191

1102

byte_arrays=False):

1192

1103

"""Decorators for marking methods of a DBusObjectWithProperties to

1193

1104

become properties on the D-Bus.

1194

1105

1195

1106

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

1196

1107

and with one argument by "Set".

1197

1108

1198

1109

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

1199

1110

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

1200

1111

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

1204

1115

if byte_arrays and signature != "ay":

1205

1116

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

1206

1117

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

1207

1118

1208

1119

def decorator(func):

1209

1120

func._dbus_is_property = True

1210

1121

func._dbus_interface = dbus_interface

1213

1124

func._dbus_name = func.__name__

1214

1125

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

1215

1126

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

1216

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

1127

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1217

1128

return func

1218

1129

1219

1130

return decorator

1220

1131

1221

1132

1222

1133

def dbus_interface_annotations(dbus_interface):

1223

1134

"""Decorator for marking functions returning interface annotations

1224

1135

1225

1136

Usage:

1226

1137

1227

1138

@dbus_interface_annotations("org.example.Interface")

1228

1139

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

1229

1140

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

1230

1141

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

1231

1142

"false"}

1232

1143

"""

1233

1144

1234

1145

def decorator(func):

1235

1146

func._dbus_is_interface = True

1236

1147

func._dbus_interface = dbus_interface

1237

1148

func._dbus_name = dbus_interface

1238

1149

return func

1239

1150

1240

1151

return decorator

1241

1152

1242

1153

1243

1154

def dbus_annotations(annotations):

1244

1155

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

1245

1156

Usage:

1246

1157

1247

1158

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

1248

1159

"org.freedesktop.DBus.Property."

1249

1160

"EmitsChangedSignal": "false"})

1251

1162

access="r")

1252

1163

def Property_dbus_property(self):

1253

1164

return dbus.Boolean(False)

1254

1165

1255

1166

See also the DBusObjectWithAnnotations class.

1256

1167

"""

1257

1168

1258

1169

def decorator(func):

1259

1170

func._dbus_annotations = annotations

1260

1171

return func

1261

1172

1262

1173

return decorator

1263

1174

1264

1175

1282

1193

1283

1194

class DBusObjectWithAnnotations(dbus.service.Object):

1284

1195

"""A D-Bus object with annotations.

1285

1196

1286

1197

Classes inheriting from this can use the dbus_annotations

1287

1198

decorator to add annotations to methods or signals.

1288

1199

"""

1289

1200

1290

1201

@staticmethod

1291

1202

def _is_dbus_thing(thing):

1292

1203

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

1293

1204

1294

1205

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

1295

1206

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

1296

1207

"""

1297

1208

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

1298

1209

False)

1299

1210

1300

1211

def _get_all_dbus_things(self, thing):

1301

1212

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

1302

1213

"""

1305

1216

for cls in self.__class__.__mro__

1306

1217

for name, athing in

1307

1218

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

1308

1219

1309

1220

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1310

out_signature="s",

1311

path_keyword='object_path',

1312

connection_keyword='connection')

1221

out_signature = "s",

1222

path_keyword = 'object_path',

1223

connection_keyword = 'connection')

1313

1224

def Introspect(self, object_path, connection):

1314

1225

"""Overloading of standard D-Bus method.

1315

1226

1316

1227

Inserts annotation tags on methods and signals.

1317

1228

"""

1318

1229

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

1319

1230

connection)

1320

1231

try:

1321

1232

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

1322

1233

1323

1234

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

1324

1235

# Add annotation tags

1325

1236

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

1352

1263

if_tag.appendChild(ann_tag)

1353

1264

# Fix argument name for the Introspect method itself

1354

1265

if (if_tag.getAttribute("name")

1355

== dbus.INTROSPECTABLE_IFACE):

1266

== dbus.INTROSPECTABLE_IFACE):

1356

1267

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

1357

1268

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

1358

1269

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

1371

1282

1372

1283

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1373

1284

"""A D-Bus object with properties.

1374

1285

1375

1286

Classes inheriting from this can use the dbus_service_property

1376

1287

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

1377

1288

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

1378

1289

"""

1379

1290

1380

1291

def _get_dbus_property(self, interface_name, property_name):

1381

1292

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

1382

1293

property with the specified name and interface.

1387

1298

if (value._dbus_name == property_name

1388

1299

and value._dbus_interface == interface_name):

1389

1300

return value.__get__(self)

1390

1301

1391

1302

# No such property

1392

1303

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

1393

1304

self.dbus_object_path, interface_name, property_name))

1394

1305

1395

1306

@classmethod

1396

1307

def _get_all_interface_names(cls):

1397

1308

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

1400

1311

for x in (inspect.getmro(cls))

1401

1312

for attr in dir(x))

1402

1313

if name is not None)

1403

1314

1404

1315

@dbus.service.method(dbus.PROPERTIES_IFACE,

1405

1316

in_signature="ss",

1406

1317

out_signature="v")

1414

1325

if not hasattr(value, "variant_level"):

1415

1326

return value

1416

1327

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

1417

1328

1418

1329

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

1419

1330

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

1420

1331

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

1429

1340

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

1430

1341

"'ay' signature {!r}"

1431

1342

.format(prop._dbus_signature))

1432

value = dbus.ByteArray(bytes(value))

1343

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

1344

for byte in value))

1433

1345

prop(value)

1434

1346

1435

1347

@dbus.service.method(dbus.PROPERTIES_IFACE,

1436

1348

in_signature="s",

1437

1349

out_signature="a{sv}")

1438

1350

def GetAll(self, interface_name):

1439

1351

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

1440

1352

standard.

1441

1353

1442

1354

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

1443

1355

"""

1444

1356

properties = {}

1455

1367

properties[name] = value

1456

1368

continue

1457

1369

properties[name] = type(value)(

1458

value, variant_level=value.variant_level + 1)

1370

value, variant_level = value.variant_level + 1)

1459

1371

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

1460

1372

1461

1373

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

1462

1374

def PropertiesChanged(self, interface_name, changed_properties,

1463

1375

invalidated_properties):

1465

1377

standard.

1466

1378

"""

1467

1379

pass

1468

1380

1469

1381

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1470

1382

out_signature="s",

1471

1383

path_keyword='object_path',

1472

1384

connection_keyword='connection')

1473

1385

def Introspect(self, object_path, connection):

1474

1386

"""Overloading of standard D-Bus method.

1475

1387

1476

1388

Inserts property tags and interface annotation tags.

1477

1389

"""

1478

1390

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1480

1392

connection)

1481

1393

try:

1482

1394

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

1483

1395

1484

1396

def make_tag(document, name, prop):

1485

1397

e = document.createElement("property")

1486

1398

e.setAttribute("name", name)

1487

1399

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

1488

1400

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

1489

1401

return e

1490

1402

1491

1403

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

1492

1404

# Add property tags

1493

1405

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

1535

1447

exc_info=error)

1536

1448

return xmlstring

1537

1449

1538

1539

1450

try:

1540

1451

dbus.OBJECT_MANAGER_IFACE

1541

1452

except AttributeError:

1542

1453

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

1543

1454

1544

1545

1455

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1546

1456

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

1547

1457

1548

1458

Classes inheriting from this exposes the standard

1549

1459

GetManagedObjects call and the InterfacesAdded and

1550

1460

InterfacesRemoved signals on the standard

1551

1461

"org.freedesktop.DBus.ObjectManager" interface.

1552

1462

1553

1463

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

1554

1464

manually.

1555

1465

"""

1556

1466

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1557

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

1467

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

1558

1468

def GetManagedObjects(self):

1559

1469

"""This function must be overridden"""

1560

1470

raise NotImplementedError()

1561

1471

1562

1472

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1563

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

1473

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

1564

1474

def InterfacesAdded(self, object_path, interfaces_and_properties):

1565

1475

pass

1566

1567

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

1476

1477

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

1568

1478

def InterfacesRemoved(self, object_path, interfaces):

1569

1479

pass

1570

1480

1571

1481

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1572

out_signature="s",

1573

path_keyword='object_path',

1574

connection_keyword='connection')

1482

out_signature = "s",

1483

path_keyword = 'object_path',

1484

connection_keyword = 'connection')

1575

1485

def Introspect(self, object_path, connection):

1576

1486

"""Overloading of standard D-Bus method.

1577

1487

1578

1488

Override return argument name of GetManagedObjects to be

1579

1489

"objpath_interfaces_and_properties"

1580

1490

"""

1583

1493

connection)

1584

1494

try:

1585

1495

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

1586

1496

1587

1497

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

1588

1498

# Fix argument name for the GetManagedObjects method

1589

1499

if (if_tag.getAttribute("name")

1590

== dbus.OBJECT_MANAGER_IFACE):

1500

== dbus.OBJECT_MANAGER_IFACE):

1591

1501

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

1592

1502

if (cn.getAttribute("name")

1593

1503

== "GetManagedObjects"):

1603

1513

except (AttributeError, xml.dom.DOMException,

1604

1514

xml.parsers.expat.ExpatError) as error:

1605

1515

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

1606

exc_info=error)

1516

exc_info = error)

1607

1517

return xmlstring

1608

1518

1609

1610

1519

def datetime_to_dbus(dt, variant_level=0):

1611

1520

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

1612

1521

if dt is None:

1613

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

1522

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

1614

1523

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

1615

1524

1616

1525

1619

1528

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

1620

1529

interface names according to the "alt_interface_names" mapping.

1621

1530

Usage:

1622

1531

1623

1532

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

1624

1533

"net.example.AlternateInterface"})

1625

1534

class SampleDBusObject(dbus.service.Object):

1626

1535

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

1627

1536

def SampleDBusMethod():

1628

1537

pass

1629

1538

1630

1539

The above "SampleDBusMethod" on "SampleDBusObject" will be

1631

1540

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

1632

1541

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

1633

1542

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

1634

1543

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

1635

1544

1636

1545

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

1637

1546

(from DBusObjectWithProperties) and interfaces (from the

1638

1547

dbus_interface_annotations decorator).

1639

1548

"""

1640

1549

1641

1550

def wrapper(cls):

1642

1551

for orig_interface_name, alt_interface_name in (

1643

1552

alt_interface_names.items()):

1683

1592

attribute._dbus_annotations)

1684

1593

except AttributeError:

1685

1594

pass

1686

1687

1595

# Define a creator of a function to call both the

1688

1596

# original and alternate functions, so both the

1689

1597

# original and alternate signals gets sent when

1692

1600

"""This function is a scope container to pass

1693

1601

func1 and func2 to the "call_both" function

1694

1602

outside of its arguments"""

1695

1603

1696

1604

@functools.wraps(func2)

1697

1605

def call_both(*args, **kwargs):

1698

1606

"""This function will emit two D-Bus

1699

1607

signals by calling func1 and func2"""

1700

1608

func1(*args, **kwargs)

1701

1609

func2(*args, **kwargs)

1702

# Make wrapper function look like a D-Bus

1703

# signal

1610

# Make wrapper function look like a D-Bus signal

1704

1611

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

1705

1612

if name.startswith("_dbus_"):

1706

1613

setattr(call_both, name, attr)

1707

1614

1708

1615

return call_both

1709

1616

# Create the "call_both" function and add it to

1710

1617

# the class

1756

1663

(copy_function(attribute)))

1757

1664

if deprecate:

1758

1665

# Deprecate all alternate interfaces

1759

iname = "_AlternateDBusNames_interface_annotation{}"

1666

iname="_AlternateDBusNames_interface_annotation{}"

1760

1667

for interface_name in interface_names:

1761

1668

1762

1669

@dbus_interface_annotations(interface_name)

1763

1670

def func(self):

1764

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

1765

"true"}

1671

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

1672

"true" }

1766

1673

# Find an unused name

1767

1674

for aname in (iname.format(i)

1768

1675

for i in itertools.count()):

1779

1686

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

1780

1687

(cls, ), attr)

1781

1688

return cls

1782

1689

1783

1690

return wrapper

1784

1691

1785

1692

1787

1694

"se.bsnet.fukt.Mandos"})

1788

1695

class ClientDBus(Client, DBusObjectWithProperties):

1789

1696

"""A Client class using D-Bus

1790

1697

1791

1698

Attributes:

1792

1699

dbus_object_path: dbus.ObjectPath

1793

1700

bus: dbus.SystemBus()

1794

1701

"""

1795

1702

1796

1703

runtime_expansions = (Client.runtime_expansions

1797

1704

+ ("dbus_object_path", ))

1798

1705

1799

1706

_interface = "se.recompile.Mandos.Client"

1800

1707

1801

1708

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

1802

1803

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

1709

1710

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

1804

1711

self.bus = bus

1805

1712

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

1806

1713

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

1812

1719

"/clients/" + client_object_name)

1813

1720

DBusObjectWithProperties.__init__(self, self.bus,

1814

1721

self.dbus_object_path)

1815

1722

1816

1723

def notifychangeproperty(transform_func, dbus_name,

1817

1724

type_func=lambda x: x,

1818

1725

variant_level=1,

1820

1727

_interface=_interface):

1821

1728

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

1822

1729

its changes to DBus.

1823

1730

1824

1731

transform_fun: Function that takes a value and a variant_level

1825

1732

and transforms it to a D-Bus type.

1826

1733

dbus_name: D-Bus name of the variable

1829

1736

variant_level: D-Bus variant level. Default: 1

1830

1737

"""

1831

1738

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

1832

1739

1833

1740

def setter(self, value):

1834

1741

if hasattr(self, "dbus_object_path"):

1835

1742

if (not hasattr(self, attrname) or

1842

1749

else:

1843

1750

dbus_value = transform_func(

1844

1751

type_func(value),

1845

variant_level=variant_level)

1752

variant_level = variant_level)

1846

1753

self.PropertyChanged(dbus.String(dbus_name),

1847

1754

dbus_value)

1848

1755

self.PropertiesChanged(

1849

1756

_interface,

1850

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

1851

dbus_value}),

1757

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

1758

dbus_value }),

1852

1759

dbus.Array())

1853

1760

setattr(self, attrname, value)

1854

1761

1855

1762

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

1856

1763

1857

1764

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1858

1765

approvals_pending = notifychangeproperty(dbus.Boolean,

1859

1766

"ApprovalPending",

1860

type_func=bool)

1767

type_func = bool)

1861

1768

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

1862

1769

last_enabled = notifychangeproperty(datetime_to_dbus,

1863

1770

"LastEnabled")

1864

1771

checker = notifychangeproperty(

1865

1772

dbus.Boolean, "CheckerRunning",

1866

type_func=lambda checker: checker is not None)

1773

type_func = lambda checker: checker is not None)

1867

1774

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1868

1775

"LastCheckedOK")

1869

1776

last_checker_status = notifychangeproperty(dbus.Int16,

1874

1781

"ApprovedByDefault")

1875

1782

approval_delay = notifychangeproperty(

1876

1783

dbus.UInt64, "ApprovalDelay",

1877

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

1784

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

1878

1785

approval_duration = notifychangeproperty(

1879

1786

dbus.UInt64, "ApprovalDuration",

1880

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

1787

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

1881

1788

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

1882

1789

timeout = notifychangeproperty(

1883

1790

dbus.UInt64, "Timeout",

1884

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

1791

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

1885

1792

extended_timeout = notifychangeproperty(

1886

1793

dbus.UInt64, "ExtendedTimeout",

1887

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

1794

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

1888

1795

interval = notifychangeproperty(

1889

1796

dbus.UInt64, "Interval",

1890

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

1797

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

1891

1798

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

1892

1799

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

1893

1800

invalidate_only=True)

1894

1801

1895

1802

del notifychangeproperty

1896

1803

1897

1804

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

1898

1805

try:

1899

1806

self.remove_from_connection()

1902

1809

if hasattr(DBusObjectWithProperties, "__del__"):

1903

1810

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

1904

1811

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

1905

1812

1906

1813

def checker_callback(self, source, condition,

1907

1814

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

1908

1815

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

1924

1831

| self.last_checker_signal),

1925

1832

dbus.String(command))

1926

1833

return ret

1927

1834

1928

1835

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

1929

1836

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

1930

1837

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

1934

1841

# Emit D-Bus signal

1935

1842

self.CheckerStarted(self.current_checker_command)

1936

1843

return r

1937

1844

1938

1845

def _reset_approved(self):

1939

1846

self.approved = None

1940

1847

return False

1941

1848

1942

1849

def approve(self, value=True):

1943

1850

self.approved = value

1944

1851

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

1945

1852

* 1000), self._reset_approved)

1946

1853

self.send_changedstate()

1947

1948

# D-Bus methods, signals & properties

1949

1950

# Interfaces

1951

1952

# Signals

1953

1854

1855

## D-Bus methods, signals & properties

1856

1857

## Interfaces

1858

1859

## Signals

1860

1954

1861

# CheckerCompleted - signal

1955

1862

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

1956

1863

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

1957

1864

"D-Bus signal"

1958

1865

pass

1959

1866

1960

1867

# CheckerStarted - signal

1961

1868

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

1962

1869

def CheckerStarted(self, command):

1963

1870

"D-Bus signal"

1964

1871

pass

1965

1872

1966

1873

# PropertyChanged - signal

1967

1874

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

1968

1875

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

1969

1876

def PropertyChanged(self, property, value):

1970

1877

"D-Bus signal"

1971

1878

pass

1972

1879

1973

1880

# GotSecret - signal

1974

1881

@dbus.service.signal(_interface)

1975

1882

def GotSecret(self):

1978

1885

server to mandos-client

1979

1886

"""

1980

1887

pass

1981

1888

1982

1889

# Rejected - signal

1983

1890

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

1984

1891

def Rejected(self, reason):

1985

1892

"D-Bus signal"

1986

1893

pass

1987

1894

1988

1895

# NeedApproval - signal

1989

1896

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

1990

1897

def NeedApproval(self, timeout, default):

1991

1898

"D-Bus signal"

1992

1899

return self.need_approval()

1993

1994

# Methods

1995

1900

1901

## Methods

1902

1996

1903

# Approve - method

1997

1904

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

1998

1905

def Approve(self, value):

1999

1906

self.approve(value)

2000

1907

2001

1908

# CheckedOK - method

2002

1909

@dbus.service.method(_interface)

2003

1910

def CheckedOK(self):

2004

1911

self.checked_ok()

2005

1912

2006

1913

# Enable - method

2007

1914

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

2008

1915

@dbus.service.method(_interface)

2009

1916

def Enable(self):

2010

1917

"D-Bus method"

2011

1918

self.enable()

2012

1919

2013

1920

# StartChecker - method

2014

1921

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

2015

1922

@dbus.service.method(_interface)

2016

1923

def StartChecker(self):

2017

1924

"D-Bus method"

2018

1925

self.start_checker()

2019

1926

2020

1927

# Disable - method

2021

1928

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

2022

1929

@dbus.service.method(_interface)

2023

1930

def Disable(self):

2024

1931

"D-Bus method"

2025

1932

self.disable()

2026

1933

2027

1934

# StopChecker - method

2028

1935

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

2029

1936

@dbus.service.method(_interface)

2030

1937

def StopChecker(self):

2031

1938

self.stop_checker()

2032

2033

# Properties

2034

1939

1940

## Properties

1941

2035

1942

# ApprovalPending - property

2036

1943

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

2037

1944

def ApprovalPending_dbus_property(self):

2038

1945

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

2039

1946

2040

1947

# ApprovedByDefault - property

2041

1948

@dbus_service_property(_interface,

2042

1949

signature="b",

2045

1952

if value is None: # get

2046

1953

return dbus.Boolean(self.approved_by_default)

2047

1954

self.approved_by_default = bool(value)

2048

1955

2049

1956

# ApprovalDelay - property

2050

1957

@dbus_service_property(_interface,

2051

1958

signature="t",

2055

1962

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

2056

1963

* 1000)

2057

1964

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

2058

1965

2059

1966

# ApprovalDuration - property

2060

1967

@dbus_service_property(_interface,

2061

1968

signature="t",

2065

1972

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

2066

1973

* 1000)

2067

1974

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

2068

1975

2069

1976

# Name - property

2070

1977

@dbus_annotations(

2071

1978

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

2072

1979

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

2073

1980

def Name_dbus_property(self):

2074

1981

return dbus.String(self.name)

2075

2076

# KeyID - property

2077

@dbus_annotations(

2078

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

2079

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

2080

def KeyID_dbus_property(self):

2081

return dbus.String(self.key_id)

2082

1982

2083

1983

# Fingerprint - property

2084

1984

@dbus_annotations(

2085

1985

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

2086

1986

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

2087

1987

def Fingerprint_dbus_property(self):

2088

1988

return dbus.String(self.fingerprint)

2089

1989

2090

1990

# Host - property

2091

1991

@dbus_service_property(_interface,

2092

1992

signature="s",

2095

1995

if value is None: # get

2096

1996

return dbus.String(self.host)

2097

1997

self.host = str(value)

2098

1998

2099

1999

# Created - property

2100

2000

@dbus_annotations(

2101

2001

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

2102

2002

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

2103

2003

def Created_dbus_property(self):

2104

2004

return datetime_to_dbus(self.created)

2105

2005

2106

2006

# LastEnabled - property

2107

2007

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

2108

2008

def LastEnabled_dbus_property(self):

2109

2009

return datetime_to_dbus(self.last_enabled)

2110

2010

2111

2011

# Enabled - property

2112

2012

@dbus_service_property(_interface,

2113

2013

signature="b",

2119

2019

self.enable()

2120

2020

else:

2121

2021

self.disable()

2122

2022

2123

2023

# LastCheckedOK - property

2124

2024

@dbus_service_property(_interface,

2125

2025

signature="s",

2129

2029

self.checked_ok()

2130

2030

return

2131

2031

return datetime_to_dbus(self.last_checked_ok)

2132

2032

2133

2033

# LastCheckerStatus - property

2134

2034

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

2135

2035

def LastCheckerStatus_dbus_property(self):

2136

2036

return dbus.Int16(self.last_checker_status)

2137

2037

2138

2038

# Expires - property

2139

2039

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

2140

2040

def Expires_dbus_property(self):

2141

2041

return datetime_to_dbus(self.expires)

2142

2042

2143

2043

# LastApprovalRequest - property

2144

2044

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

2145

2045

def LastApprovalRequest_dbus_property(self):

2146

2046

return datetime_to_dbus(self.last_approval_request)

2147

2047

2148

2048

# Timeout - property

2149

2049

@dbus_service_property(_interface,

2150

2050

signature="t",

2169

2069

self.disable_initiator_tag = GLib.timeout_add(

2170

2070

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

2171

2071

self.disable)

2172

2072

2173

2073

# ExtendedTimeout - property

2174

2074

@dbus_service_property(_interface,

2175

2075

signature="t",

2179

2079

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

2180

2080

* 1000)

2181

2081

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

2182

2082

2183

2083

# Interval - property

2184

2084

@dbus_service_property(_interface,

2185

2085

signature="t",

2195

2095

GLib.source_remove(self.checker_initiator_tag)

2196

2096

self.checker_initiator_tag = GLib.timeout_add(

2197

2097

value, self.start_checker)

2198

self.start_checker() # Start one now, too

2199

2098

self.start_checker() # Start one now, too

2099

2200

2100

# Checker - property

2201

2101

@dbus_service_property(_interface,

2202

2102

signature="s",

2205

2105

if value is None: # get

2206

2106

return dbus.String(self.checker_command)

2207

2107

self.checker_command = str(value)

2208

2108

2209

2109

# CheckerRunning - property

2210

2110

@dbus_service_property(_interface,

2211

2111

signature="b",

2217

2117

self.start_checker()

2218

2118

else:

2219

2119

self.stop_checker()

2220

2120

2221

2121

# ObjectPath - property

2222

2122

@dbus_annotations(

2223

2123

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

2224

2124

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

2225

2125

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

2226

2126

def ObjectPath_dbus_property(self):

2227

return self.dbus_object_path # is already a dbus.ObjectPath

2228

2127

return self.dbus_object_path # is already a dbus.ObjectPath

2128

2229

2129

# Secret = property

2230

2130

@dbus_annotations(

2231

2131

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

2236

2136

byte_arrays=True)

2237

2137

def Secret_dbus_property(self, value):

2238

2138

self.secret = bytes(value)

2239

2139

2240

2140

del _interface

2241

2141

2242

2142

2243

class ProxyClient:

2244

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

2143

class ProxyClient(object):

2144

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

2245

2145

self._pipe = child_pipe

2246

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

2146

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

2247

2147

if not self._pipe.recv():

2248

raise KeyError(key_id or fpr)

2249

2148

raise KeyError(fpr)

2149

2250

2150

def __getattribute__(self, name):

2251

2151

if name == '_pipe':

2252

2152

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

2255

2155

if data[0] == 'data':

2256

2156

return data[1]

2257

2157

if data[0] == 'function':

2258

2158

2259

2159

def func(*args, **kwargs):

2260

2160

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

2261

2161

return self._pipe.recv()[1]

2262

2162

2263

2163

return func

2264

2164

2265

2165

def __setattr__(self, name, value):

2266

2166

if name == '_pipe':

2267

2167

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

2270

2170

2271

2171

class ClientHandler(socketserver.BaseRequestHandler, object):

2272

2172

"""A class to handle client connections.

2273

2173

2274

2174

Instantiated once for each connection to handle it.

2275

2175

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

2276

2176

2277

2177

def handle(self):

2278

2178

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

2279

2179

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

2280

2180

str(self.client_address))

2281

2181

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

2282

2182

self.server.child_pipe.fileno())

2283

2183

2284

2184

session = gnutls.ClientSession(self.request)

2285

2286

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

2287

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

2288

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

2289

# "+DHE-DSS"))

2185

2186

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

2187

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

2188

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

2189

# "+DHE-DSS"))

2290

2190

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

2291

2191

priority = self.server.gnutls_priority

2292

2192

if priority is None:

2294

2194

gnutls.priority_set_direct(session._c_object,

2295

2195

priority.encode("utf-8"),

2296

2196

None)

2297

2197

2298

2198

# Start communication using the Mandos protocol

2299

2199

# Get protocol number

2300

2200

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

2305

2205

except (ValueError, IndexError, RuntimeError) as error:

2306

2206

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

2307

2207

return

2308

2208

2309

2209

# Start GnuTLS connection

2310

2210

try:

2311

2211

session.handshake()

2315

2215

# established. Just abandon the request.

2316

2216

return

2317

2217

logger.debug("Handshake succeeded")

2318

2218

2319

2219

approval_required = False

2320

2220

try:

2321

if gnutls.has_rawpk:

2322

fpr = b""

2323

try:

2324

key_id = self.key_id(

2325

self.peer_certificate(session))

2326

except (TypeError, gnutls.Error) as error:

2327

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

2328

return

2329

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

2330

2331

else:

2332

key_id = b""

2333

try:

2334

fpr = self.fingerprint(

2335

self.peer_certificate(session))

2336

except (TypeError, gnutls.Error) as error:

2337

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

2338

return

2339

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

2340

2341

try:

2342

client = ProxyClient(child_pipe, key_id, fpr,

2221

try:

2222

fpr = self.fingerprint(

2223

self.peer_certificate(session))

2224

except (TypeError, gnutls.Error) as error:

2225

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

2226

return

2227

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

2228

2229

try:

2230

client = ProxyClient(child_pipe, fpr,

2343

2231

self.client_address)

2344

2232

except KeyError:

2345

2233

return

2346

2234

2347

2235

if client.approval_delay:

2348

2236

delay = client.approval_delay

2349

2237

client.approvals_pending += 1

2350

2238

approval_required = True

2351

2239

2352

2240

while True:

2353

2241

if not client.enabled:

2354

2242

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

2357

2245

# Emit D-Bus signal

2358

2246

client.Rejected("Disabled")

2359

2247

return

2360

2248

2361

2249

if client.approved or not client.approval_delay:

2362

# We are approved or approval is disabled

2250

#We are approved or approval is disabled

2363

2251

break

2364

2252

elif client.approved is None:

2365

2253

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

2376

2264

# Emit D-Bus signal

2377

2265

client.Rejected("Denied")

2378

2266

return

2379

2380

# wait until timeout or approved

2267

2268

#wait until timeout or approved

2381

2269

time = datetime.datetime.now()

2382

2270

client.changedstate.acquire()

2383

2271

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

2396

2284

break

2397

2285

else:

2398

2286

delay -= time2 - time

2399

2287

2400

2288

try:

2401

2289

session.send(client.secret)

2402

2290

except gnutls.Error as error:

2403

2291

logger.warning("gnutls send failed",

2404

exc_info=error)

2292

exc_info = error)

2405

2293

return

2406

2294

2407

2295

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

2408

2296

# bump the timeout using extended_timeout

2409

2297

client.bump_timeout(client.extended_timeout)

2410

2298

if self.server.use_dbus:

2411

2299

# Emit D-Bus signal

2412

2300

client.GotSecret()

2413

2301

2414

2302

finally:

2415

2303

if approval_required:

2416

2304

client.approvals_pending -= 1

2419

2307

except gnutls.Error as error:

2420

2308

logger.warning("GnuTLS bye failed",

2421

2309

exc_info=error)

2422

2310

2423

2311

@staticmethod

2424

2312

def peer_certificate(session):

2425

"Return the peer's certificate as a bytestring"

2426

try:

2427

cert_type = gnutls.certificate_type_get2(session._c_object,

2428

gnutls.CTYPE_PEERS)

2429

except AttributeError:

2430

cert_type = gnutls.certificate_type_get(session._c_object)

2431

if gnutls.has_rawpk:

2432

valid_cert_types = frozenset((gnutls.CRT_RAWPK,))

2433

else:

2434

valid_cert_types = frozenset((gnutls.CRT_OPENPGP,))

2435

# If not a valid certificate type...

2436

if cert_type not in valid_cert_types:

2437

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

2438

valid_cert_types)

2313

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

2314

# If not an OpenPGP certificate...

2315

if (gnutls.certificate_type_get(session._c_object)

2316

!= gnutls.CRT_OPENPGP):

2439

2317

# ...return invalid data

2440

2318

return b""

2441

2319

list_size = ctypes.c_uint(1)

2447

2325

return None

2448

2326

cert = cert_list[0]

2449

2327

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

2450

2451

@staticmethod

2452

def key_id(certificate):

2453

"Convert a certificate bytestring to a hexdigit key ID"

2454

# New GnuTLS "datum" with the public key

2455

datum = gnutls.datum_t(

2456

ctypes.cast(ctypes.c_char_p(certificate),

2457

ctypes.POINTER(ctypes.c_ubyte)),

2458

ctypes.c_uint(len(certificate)))

2459

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

2460

# New empty GnuTLS certificate

2461

pubkey = gnutls.pubkey_t()

2462

gnutls.pubkey_init(ctypes.byref(pubkey))

2463

# Import the raw public key into the certificate

2464

gnutls.pubkey_import(pubkey,

2465

ctypes.byref(datum),

2466

gnutls.X509_FMT_DER)

2467

# New buffer for the key ID

2468

buf = ctypes.create_string_buffer(32)

2469

buf_len = ctypes.c_size_t(len(buf))

2470

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

2471

gnutls.pubkey_get_key_id(pubkey,

2472

gnutls.KEYID_USE_SHA256,

2473

ctypes.cast(ctypes.byref(buf),

2474

ctypes.POINTER(ctypes.c_ubyte)),

2475

ctypes.byref(buf_len))

2476

# Deinit the certificate

2477

gnutls.pubkey_deinit(pubkey)

2478

2479

# Convert the buffer to a Python bytestring

2480

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

2481

# Convert the bytestring to hexadecimal notation

2482

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

2483

return hex_key_id

2484

2328

2485

2329

@staticmethod

2486

2330

def fingerprint(openpgp):

2487

2331

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2502

2346

ctypes.byref(crtverify))

2503

2347

if crtverify.value != 0:

2504

2348

gnutls.openpgp_crt_deinit(crt)

2505

raise gnutls.CertificateSecurityError(code

2506

=crtverify.value)

2349

raise gnutls.CertificateSecurityError("Verify failed")

2507

2350

# New buffer for the fingerprint

2508

2351

buf = ctypes.create_string_buffer(20)

2509

2352

buf_len = ctypes.c_size_t()

2519

2362

return hex_fpr

2520

2363

2521

2364

2522

class MultiprocessingMixIn:

2365

class MultiprocessingMixIn(object):

2523

2366

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

2524

2367

2525

2368

def sub_process_main(self, request, address):

2526

2369

try:

2527

2370

self.finish_request(request, address)

2528

2371

except Exception:

2529

2372

self.handle_error(request, address)

2530

2373

self.close_request(request)

2531

2374

2532

2375

def process_request(self, request, address):

2533

2376

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

2534

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

2535

args=(request, address))

2377

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

2378

args = (request, address))

2536

2379

proc.start()

2537

2380

return proc

2538

2381

2539

2382

2540

class MultiprocessingMixInWithPipe(MultiprocessingMixIn):

2383

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2541

2384

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

2542

2385

2543

2386

def process_request(self, request, client_address):

2544

2387

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

2545

2388

2546

2389

This function creates a new pipe in self.pipe

2547

2390

"""

2548

2391

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2549

2392

2550

2393

proc = MultiprocessingMixIn.process_request(self, request,

2551

2394

client_address)

2552

2395

self.child_pipe.close()

2553

2396

self.add_pipe(parent_pipe, proc)

2554

2397

2555

2398

def add_pipe(self, parent_pipe, proc):

2556

2399

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

2557

2400

raise NotImplementedError()

2558

2401

2559

2402

2560

2403

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2561

socketserver.TCPServer):

2404

socketserver.TCPServer, object):

2562

2405

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

2563

2406

2564

2407

Attributes:

2565

2408

enabled: Boolean; whether this server is activated yet

2566

2409

interface: None or a network interface name (string)

2567

2410

use_ipv6: Boolean; to use IPv6 or not

2568

2411

"""

2569

2412

2570

2413

def __init__(self, server_address, RequestHandlerClass,

2571

2414

interface=None,

2572

2415

use_ipv6=True,

2582

2425

self.socketfd = socketfd

2583

2426

# Save the original socket.socket() function

2584

2427

self.socket_socket = socket.socket

2585

2586

2428

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

2587

#

2429

#

2588

2430

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

2589

2431

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

2590

2432

# patching socket.socket.)

2591

#

2433

#

2592

2434

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

2593

2435

@functools.wraps(socket.socket)

2594

2436

def socket_wrapper(*args, **kwargs):

2606

2448

# socket_wrapper(), if socketfd was set.

2607

2449

socketserver.TCPServer.__init__(self, server_address,

2608

2450

RequestHandlerClass)

2609

2451

2610

2452

def server_bind(self):

2611

2453

"""This overrides the normal server_bind() function

2612

2454

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

2637

2479

raise

2638

2480

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

2639

2481

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

2640

if self.server_address[1]:

2641

self.allow_reuse_address = True

2642

2482

if not self.server_address[0]:

2643

2483

if self.address_family == socket.AF_INET6:

2644

any_address = "::" # in6addr_any

2484

any_address = "::" # in6addr_any

2645

2485

else:

2646

any_address = "0.0.0.0" # INADDR_ANY

2486

any_address = "0.0.0.0" # INADDR_ANY

2647

2487

self.server_address = (any_address,

2648

2488

self.server_address[1])

2649

2489

elif not self.server_address[1]:

2659

2499

2660

2500

class MandosServer(IPv6_TCPServer):

2661

2501

"""Mandos server.

2662

2502

2663

2503

Attributes:

2664

2504

clients: set of Client objects

2665

2505

gnutls_priority GnuTLS priority string

2666

2506

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

2667

2507

2668

2508

Assumes a GLib.MainLoop event loop.

2669

2509

"""

2670

2510

2671

2511

def __init__(self, server_address, RequestHandlerClass,

2672

2512

interface=None,

2673

2513

use_ipv6=True,

2683

2523

self.gnutls_priority = gnutls_priority

2684

2524

IPv6_TCPServer.__init__(self, server_address,

2685

2525

RequestHandlerClass,

2686

interface=interface,

2687

use_ipv6=use_ipv6,

2688

socketfd=socketfd)

2689

2526

interface = interface,

2527

use_ipv6 = use_ipv6,

2528

socketfd = socketfd)

2529

2690

2530

def server_activate(self):

2691

2531

if self.enabled:

2692

2532

return socketserver.TCPServer.server_activate(self)

2693

2533

2694

2534

def enable(self):

2695

2535

self.enabled = True

2696

2536

2697

2537

def add_pipe(self, parent_pipe, proc):

2698

2538

# Call "handle_ipc" for both data and EOF events

2699

2539

GLib.io_add_watch(

2700

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

2701

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

2540

parent_pipe.fileno(),

2541

GLib.IO_IN | GLib.IO_HUP,

2702

2542

functools.partial(self.handle_ipc,

2703

parent_pipe=parent_pipe,

2704

proc=proc))

2705

2543

parent_pipe = parent_pipe,

2544

proc = proc))

2545

2706

2546

def handle_ipc(self, source, condition,

2707

2547

parent_pipe=None,

2708

proc=None,

2548

proc = None,

2709

2549

client_object=None):

2710

2550

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

2711

2551

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

2712

2552

# Wait for other process to exit

2713

2553

proc.join()

2714

2554

return False

2715

2555

2716

2556

# Read a request from the child

2717

2557

request = parent_pipe.recv()

2718

2558

command = request[0]

2719

2559

2720

2560

if command == 'init':

2721

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

2722

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

2723

address = request[3]

2724

2561

fpr = request[1]

2562

address = request[2]

2563

2725

2564

for c in self.clients.values():

2726

if key_id == "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855":

2727

continue

2728

if key_id and c.key_id == key_id:

2729

client = c

2730

break

2731

if fpr and c.fingerprint == fpr:

2565

if c.fingerprint == fpr:

2732

2566

client = c

2733

2567

break

2734

2568

else:

2735

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

2736

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

2569

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

2570

"dress: %s", fpr, address)

2737

2571

if self.use_dbus:

2738

2572

# Emit D-Bus signal

2739

mandos_dbus_service.ClientNotFound(key_id or fpr,

2573

mandos_dbus_service.ClientNotFound(fpr,

2740

2574

address[0])

2741

2575

parent_pipe.send(False)

2742

2576

return False

2743

2577

2744

2578

GLib.io_add_watch(

2745

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

2746

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

2579

parent_pipe.fileno(),

2580

GLib.IO_IN | GLib.IO_HUP,

2747

2581

functools.partial(self.handle_ipc,

2748

parent_pipe=parent_pipe,

2749

proc=proc,

2750

client_object=client))

2582

parent_pipe = parent_pipe,

2583

proc = proc,

2584

client_object = client))

2751

2585

parent_pipe.send(True)

2752

2586

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

2753

2587

# same fileno

2756

2590

funcname = request[1]

2757

2591

args = request[2]

2758

2592

kwargs = request[3]

2759

2593

2760

2594

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

2761

2595

funcname)(*args,

2762

2596

**kwargs)))

2763

2597

2764

2598

if command == 'getattr':

2765

2599

attrname = request[1]

2766

2600

if isinstance(client_object.__getattribute__(attrname),

2767

collections.abc.Callable):

2601

collections.Callable):

2768

2602

parent_pipe.send(('function', ))

2769

2603

else:

2770

2604

parent_pipe.send((

2771

2605

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

2772

2606

2773

2607

if command == 'setattr':

2774

2608

attrname = request[1]

2775

2609

value = request[2]

2776

2610

setattr(client_object, attrname, value)

2777

2611

2778

2612

return True

2779

2613

2780

2614

2781

2615

def rfc3339_duration_to_delta(duration):

2782

2616

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

2783

2784

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

2785

True

2786

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

2787

True

2788

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

2789

True

2790

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

2791

True

2792

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

2793

True

2794

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

2795

True

2796

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

2797

True

2617

2618

>>> rfc3339_duration_to_delta("P7D")

2619

datetime.timedelta(7)

2620

>>> rfc3339_duration_to_delta("PT60S")

2621

datetime.timedelta(0, 60)

2622

>>> rfc3339_duration_to_delta("PT60M")

2623

datetime.timedelta(0, 3600)

2624

>>> rfc3339_duration_to_delta("PT24H")

2625

datetime.timedelta(1)

2626

>>> rfc3339_duration_to_delta("P1W")

2627

datetime.timedelta(7)

2628

>>> rfc3339_duration_to_delta("PT5M30S")

2629

datetime.timedelta(0, 330)

2630

>>> rfc3339_duration_to_delta("P1DT3M20S")

2631

datetime.timedelta(1, 200)

2798

2632

"""

2799

2633

2800

2634

# Parsing an RFC 3339 duration with regular expressions is not

2801

2635

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

2802

2636

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

2803

2637

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

2804

2638

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

2805

2639

# avoid excessive use of external libraries.

2806

2640

2807

2641

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

2808

2642

Token = collections.namedtuple("Token", (

2809

2643

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

2842

2676

frozenset((token_year, token_month,

2843

2677

token_day, token_time,

2844

2678

token_week)))

2845

# Define starting values:

2846

# Value so far

2847

value = datetime.timedelta()

2679

# Define starting values

2680

value = datetime.timedelta() # Value so far

2848

2681

found_token = None

2849

# Following valid tokens

2850

followers = frozenset((token_duration, ))

2851

# String left to parse

2852

s = duration

2682

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

2683

s = duration # String left to parse

2853

2684

# Loop until end token is found

2854

2685

while found_token is not token_end:

2855

2686

# Search for any currently valid tokens

2879

2710

2880

2711

def string_to_delta(interval):

2881

2712

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

2882

2883

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

2884

True

2885

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

2886

True

2887

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

2888

True

2889

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

2890

True

2891

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

2892

True

2893

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

2894

True

2713

2714

>>> string_to_delta('7d')

2715

datetime.timedelta(7)

2716

>>> string_to_delta('60s')

2717

datetime.timedelta(0, 60)

2718

>>> string_to_delta('60m')

2719

datetime.timedelta(0, 3600)

2720

>>> string_to_delta('24h')

2721

datetime.timedelta(1)

2722

>>> string_to_delta('1w')

2723

datetime.timedelta(7)

2724

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

2725

datetime.timedelta(0, 330)

2895

2726

"""

2896

2727

2897

2728

try:

2898

2729

return rfc3339_duration_to_delta(interval)

2899

2730

except ValueError:

2900

2731

pass

2901

2732

2902

2733

timevalue = datetime.timedelta(0)

2903

2734

for s in interval.split():

2904

2735

try:

2922

2753

return timevalue

2923

2754

2924

2755

2925

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

2756

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

2926

2757

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

2927

2758

2928

2759

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

2929

2760

if os.fork():

2930

2761

sys.exit()

2948

2779

2949

2780

2950

2781

def main():

2951

2782

2952

2783

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

2953

2784

# Parsing of options, both command line and config file

2954

2785

2955

2786

parser = argparse.ArgumentParser()

2956

2787

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

2957

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

2788

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

2958

2789

help="show version number and exit")

2959

2790

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

2960

2791

help="Bind to interface IF")

2996

2827

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

2997

2828

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

2998

2829

default=None)

2999

2830

3000

2831

options = parser.parse_args()

3001

2832

2833

if options.check:

2834

import doctest

2835

fail_count, test_count = doctest.testmod()

2836

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

2837

3002

2838

# Default values for config file for server-global settings

3003

if gnutls.has_rawpk:

3004

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

3005

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

3006

else:

3007

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

3008

":+SIGN-DSA-SHA256")

3009

server_defaults = {"interface": "",

3010

"address": "",

3011

"port": "",

3012

"debug": "False",

3013

"priority": priority,

3014

"servicename": "Mandos",

3015

"use_dbus": "True",

3016

"use_ipv6": "True",

3017

"debuglevel": "",

3018

"restore": "True",

3019

"socket": "",

3020

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

3021

"foreground": "False",

3022

"zeroconf": "True",

3023

}

3024

del priority

3025

2839

server_defaults = { "interface": "",

2840

"address": "",

2841

"port": "",

2842

"debug": "False",

2843

"priority":

2844

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

2845

":+SIGN-DSA-SHA256",

2846

"servicename": "Mandos",

2847

"use_dbus": "True",

2848

"use_ipv6": "True",

2849

"debuglevel": "",

2850

"restore": "True",

2851

"socket": "",

2852

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

2853

"foreground": "False",

2854

"zeroconf": "True",

2855

}

2856

3026

2857

# Parse config file for server-global settings

3027

server_config = configparser.ConfigParser(server_defaults)

2858

server_config = configparser.SafeConfigParser(server_defaults)

3028

2859

del server_defaults

3029

2860

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

3030

# Convert the ConfigParser object to a dict

2861

# Convert the SafeConfigParser object to a dict

3031

2862

server_settings = server_config.defaults()

3032

2863

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

3033

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

3034

"foreground", "zeroconf"):

2864

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

3035

2865

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

3036

2866

option)

3037

2867

if server_settings["port"]:

3047

2877

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

3048

2878

["socket"])

3049

2879

del server_config

3050

2880

3051

2881

# Override the settings from the config file with command line

3052

2882

# options, if set.

3053

2883

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

3071

2901

if server_settings["debug"]:

3072

2902

server_settings["foreground"] = True

3073

2903

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

3074

2904

3075

2905

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

3076

2906

3077

2907

if (not server_settings["zeroconf"]

3078

2908

and not (server_settings["port"]

3079

2909

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

3080

2910

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

3081

2911

3082

2912

# For convenience

3083

2913

debug = server_settings["debug"]

3084

2914

debuglevel = server_settings["debuglevel"]

3088

2918

stored_state_file)

3089

2919

foreground = server_settings["foreground"]

3090

2920

zeroconf = server_settings["zeroconf"]

3091

2921

3092

2922

if debug:

3093

2923

initlogger(debug, logging.DEBUG)

3094

2924

else:

3097

2927

else:

3098

2928

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

3099

2929

initlogger(debug, level)

3100

2930

3101

2931

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

3102

2932

syslogger.setFormatter(

3103

2933

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

3104

2934

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

3105

2935

server_settings["servicename"])))

3106

2936

3107

2937

# Parse config file with clients

3108

client_config = configparser.ConfigParser(Client.client_defaults)

2938

client_config = configparser.SafeConfigParser(Client

2939

.client_defaults)

3109

2940

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

3110

2941

"clients.conf"))

3111

2942

3112

2943

global mandos_dbus_service

3113

2944

mandos_dbus_service = None

3114

2945

3115

2946

socketfd = None

3116

2947

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

3117

2948

socketfd = server_settings["socket"]

3133

2964

except IOError as e:

3134

2965

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

3135

2966

exc_info=e)

3136

2967

3137

2968

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

3138

2969

("mandos", "mandos"),

3139

2970

("nobody", "nogroup")):

3157

2988

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

3158

2989

if error.errno != errno.EPERM:

3159

2990

raise

3160

2991

3161

2992

if debug:

3162

2993

# Enable all possible GnuTLS debugging

3163

2994

3164

2995

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

3165

2996

# - GnuTLS manual

3166

2997

gnutls.global_set_log_level(11)

3167

2998

3168

2999

@gnutls.log_func

3169

3000

def debug_gnutls(level, string):

3170

3001

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

3171

3002

3172

3003

gnutls.global_set_log_function(debug_gnutls)

3173

3004

3174

3005

# Redirect stdin so all checkers get /dev/null

3175

3006

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

3176

3007

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

3177

3008

if null > 2:

3178

3009

os.close(null)

3179

3010

3180

3011

# Need to fork before connecting to D-Bus

3181

3012

if not foreground:

3182

3013

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

3183

3014

daemon()

3184

3185

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

3186

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

3187

# need to inform GLib that threads will be used.

3188

GLib.threads_init()

3189

3015

3016

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

3017

# to inform GLib that threads will be used.

3018

GLib.threads_init()

3019

3190

3020

global main_loop

3191

3021

# From the Avahi example code

3192

3022

DBusGMainLoop(set_as_default=True)

3209

3039

if zeroconf:

3210

3040

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3211

3041

service = AvahiServiceToSyslog(

3212

name=server_settings["servicename"],

3213

servicetype="_mandos._tcp",

3214

protocol=protocol,

3215

bus=bus)

3042

name = server_settings["servicename"],

3043

servicetype = "_mandos._tcp",

3044

protocol = protocol,

3045

bus = bus)

3216

3046

if server_settings["interface"]:

3217

3047

service.interface = if_nametoindex(

3218

3048

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

3219

3049

3220

3050

global multiprocessing_manager

3221

3051

multiprocessing_manager = multiprocessing.Manager()

3222

3052

3223

3053

client_class = Client

3224

3054

if use_dbus:

3225

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

3226

3055

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

3056

3227

3057

client_settings = Client.config_parser(client_config)

3228

3058

old_client_settings = {}

3229

3059

clients_data = {}

3230

3060

3231

3061

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

3232

3062

global wnull

3233

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

3063

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

3234

3064

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

3235

3065

# mode

3236

3066

if debug or not foreground:

3237

3067

wnull.close()

3238

3068

3239

3069

# Get client data and settings from last running state.

3240

3070

if server_settings["restore"]:

3241

3071

try:

3242

3072

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

3243

if sys.version_info.major == 2:

3073

if sys.version_info.major == 2:

3244

3074

clients_data, old_client_settings = pickle.load(

3245

3075

stored_state)

3246

3076

else:

3247

3077

bytes_clients_data, bytes_old_client_settings = (

3248

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

3249

# Fix bytes to strings

3250

# clients_data

3078

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

3079

### Fix bytes to strings

3080

## clients_data

3251

3081

# .keys()

3252

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

3253

if isinstance(key, bytes)

3254

else key): value

3255

for key, value in

3256

bytes_clients_data.items()}

3082

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

3083

if isinstance(key, bytes)

3084

else key): value

3085

for key, value in

3086

bytes_clients_data.items() }

3257

3087

del bytes_clients_data

3258

3088

for key in clients_data:

3259

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

3260

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

3261

for k, v in

3262

clients_data[key].items()}

3089

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

3090

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

3091

for k, v in

3092

clients_data[key].items() }

3263

3093

clients_data[key] = value

3264

3094

# .client_structure

3265

3095

value["client_structure"] = [

3266

3096

(s.decode("utf-8")

3267

3097

if isinstance(s, bytes)

3268

3098

else s) for s in

3269

value["client_structure"]]

3270

# .name, .host, and .checker_command

3271

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

3099

value["client_structure"] ]

3100

# .name & .host

3101

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

3272

3102

if isinstance(value[k], bytes):

3273

3103

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

3274

if "key_id" not in value:

3275

value["key_id"] = ""

3276

elif "fingerprint" not in value:

3277

value["fingerprint"] = ""

3278

# old_client_settings

3104

## old_client_settings

3279

3105

# .keys()

3280

3106

old_client_settings = {

3281

3107

(key.decode("utf-8")

3282

3108

if isinstance(key, bytes)

3283

3109

else key): value

3284

3110

for key, value in

3285

bytes_old_client_settings.items()}

3111

bytes_old_client_settings.items() }

3286

3112

del bytes_old_client_settings

3287

# .host and .checker_command

3113

# .host

3288

3114

for value in old_client_settings.values():

3289

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

3290

if isinstance(value[attribute], bytes):

3291

value[attribute] = (value[attribute]

3292

.decode("utf-8"))

3115

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

3116

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

3117

.decode("utf-8"))

3293

3118

os.remove(stored_state_path)

3294

3119

except IOError as e:

3295

3120

if e.errno == errno.ENOENT:

3303

3128

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

3304

3129

"EOFError:",

3305

3130

exc_info=e)

3306

3131

3307

3132

with PGPEngine() as pgp:

3308

3133

for client_name, client in clients_data.items():

3309

3134

# Skip removed clients

3310

3135

if client_name not in client_settings:

3311

3136

continue

3312

3137

3313

3138

# Decide which value to use after restoring saved state.

3314

3139

# We have three different values: Old config file,

3315

3140

# new config file, and saved state.

3326

3151

client[name] = value

3327

3152

except KeyError:

3328

3153

pass

3329

3154

3330

3155

# Clients who has passed its expire date can still be

3331

3156

# enabled if its last checker was successful. A Client

3332

3157

# whose checker succeeded before we stored its state is

3365

3190

client_name))

3366

3191

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

3367

3192

["secret"])

3368

3193

3369

3194

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

3370

3195

for client_name in (set(old_client_settings)

3371

3196

- set(client_settings)):

3373

3198

for client_name in (set(client_settings)

3374

3199

- set(old_client_settings)):

3375

3200

clients_data[client_name] = client_settings[client_name]

3376

3201

3377

3202

# Create all client objects

3378

3203

for client_name, client in clients_data.items():

3379

3204

tcp_server.clients[client_name] = client_class(

3380

name=client_name,

3381

settings=client,

3382

server_settings=server_settings)

3383

3205

name = client_name,

3206

settings = client,

3207

server_settings = server_settings)

3208

3384

3209

if not tcp_server.clients:

3385

3210

logger.warning("No clients defined")

3386

3211

3387

3212

if not foreground:

3388

3213

if pidfile is not None:

3389

3214

pid = os.getpid()

3395

3220

pidfilename, pid)

3396

3221

del pidfile

3397

3222

del pidfilename

3398

3223

3399

3224

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

3400

3225

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3401

3226

lambda: main_loop.quit() and False)

3402

3227

3403

3228

if use_dbus:

3404

3229

3405

3230

@alternate_dbus_interfaces(

3406

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

3231

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

3407

3232

class MandosDBusService(DBusObjectWithObjectManager):

3408

3233

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

3409

3234

3410

3235

def __init__(self):

3411

3236

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

3412

3237

3413

3238

_interface = "se.recompile.Mandos"

3414

3239

3415

3240

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

3416

3241

def ClientAdded(self, objpath):

3417

3242

"D-Bus signal"

3418

3243

pass

3419

3244

3420

3245

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

3421

def ClientNotFound(self, key_id, address):

3246

def ClientNotFound(self, fingerprint, address):

3422

3247

"D-Bus signal"

3423

3248

pass

3424

3249

3425

3250

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

3426

3251

"true"})

3427

3252

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

3428

3253

def ClientRemoved(self, objpath, name):

3429

3254

"D-Bus signal"

3430

3255

pass

3431

3256

3432

3257

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

3433

3258

"true"})

3434

3259

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

3436

3261

"D-Bus method"

3437

3262

return dbus.Array(c.dbus_object_path for c in

3438

3263

tcp_server.clients.values())

3439

3264

3440

3265

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

3441

3266

"true"})

3442

3267

@dbus.service.method(_interface,

3444

3269

def GetAllClientsWithProperties(self):

3445

3270

"D-Bus method"

3446

3271

return dbus.Dictionary(

3447

{c.dbus_object_path: c.GetAll(

3272

{ c.dbus_object_path: c.GetAll(

3448

3273

"se.recompile.Mandos.Client")

3449

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

3274

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

3450

3275

signature="oa{sv}")

3451

3276

3452

3277

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

3453

3278

def RemoveClient(self, object_path):

3454

3279

"D-Bus method"

3462

3287

self.client_removed_signal(c)

3463

3288

return

3464

3289

raise KeyError(object_path)

3465

3290

3466

3291

del _interface

3467

3292

3468

3293

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3469

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

3294

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

3470

3295

def GetManagedObjects(self):

3471

3296

"""D-Bus method"""

3472

3297

return dbus.Dictionary(

3473

{client.dbus_object_path:

3474

dbus.Dictionary(

3475

{interface: client.GetAll(interface)

3476

for interface in

3477

client._get_all_interface_names()})

3478

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

3479

3298

{ client.dbus_object_path:

3299

dbus.Dictionary(

3300

{ interface: client.GetAll(interface)

3301

for interface in

3302

client._get_all_interface_names()})

3303

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

3304

3480

3305

def client_added_signal(self, client):

3481

3306

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

3482

3307

if use_dbus:

3484

3309

self.InterfacesAdded(

3485

3310

client.dbus_object_path,

3486

3311

dbus.Dictionary(

3487

{interface: client.GetAll(interface)

3488

for interface in

3489

client._get_all_interface_names()}))

3312

{ interface: client.GetAll(interface)

3313

for interface in

3314

client._get_all_interface_names()}))

3490

3315

# Old signal

3491

3316

self.ClientAdded(client.dbus_object_path)

3492

3317

3493

3318

def client_removed_signal(self, client):

3494

3319

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

3495

3320

if use_dbus:

3500

3325

# Old signal

3501

3326

self.ClientRemoved(client.dbus_object_path,

3502

3327

client.name)

3503

3328

3504

3329

mandos_dbus_service = MandosDBusService()

3505

3330

3506

3331

# Save modules to variables to exempt the modules from being

3507

3332

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

3508

3333

mp = multiprocessing

3509

3334

wn = wnull

3510

3511

3335

def cleanup():

3512

3336

"Cleanup function; run on exit"

3513

3337

if zeroconf:

3514

3338

service.cleanup()

3515

3339

3516

3340

mp.active_children()

3517

3341

wn.close()

3518

3342

if not (tcp_server.clients or client_settings):

3519

3343

return

3520

3344

3521

3345

# Store client before exiting. Secrets are encrypted with key

3522

3346

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

3523

3347

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

3528

3352

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

3529

3353

key)

3530

3354

client_dict = {}

3531

3355

3532

3356

# A list of attributes that can not be pickled

3533

3357

# + secret.

3534

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

3535

"checker", "server_settings"}

3358

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

3359

"checker", "server_settings" }

3536

3360

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

3537

3361

.Object):

3538

3362

exclude.add(name)

3539

3363

3540

3364

client_dict["encrypted_secret"] = (client

3541

3365

.encrypted_secret)

3542

3366

for attr in client.client_structure:

3543

3367

if attr not in exclude:

3544

3368

client_dict[attr] = getattr(client, attr)

3545

3369

3546

3370

clients[client.name] = client_dict

3547

3371

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

3548

3372

3549

3373

try:

3550

3374

with tempfile.NamedTemporaryFile(

3551

3375

mode='wb',

3554

3378

dir=os.path.dirname(stored_state_path),

3555

3379

delete=False) as stored_state:

3556

3380

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

3557

protocol=2)

3381

protocol = 2)

3558

3382

tempname = stored_state.name

3559

3383

os.rename(tempname, stored_state_path)

3560

3384

except (IOError, OSError) as e:

3570

3394

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

3571

3395

exc_info=e)

3572

3396

raise

3573

3397

3574

3398

# Delete all clients, and settings from config

3575

3399

while tcp_server.clients:

3576

3400

name, client = tcp_server.clients.popitem()

3582

3406

if use_dbus:

3583

3407

mandos_dbus_service.client_removed_signal(client)

3584

3408

client_settings.clear()

3585

3409

3586

3410

atexit.register(cleanup)

3587

3411

3588

3412

for client in tcp_server.clients.values():

3589

3413

if use_dbus:

3590

3414

# Emit D-Bus signal for adding

3592

3416

# Need to initiate checking of clients

3593

3417

if client.enabled:

3594

3418

client.init_checker()

3595

3419

3596

3420

tcp_server.enable()

3597

3421

tcp_server.server_activate()

3598

3422

3599

3423

# Find out what port we got

3600

3424

if zeroconf:

3601

3425

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

3606

3430

else: # IPv4

3607

3431

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

3608

3432

*tcp_server.socket.getsockname())

3609

3610

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

3611

3433

3434

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

3435

3612

3436

try:

3613

3437

if zeroconf:

3614

3438

# From the Avahi example code

3619

3443

cleanup()

3620

3444

sys.exit(1)

3621

3445

# End of Avahi example code

3622

3623

GLib.io_add_watch(

3624

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

3625

GLib.PRIORITY_DEFAULT, GLib.IO_IN,

3626

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

3627

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

3628

3446

3447

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

3448

lambda *args, **kwargs:

3449

(tcp_server.handle_request

3450

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

3451

3629

3452

logger.debug("Starting main loop")

3630

3453

main_loop.run()

3631

3454

except AvahiError as error:

3640

3463

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

3641

3464

cleanup()

3642

3465

3643

3644

def should_only_run_tests():

3645

parser = argparse.ArgumentParser(add_help=False)

3646

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

3647

args, unknown_args = parser.parse_known_args()

3648

run_tests = args.check

3649

if run_tests:

3650

# Remove --check argument from sys.argv

3651

sys.argv[1:] = unknown_args

3652

return run_tests

3653

3654

# Add all tests from doctest strings

3655

def load_tests(loader, tests, none):

3656

import doctest

3657

tests.addTests(doctest.DocTestSuite())

3658

return tests

3659

3466

3660

3467

if __name__ == '__main__':

3661

try:

3662

if should_only_run_tests():

3663

# Call using ./mandos --check [--verbose]

3664

unittest.main()

3665

else:

3666

main()

3667

finally:

3668

logging.shutdown()

3468

main()