/mandos/release : revision 237.7.332

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

2

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

3

#

3

#

4

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

5

#

5

#

6

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

7

# service publisher, downloaded from

8

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

9

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

10

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

11

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

12

#

12

#

13

# Everything else is

14

15

16

#

17

# This file is part of Mandos.

18

#

19

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

20

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

14

15

16

#

17

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

18

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

21

19

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

22

20

# (at your option) any later version.

23

21

#

24

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

25

# WITHOUT ANY WARRANTY; without even the implied warranty of

22

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

23

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

26

24

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

27

25

# GNU General Public License for more details.

28

#

26

#

29

27

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

30

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

31

#

28

# along with this program. If not, see

29

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

30

#

32

31

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

33

#

32

#

34

33

35

34

from __future__ import (division, absolute_import, print_function,

36

35

unicode_literals)

37

36

38

try:

39

from future_builtins import *

40

except ImportError:

41

pass

37

from future_builtins import *

42

38

43

39

try:

44

40

import SocketServer as socketserver

48

44

import argparse

49

45

import datetime

50

46

import errno

47

import gnutls.crypto

48

import gnutls.connection

49

import gnutls.errors

50

import gnutls.library.functions

51

import gnutls.library.constants

52

import gnutls.library.types

51

53

try:

52

54

import ConfigParser as configparser

53

55

except ImportError:

80

82

81

83

import dbus

82

84

import dbus.service

83

from gi.repository import GLib

85

try:

86

import gobject

87

except ImportError:

88

from gi.repository import GObject as gobject

89

import avahi

84

90

from dbus.mainloop.glib import DBusGMainLoop

85

91

import ctypes

86

92

import ctypes.util

87

93

import xml.dom.minidom

88

94

import inspect

89

95

90

# Try to find the value of SO_BINDTODEVICE:

91

96

try:

92

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

93

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

94

97

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

95

98

except AttributeError:

96

99

try:

97

# This is where SO_BINDTODEVICE was up to and including Python

98

# 2.6, and also 3.2:

99

100

from IN import SO_BINDTODEVICE

100

101

except ImportError:

101

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

102

# Try running the C preprocessor:

103

try:

104

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

105

"/dev/stdin"],

106

stdin=subprocess.PIPE,

107

stdout=subprocess.PIPE)

108

stdout = cc.communicate(

109

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

110

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

111

except (OSError, ValueError, IndexError):

112

# No value found

113

SO_BINDTODEVICE = None

102

SO_BINDTODEVICE = None

114

103

115

104

if sys.version_info.major == 2:

116

105

str = unicode

117

106

118

version = "1.7.19"

107

version = "1.6.9"

119

108

stored_state_file = "clients.pickle"

120

109

121

110

logger = logging.getLogger()

125

114

if_nametoindex = ctypes.cdll.LoadLibrary(

126

115

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

127

116

except (OSError, AttributeError):

128

117

129

118

def if_nametoindex(interface):

130

119

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

131

120

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

136

125

return interface_index

137

126

138

127

139

def copy_function(func):

140

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

141

if sys.version_info.major == 2:

142

return types.FunctionType(func.func_code,

143

func.func_globals,

144

func.func_name,

145

func.func_defaults,

146

func.func_closure)

147

else:

148

return types.FunctionType(func.__code__,

149

func.__globals__,

150

func.__name__,

151

func.__defaults__,

152

func.__closure__)

153

154

155

128

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

156

129

"""init logger and add loglevel"""

157

130

158

131

global syslogger

159

132

syslogger = (logging.handlers.SysLogHandler(

160

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

161

address="/dev/log"))

133

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

134

address = "/dev/log"))

162

135

syslogger.setFormatter(logging.Formatter

163

136

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

164

137

' %(message)s'))

165

138

logger.addHandler(syslogger)

166

139

167

140

if debug:

168

141

console = logging.StreamHandler()

169

142

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

181

154

182

155

class PGPEngine(object):

183

156

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

184

157

185

158

def __init__(self):

186

159

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

187

self.gpg = "gpg"

188

try:

189

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

190

for line in output.splitlines():

191

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

192

if name == "gpg":

193

self.gpg = path

194

break

195

except OSError as e:

196

if e.errno != errno.ENOENT:

197

raise

198

160

self.gnupgargs = ['--batch',

199

'--homedir', self.tempdir,

161

'--home', self.tempdir,

200

162

'--force-mdc',

201

'--quiet']

202

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

203

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

204

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

205

163

'--quiet',

164

'--no-use-agent']

165

206

166

def __enter__(self):

207

167

return self

208

168

209

169

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

210

170

self._cleanup()

211

171

return False

212

172

213

173

def __del__(self):

214

174

self._cleanup()

215

175

216

176

def _cleanup(self):

217

177

if self.tempdir is not None:

218

178

# Delete contents of tempdir

219

179

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

220

topdown=False):

180

topdown = False):

221

181

for filename in files:

222

182

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

223

183

for dirname in dirs:

225

185

# Remove tempdir

226

186

os.rmdir(self.tempdir)

227

187

self.tempdir = None

228

188

229

189

def password_encode(self, password):

230

190

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

231

191

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

236

196

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

237

197

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

238

198

return encoded

239

199

240

200

def encrypt(self, data, password):

241

201

passphrase = self.password_encode(password)

242

202

with tempfile.NamedTemporaryFile(

243

203

dir=self.tempdir) as passfile:

244

204

passfile.write(passphrase)

245

205

passfile.flush()

246

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

206

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

247

207

'--passphrase-file',

248

208

passfile.name]

249

209

+ self.gnupgargs,

250

stdin=subprocess.PIPE,

251

stdout=subprocess.PIPE,

252

stderr=subprocess.PIPE)

253

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

210

stdin = subprocess.PIPE,

211

stdout = subprocess.PIPE,

212

stderr = subprocess.PIPE)

213

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

254

214

if proc.returncode != 0:

255

215

raise PGPError(err)

256

216

return ciphertext

257

217

258

218

def decrypt(self, data, password):

259

219

passphrase = self.password_encode(password)

260

220

with tempfile.NamedTemporaryFile(

261

dir=self.tempdir) as passfile:

221

dir = self.tempdir) as passfile:

262

222

passfile.write(passphrase)

263

223

passfile.flush()

264

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

224

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

265

225

'--passphrase-file',

266

226

passfile.name]

267

227

+ self.gnupgargs,

268

stdin=subprocess.PIPE,

269

stdout=subprocess.PIPE,

270

stderr=subprocess.PIPE)

271

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

228

stdin = subprocess.PIPE,

229

stdout = subprocess.PIPE,

230

stderr = subprocess.PIPE)

231

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

272

232

if proc.returncode != 0:

273

233

raise PGPError(err)

274

234

return decrypted_plaintext

275

235

276

236

277

# Pretend that we have an Avahi module

278

class Avahi(object):

279

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

280

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

281

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

282

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

283

PROTO_INET = 0 # avahi-common/address.h

284

PROTO_INET6 = 1 # avahi-common/address.h

285

DBUS_NAME = "org.freedesktop.Avahi"

286

DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"

287

DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"

288

DBUS_PATH_SERVER = "/"

289

290

def string_array_to_txt_array(self, t):

291

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

292

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

293

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

294

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

295

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

296

SERVER_INVALID = 0 # avahi-common/defs.h

297

SERVER_REGISTERING = 1 # avahi-common/defs.h

298

SERVER_RUNNING = 2 # avahi-common/defs.h

299

SERVER_COLLISION = 3 # avahi-common/defs.h

300

SERVER_FAILURE = 4 # avahi-common/defs.h

301

avahi = Avahi()

302

303

304

237

class AvahiError(Exception):

305

238

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

306

239

self.value = value

318

251

319

252

class AvahiService(object):

320

253

"""An Avahi (Zeroconf) service.

321

254

322

255

Attributes:

323

256

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

324

257

Used to optionally bind to the specified interface.

336

269

server: D-Bus Server

337

270

bus: dbus.SystemBus()

338

271

"""

339

272

340

273

def __init__(self,

341

interface=avahi.IF_UNSPEC,

342

name=None,

343

servicetype=None,

344

port=None,

345

TXT=None,

346

domain="",

347

host="",

348

max_renames=32768,

349

protocol=avahi.PROTO_UNSPEC,

350

bus=None):

274

interface = avahi.IF_UNSPEC,

275

name = None,

276

servicetype = None,

277

port = None,

278

TXT = None,

279

domain = "",

280

host = "",

281

max_renames = 32768,

282

protocol = avahi.PROTO_UNSPEC,

283

bus = None):

351

284

self.interface = interface

352

285

self.name = name

353

286

self.type = servicetype

362

295

self.server = None

363

296

self.bus = bus

364

297

self.entry_group_state_changed_match = None

365

298

366

299

def rename(self, remove=True):

367

300

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

368

301

if self.rename_count >= self.max_renames:

388

321

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

389

322

self.cleanup()

390

323

os._exit(1)

391

324

392

325

def remove(self):

393

326

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

394

327

if self.entry_group_state_changed_match is not None:

396

329

self.entry_group_state_changed_match = None

397

330

if self.group is not None:

398

331

self.group.Reset()

399

332

400

333

def add(self):

401

334

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

402

335

self.remove()

419

352

dbus.UInt16(self.port),

420

353

avahi.string_array_to_txt_array(self.TXT))

421

354

self.group.Commit()

422

355

423

356

def entry_group_state_changed(self, state, error):

424

357

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

425

358

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

426

359

427

360

if state == avahi.ENTRY_GROUP_ESTABLISHED:

428

361

logger.debug("Zeroconf service established.")

429

362

elif state == avahi.ENTRY_GROUP_COLLISION:

433

366

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

434

367

str(error))

435

368

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

436

369

437

370

def cleanup(self):

438

371

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

439

372

if self.group is not None:

444

377

pass

445

378

self.group = None

446

379

self.remove()

447

380

448

381

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

449

382

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

450

383

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

479

412

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

480

413

else:

481

414

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

482

415

483

416

def activate(self):

484

417

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

485

418

if self.server is None:

496

429

class AvahiServiceToSyslog(AvahiService):

497

430

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

498

431

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

499

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

432

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

500

433

syslogger.setFormatter(logging.Formatter(

501

434

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

502

435

.format(self.name)))

503

436

return ret

504

437

505

506

# Pretend that we have a GnuTLS module

507

class GnuTLS(object):

508

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

509

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

510

511

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

512

if library is None:

513

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

514

_library = ctypes.cdll.LoadLibrary(library)

515

del library

516

_need_version = b"3.3.0"

517

518

def __init__(self):

519

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

520

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

521

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

522

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

523

.format(self._need_version))

524

525

# Unless otherwise indicated, the constants and types below are

526

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

527

528

# Constants

529

E_SUCCESS = 0

530

E_INTERRUPTED = -52

531

E_AGAIN = -28

532

CRT_OPENPGP = 2

533

CLIENT = 2

534

SHUT_RDWR = 0

535

CRD_CERTIFICATE = 1

536

E_NO_CERTIFICATE_FOUND = -49

537

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

538

539

# Types

540

class session_int(ctypes.Structure):

541

_fields_ = []

542

session_t = ctypes.POINTER(session_int)

543

544

class certificate_credentials_st(ctypes.Structure):

545

_fields_ = []

546

certificate_credentials_t = ctypes.POINTER(

547

certificate_credentials_st)

548

certificate_type_t = ctypes.c_int

549

550

class datum_t(ctypes.Structure):

551

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

552

('size', ctypes.c_uint)]

553

554

class openpgp_crt_int(ctypes.Structure):

555

_fields_ = []

556

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

557

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

558

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

559

credentials_type_t = ctypes.c_int

560

transport_ptr_t = ctypes.c_void_p

561

close_request_t = ctypes.c_int

562

563

# Exceptions

564

class Error(Exception):

565

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

566

# exception might be raised from within GnuTLS.__init__,

567

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

568

# global variable has happened.

569

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

570

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

571

# code is passed, convert it to a string with

572

# gnutls.strerror()

573

self.code = code

574

if message is None and code is not None:

575

message = GnuTLS.strerror(code)

576

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

577

message, *args)

578

579

class CertificateSecurityError(Error):

580

pass

581

582

# Classes

583

class Credentials(object):

584

def __init__(self):

585

self._c_object = gnutls.certificate_credentials_t()

586

gnutls.certificate_allocate_credentials(

587

ctypes.byref(self._c_object))

588

self.type = gnutls.CRD_CERTIFICATE

589

590

def __del__(self):

591

gnutls.certificate_free_credentials(self._c_object)

592

593

class ClientSession(object):

594

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

595

self._c_object = gnutls.session_t()

596

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

597

gnutls.set_default_priority(self._c_object)

598

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

599

gnutls.handshake_set_private_extensions(self._c_object,

600

True)

601

self.socket = socket

602

if credentials is None:

603

credentials = gnutls.Credentials()

604

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

605

ctypes.cast(credentials._c_object,

606

ctypes.c_void_p))

607

self.credentials = credentials

608

609

def __del__(self):

610

gnutls.deinit(self._c_object)

611

612

def handshake(self):

613

return gnutls.handshake(self._c_object)

614

615

def send(self, data):

616

data = bytes(data)

617

data_len = len(data)

618

while data_len > 0:

619

data_len -= gnutls.record_send(self._c_object,

620

data[-data_len:],

621

data_len)

622

623

def bye(self):

624

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

625

626

# Error handling functions

627

def _error_code(result):

628

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

629

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

630

if result >= 0:

631

return result

632

if result == gnutls.E_NO_CERTIFICATE_FOUND:

633

raise gnutls.CertificateSecurityError(code=result)

634

raise gnutls.Error(code=result)

635

636

def _retry_on_error(result, func, arguments):

637

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

638

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

639

while result < 0:

640

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

641

return _error_code(result)

642

result = func(*arguments)

643

return result

644

645

# Unless otherwise indicated, the function declarations below are

646

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

647

648

# Functions

649

priority_set_direct = _library.gnutls_priority_set_direct

650

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

651

ctypes.POINTER(ctypes.c_char_p)]

652

priority_set_direct.restype = _error_code

653

654

init = _library.gnutls_init

655

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

656

init.restype = _error_code

657

658

set_default_priority = _library.gnutls_set_default_priority

659

set_default_priority.argtypes = [session_t]

660

set_default_priority.restype = _error_code

661

662

record_send = _library.gnutls_record_send

663

record_send.argtypes = [session_t, ctypes.c_void_p,

664

ctypes.c_size_t]

665

record_send.restype = ctypes.c_ssize_t

666

record_send.errcheck = _retry_on_error

667

668

certificate_allocate_credentials = (

669

_library.gnutls_certificate_allocate_credentials)

670

certificate_allocate_credentials.argtypes = [

671

ctypes.POINTER(certificate_credentials_t)]

672

certificate_allocate_credentials.restype = _error_code

673

674

certificate_free_credentials = (

675

_library.gnutls_certificate_free_credentials)

676

certificate_free_credentials.argtypes = [

677

certificate_credentials_t]

678

certificate_free_credentials.restype = None

679

680

handshake_set_private_extensions = (

681

_library.gnutls_handshake_set_private_extensions)

682

handshake_set_private_extensions.argtypes = [session_t,

683

ctypes.c_int]

684

handshake_set_private_extensions.restype = None

685

686

credentials_set = _library.gnutls_credentials_set

687

credentials_set.argtypes = [session_t, credentials_type_t,

688

ctypes.c_void_p]

689

credentials_set.restype = _error_code

690

691

strerror = _library.gnutls_strerror

692

strerror.argtypes = [ctypes.c_int]

693

strerror.restype = ctypes.c_char_p

694

695

certificate_type_get = _library.gnutls_certificate_type_get

696

certificate_type_get.argtypes = [session_t]

697

certificate_type_get.restype = _error_code

698

699

certificate_get_peers = _library.gnutls_certificate_get_peers

700

certificate_get_peers.argtypes = [session_t,

701

ctypes.POINTER(ctypes.c_uint)]

702

certificate_get_peers.restype = ctypes.POINTER(datum_t)

703

704

global_set_log_level = _library.gnutls_global_set_log_level

705

global_set_log_level.argtypes = [ctypes.c_int]

706

global_set_log_level.restype = None

707

708

global_set_log_function = _library.gnutls_global_set_log_function

709

global_set_log_function.argtypes = [log_func]

710

global_set_log_function.restype = None

711

712

deinit = _library.gnutls_deinit

713

deinit.argtypes = [session_t]

714

deinit.restype = None

715

716

handshake = _library.gnutls_handshake

717

handshake.argtypes = [session_t]

718

handshake.restype = _error_code

719

handshake.errcheck = _retry_on_error

720

721

transport_set_ptr = _library.gnutls_transport_set_ptr

722

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

723

transport_set_ptr.restype = None

724

725

bye = _library.gnutls_bye

726

bye.argtypes = [session_t, close_request_t]

727

bye.restype = _error_code

728

bye.errcheck = _retry_on_error

729

730

check_version = _library.gnutls_check_version

731

check_version.argtypes = [ctypes.c_char_p]

732

check_version.restype = ctypes.c_char_p

733

734

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

735

736

openpgp_crt_init = _library.gnutls_openpgp_crt_init

737

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

738

openpgp_crt_init.restype = _error_code

739

740

openpgp_crt_import = _library.gnutls_openpgp_crt_import

741

openpgp_crt_import.argtypes = [openpgp_crt_t,

742

ctypes.POINTER(datum_t),

743

openpgp_crt_fmt_t]

744

openpgp_crt_import.restype = _error_code

745

746

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

747

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

748

ctypes.POINTER(ctypes.c_uint)]

749

openpgp_crt_verify_self.restype = _error_code

750

751

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

752

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

753

openpgp_crt_deinit.restype = None

754

755

openpgp_crt_get_fingerprint = (

756

_library.gnutls_openpgp_crt_get_fingerprint)

757

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

758

ctypes.c_void_p,

759

ctypes.POINTER(

760

ctypes.c_size_t)]

761

openpgp_crt_get_fingerprint.restype = _error_code

762

763

# Remove non-public functions

764

del _error_code, _retry_on_error

765

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

766

gnutls = GnuTLS()

767

768

769

438

def call_pipe(connection, # : multiprocessing.Connection

770

439

func, *args, **kwargs):

771

440

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

772

441

773

442

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

774

443

return value on the provided multiprocessing.Connection.

775

444

"""

776

445

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

777

446

connection.close()

778

447

779

780

448

class Client(object):

781

449

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

782

450

783

451

Attributes:

784

452

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

785

453

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

787

455

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

788

456

to see if the client lives.

789

457

'None' if no process is running.

790

checker_callback_tag: a GLib event source tag, or None

458

checker_callback_tag: a gobject event source tag, or None

791

459

checker_command: string; External command which is run to check

792

460

if client lives. %() expansions are done at

793

461

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

794

462

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

795

checker_initiator_tag: a GLib event source tag, or None

463

checker_initiator_tag: a gobject event source tag, or None

796

464

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

797

465

client_structure: Object describing what attributes a client has

798

466

and is used for storing the client at exit

799

467

current_checker_command: string; current running checker_command

800

disable_initiator_tag: a GLib event source tag, or None

468

disable_initiator_tag: a gobject event source tag, or None

801

469

enabled: bool()

802

470

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

803

471

uniquely identify the client

822

490

disabled, or None

823

491

server_settings: The server_settings dict from main()

824

492

"""

825

493

826

494

runtime_expansions = ("approval_delay", "approval_duration",

827

495

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

828

496

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

839

507

"approved_by_default": "True",

840

508

"enabled": "True",

841

509

}

842

510

843

511

@staticmethod

844

512

def config_parser(config):

845

513

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

852

520

for client_name in config.sections():

853

521

section = dict(config.items(client_name))

854

522

client = settings[client_name] = {}

855

523

856

524

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

857

525

# Reformat values from string types to Python types

858

526

client["approved_by_default"] = config.getboolean(

859

527

client_name, "approved_by_default")

860

528

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

861

529

"enabled")

862

530

863

531

# Uppercase and remove spaces from fingerprint for later

864

532

# comparison purposes with return value from the

865

533

# fingerprint() function

866

534

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

867

535

.replace(" ", ""))

868

536

if "secret" in section:

869

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

870

.encode("utf-8"),

871

"base64")

537

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

872

538

elif "secfile" in section:

873

539

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

874

540

(section["secfile"])),

889

555

client["last_approval_request"] = None

890

556

client["last_checked_ok"] = None

891

557

client["last_checker_status"] = -2

892

558

893

559

return settings

894

895

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

560

561

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

896

562

self.name = name

897

563

if server_settings is None:

898

564

server_settings = {}

900

566

# adding all client settings

901

567

for setting, value in settings.items():

902

568

setattr(self, setting, value)

903

569

904

570

if self.enabled:

905

571

if not hasattr(self, "last_enabled"):

906

572

self.last_enabled = datetime.datetime.utcnow()

910

576

else:

911

577

self.last_enabled = None

912

578

self.expires = None

913

579

914

580

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

915

581

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

916

582

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

917

583

datetime.datetime.utcnow())

918

584

919

585

# attributes specific for this server instance

920

586

self.checker = None

921

587

self.checker_initiator_tag = None

927

593

self.changedstate = multiprocessing_manager.Condition(

928

594

multiprocessing_manager.Lock())

929

595

self.client_structure = [attr

930

for attr in self.__dict__.keys()

596

for attr in self.__dict__.iterkeys()

931

597

if not attr.startswith("_")]

932

598

self.client_structure.append("client_structure")

933

599

934

600

for name, t in inspect.getmembers(

935

601

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

936

602

if not name.startswith("_"):

937

603

self.client_structure.append(name)

938

604

939

605

# Send notice to process children that client state has changed

940

606

def send_changedstate(self):

941

607

with self.changedstate:

942

608

self.changedstate.notify_all()

943

609

944

610

def enable(self):

945

611

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

946

612

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

951

617

self.last_enabled = datetime.datetime.utcnow()

952

618

self.init_checker()

953

619

self.send_changedstate()

954

620

955

621

def disable(self, quiet=True):

956

622

"""Disable this client."""

957

623

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

959

625

if not quiet:

960

626

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

961

627

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

962

GLib.source_remove(self.disable_initiator_tag)

628

gobject.source_remove(self.disable_initiator_tag)

963

629

self.disable_initiator_tag = None

964

630

self.expires = None

965

631

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

966

GLib.source_remove(self.checker_initiator_tag)

632

gobject.source_remove(self.checker_initiator_tag)

967

633

self.checker_initiator_tag = None

968

634

self.stop_checker()

969

635

self.enabled = False

970

636

if not quiet:

971

637

self.send_changedstate()

972

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

638

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

973

639

return False

974

640

975

641

def __del__(self):

976

642

self.disable()

977

643

978

644

def init_checker(self):

979

645

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

980

646

# and every interval from then on.

981

647

if self.checker_initiator_tag is not None:

982

GLib.source_remove(self.checker_initiator_tag)

983

self.checker_initiator_tag = GLib.timeout_add(

648

gobject.source_remove(self.checker_initiator_tag)

649

self.checker_initiator_tag = gobject.timeout_add(

984

650

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

985

651

self.start_checker)

986

652

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

987

653

if self.disable_initiator_tag is not None:

988

GLib.source_remove(self.disable_initiator_tag)

989

self.disable_initiator_tag = GLib.timeout_add(

654

gobject.source_remove(self.disable_initiator_tag)

655

self.disable_initiator_tag = gobject.timeout_add(

990

656

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

991

657

# Also start a new checker *right now*.

992

658

self.start_checker()

993

659

994

660

def checker_callback(self, source, condition, connection,

995

661

command):

996

662

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

999

665

# Read return code from connection (see call_pipe)

1000

666

returncode = connection.recv()

1001

667

connection.close()

1002

668

1003

669

if returncode >= 0:

1004

670

self.last_checker_status = returncode

1005

671

self.last_checker_signal = None

1015

681

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

1016

682

vars(self))

1017

683

return False

1018

684

1019

685

def checked_ok(self):

1020

686

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

1021

687

self.last_checked_ok = datetime.datetime.utcnow()

1022

688

self.last_checker_status = 0

1023

689

self.last_checker_signal = None

1024

690

self.bump_timeout()

1025

691

1026

692

def bump_timeout(self, timeout=None):

1027

693

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

1028

694

if timeout is None:

1029

695

timeout = self.timeout

1030

696

if self.disable_initiator_tag is not None:

1031

GLib.source_remove(self.disable_initiator_tag)

697

gobject.source_remove(self.disable_initiator_tag)

1032

698

self.disable_initiator_tag = None

1033

699

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

1034

self.disable_initiator_tag = GLib.timeout_add(

700

self.disable_initiator_tag = gobject.timeout_add(

1035

701

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

1036

702

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

1037

703

1038

704

def need_approval(self):

1039

705

self.last_approval_request = datetime.datetime.utcnow()

1040

706

1041

707

def start_checker(self):

1042

708

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

1043

709

1044

710

If a checker already exists, leave it running and do

1045

711

nothing."""

1046

712

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

1051

717

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

1052

718

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

1053

719

# should be.

1054

720

1055

721

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

1056

722

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

1057

723

self.checker.join()

1061

727

# Escape attributes for the shell

1062

728

escaped_attrs = {

1063

729

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

1064

for attr in self.runtime_expansions}

730

for attr in self.runtime_expansions }

1065

731

try:

1066

732

command = self.checker_command % escaped_attrs

1067

733

except TypeError as error:

1079

745

# The exception is when not debugging but nevertheless

1080

746

# running in the foreground; use the previously

1081

747

# created wnull.

1082

popen_args = {"close_fds": True,

1083

"shell": True,

1084

"cwd": "/"}

748

popen_args = { "close_fds": True,

749

"shell": True,

750

"cwd": "/" }

1085

751

if (not self.server_settings["debug"]

1086

752

and self.server_settings["foreground"]):

1087

753

popen_args.update({"stdout": wnull,

1088

"stderr": wnull})

1089

pipe = multiprocessing.Pipe(duplex=False)

754

"stderr": wnull })

755

pipe = multiprocessing.Pipe(duplex = False)

1090

756

self.checker = multiprocessing.Process(

1091

target=call_pipe,

1092

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

1093

kwargs=popen_args)

757

target = call_pipe,

758

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

759

kwargs = popen_args)

1094

760

self.checker.start()

1095

self.checker_callback_tag = GLib.io_add_watch(

1096

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

761

self.checker_callback_tag = gobject.io_add_watch(

762

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

1097

763

self.checker_callback, pipe[0], command)

1098

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

764

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

1099

765

return True

1100

766

1101

767

def stop_checker(self):

1102

768

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

1103

769

if self.checker_callback_tag:

1104

GLib.source_remove(self.checker_callback_tag)

770

gobject.source_remove(self.checker_callback_tag)

1105

771

self.checker_callback_tag = None

1106

772

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

1107

773

return

1116

782

byte_arrays=False):

1117

783

"""Decorators for marking methods of a DBusObjectWithProperties to

1118

784

become properties on the D-Bus.

1119

785

1120

786

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

1121

787

and with one argument by "Set".

1122

788

1123

789

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

1124

790

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

1125

791

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

1129

795

if byte_arrays and signature != "ay":

1130

796

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

1131

797

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

1132

798

1133

799

def decorator(func):

1134

800

func._dbus_is_property = True

1135

801

func._dbus_interface = dbus_interface

1138

804

func._dbus_name = func.__name__

1139

805

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

1140

806

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

1141

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

807

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1142

808

return func

1143

809

1144

810

return decorator

1145

811

1146

812

1147

813

def dbus_interface_annotations(dbus_interface):

1148

814

"""Decorator for marking functions returning interface annotations

1149

815

1150

816

Usage:

1151

817

1152

818

@dbus_interface_annotations("org.example.Interface")

1153

819

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

1154

820

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

1155

821

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

1156

822

"false"}

1157

823

"""

1158

824

1159

825

def decorator(func):

1160

826

func._dbus_is_interface = True

1161

827

func._dbus_interface = dbus_interface

1162

828

func._dbus_name = dbus_interface

1163

829

return func

1164

830

1165

831

return decorator

1166

832

1167

833

1168

834

def dbus_annotations(annotations):

1169

835

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

1170

836

Usage:

1171

837

1172

838

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

1173

839

"org.freedesktop.DBus.Property."

1174

840

"EmitsChangedSignal": "false"})

1176

842

access="r")

1177

843

def Property_dbus_property(self):

1178

844

return dbus.Boolean(False)

1179

845

1180

846

See also the DBusObjectWithAnnotations class.

1181

847

"""

1182

848

1183

849

def decorator(func):

1184

850

func._dbus_annotations = annotations

1185

851

return func

1186

852

1187

853

return decorator

1188

854

1189

855

1207

873

1208

874

class DBusObjectWithAnnotations(dbus.service.Object):

1209

875

"""A D-Bus object with annotations.

1210

876

1211

877

Classes inheriting from this can use the dbus_annotations

1212

878

decorator to add annotations to methods or signals.

1213

879

"""

1214

880

1215

881

@staticmethod

1216

882

def _is_dbus_thing(thing):

1217

883

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

1218

884

1219

885

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

1220

886

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

1221

887

"""

1222

888

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

1223

889

False)

1224

890

1225

891

def _get_all_dbus_things(self, thing):

1226

892

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

1227

893

"""

1230

896

for cls in self.__class__.__mro__

1231

897

for name, athing in

1232

898

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

1233

899

1234

900

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1235

out_signature="s",

1236

path_keyword='object_path',

1237

connection_keyword='connection')

901

out_signature = "s",

902

path_keyword = 'object_path',

903

connection_keyword = 'connection')

1238

904

def Introspect(self, object_path, connection):

1239

905

"""Overloading of standard D-Bus method.

1240

906

1241

907

Inserts annotation tags on methods and signals.

1242

908

"""

1243

909

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

1244

910

connection)

1245

911

try:

1246

912

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

1247

913

1248

914

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

1249

915

# Add annotation tags

1250

916

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

1277

943

if_tag.appendChild(ann_tag)

1278

944

# Fix argument name for the Introspect method itself

1279

945

if (if_tag.getAttribute("name")

1280

== dbus.INTROSPECTABLE_IFACE):

946

== dbus.INTROSPECTABLE_IFACE):

1281

947

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

1282

948

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

1283

949

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

1296

962

1297

963

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1298

964

"""A D-Bus object with properties.

1299

965

1300

966

Classes inheriting from this can use the dbus_service_property

1301

967

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

1302

968

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

1303

969

"""

1304

970

1305

971

def _get_dbus_property(self, interface_name, property_name):

1306

972

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

1307

973

property with the specified name and interface.

1312

978

if (value._dbus_name == property_name

1313

979

and value._dbus_interface == interface_name):

1314

980

return value.__get__(self)

1315

981

1316

982

# No such property

1317

983

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

1318

984

self.dbus_object_path, interface_name, property_name))

1319

1320

@classmethod

1321

def _get_all_interface_names(cls):

1322

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

1323

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

1324

"_dbus_interface", None)

1325

for x in (inspect.getmro(cls))

1326

for attr in dir(x))

1327

if name is not None)

1328

985

1329

986

@dbus.service.method(dbus.PROPERTIES_IFACE,

1330

987

in_signature="ss",

1331

988

out_signature="v")

1339

996

if not hasattr(value, "variant_level"):

1340

997

return value

1341

998

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

1342

999

1343

1000

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

1344

1001

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

1345

1002

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

1357

1014

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

1358

1015

for byte in value))

1359

1016

prop(value)

1360

1017

1361

1018

@dbus.service.method(dbus.PROPERTIES_IFACE,

1362

1019

in_signature="s",

1363

1020

out_signature="a{sv}")

1364

1021

def GetAll(self, interface_name):

1365

1022

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

1366

1023

standard.

1367

1024

1368

1025

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

1369

1026

"""

1370

1027

properties = {}

1381

1038

properties[name] = value

1382

1039

continue

1383

1040

properties[name] = type(value)(

1384

value, variant_level=value.variant_level + 1)

1041

value, variant_level = value.variant_level + 1)

1385

1042

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

1386

1043

1387

1044

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

1388

1045

def PropertiesChanged(self, interface_name, changed_properties,

1389

1046

invalidated_properties):

1391

1048

standard.

1392

1049

"""

1393

1050

pass

1394

1051

1395

1052

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1396

1053

out_signature="s",

1397

1054

path_keyword='object_path',

1398

1055

connection_keyword='connection')

1399

1056

def Introspect(self, object_path, connection):

1400

1057

"""Overloading of standard D-Bus method.

1401

1058

1402

1059

Inserts property tags and interface annotation tags.

1403

1060

"""

1404

1061

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1406

1063

connection)

1407

1064

try:

1408

1065

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

1409

1066

1410

1067

def make_tag(document, name, prop):

1411

1068

e = document.createElement("property")

1412

1069

e.setAttribute("name", name)

1413

1070

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

1414

1071

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

1415

1072

return e

1416

1073

1417

1074

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

1418

1075

# Add property tags

1419

1076

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

1462

1119

return xmlstring

1463

1120

1464

1121

1465

try:

1466

dbus.OBJECT_MANAGER_IFACE

1467

except AttributeError:

1468

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

1469

1470

1471

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1472

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

1473

1474

Classes inheriting from this exposes the standard

1475

GetManagedObjects call and the InterfacesAdded and

1476

InterfacesRemoved signals on the standard

1477

"org.freedesktop.DBus.ObjectManager" interface.

1478

1479

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

1480

manually.

1481

"""

1482

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1483

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

1484

def GetManagedObjects(self):

1485

"""This function must be overridden"""

1486

raise NotImplementedError()

1487

1488

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1489

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

1490

def InterfacesAdded(self, object_path, interfaces_and_properties):

1491

pass

1492

1493

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

1494

def InterfacesRemoved(self, object_path, interfaces):

1495

pass

1496

1497

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1498

out_signature="s",

1499

path_keyword='object_path',

1500

connection_keyword='connection')

1501

def Introspect(self, object_path, connection):

1502

"""Overloading of standard D-Bus method.

1503

1504

Override return argument name of GetManagedObjects to be

1505

"objpath_interfaces_and_properties"

1506

"""

1507

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1508

object_path,

1509

connection)

1510

try:

1511

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

1512

1513

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

1514

# Fix argument name for the GetManagedObjects method

1515

if (if_tag.getAttribute("name")

1516

== dbus.OBJECT_MANAGER_IFACE):

1517

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

1518

if (cn.getAttribute("name")

1519

== "GetManagedObjects"):

1520

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

1521

if (arg.getAttribute("direction")

1522

== "out"):

1523

arg.setAttribute(

1524

"name",

1525

"objpath_interfaces"

1526

"_and_properties")

1527

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

1528

document.unlink()

1529

except (AttributeError, xml.dom.DOMException,

1530

xml.parsers.expat.ExpatError) as error:

1531

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

1532

exc_info=error)

1533

return xmlstring

1534

1535

1536

1122

def datetime_to_dbus(dt, variant_level=0):

1537

1123

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

1538

1124

if dt is None:

1539

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

1125

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

1540

1126

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

1541

1127

1542

1128

1545

1131

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

1546

1132

interface names according to the "alt_interface_names" mapping.

1547

1133

Usage:

1548

1134

1549

1135

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

1550

1136

"net.example.AlternateInterface"})

1551

1137

class SampleDBusObject(dbus.service.Object):

1552

1138

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

1553

1139

def SampleDBusMethod():

1554

1140

pass

1555

1141

1556

1142

The above "SampleDBusMethod" on "SampleDBusObject" will be

1557

1143

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

1558

1144

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

1559

1145

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

1560

1146

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

1561

1147

1562

1148

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

1563

1149

(from DBusObjectWithProperties) and interfaces (from the

1564

1150

dbus_interface_annotations decorator).

1565

1151

"""

1566

1152

1567

1153

def wrapper(cls):

1568

1154

for orig_interface_name, alt_interface_name in (

1569

1155

alt_interface_names.items()):

1584

1170

interface_names.add(alt_interface)

1585

1171

# Is this a D-Bus signal?

1586

1172

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

1587

# Extract the original non-method undecorated

1588

# function by black magic

1589

1173

if sys.version_info.major == 2:

1174

# Extract the original non-method undecorated

1175

# function by black magic

1590

1176

nonmethod_func = (dict(

1591

1177

zip(attribute.func_code.co_freevars,

1592

1178

attribute.__closure__))

1593

1179

["func"].cell_contents)

1594

1180

else:

1595

nonmethod_func = (dict(

1596

zip(attribute.__code__.co_freevars,

1597

attribute.__closure__))

1598

["func"].cell_contents)

1181

nonmethod_func = attribute

1599

1182

# Create a new, but exactly alike, function

1600

1183

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

1601

1184

# with the alternate D-Bus interface name

1602

new_function = copy_function(nonmethod_func)

1185

if sys.version_info.major == 2:

1186

new_function = types.FunctionType(

1187

nonmethod_func.func_code,

1188

nonmethod_func.func_globals,

1189

nonmethod_func.func_name,

1190

nonmethod_func.func_defaults,

1191

nonmethod_func.func_closure)

1192

else:

1193

new_function = types.FunctionType(

1194

nonmethod_func.__code__,

1195

nonmethod_func.__globals__,

1196

nonmethod_func.__name__,

1197

nonmethod_func.__defaults__,

1198

nonmethod_func.__closure__)

1603

1199

new_function = (dbus.service.signal(

1604

1200

alt_interface,

1605

1201

attribute._dbus_signature)(new_function))

1609

1205

attribute._dbus_annotations)

1610

1206

except AttributeError:

1611

1207

pass

1612

1613

1208

# Define a creator of a function to call both the

1614

1209

# original and alternate functions, so both the

1615

1210

# original and alternate signals gets sent when

1618

1213

"""This function is a scope container to pass

1619

1214

func1 and func2 to the "call_both" function

1620

1215

outside of its arguments"""

1621

1622

@functools.wraps(func2)

1216

1623

1217

def call_both(*args, **kwargs):

1624

1218

"""This function will emit two D-Bus

1625

1219

signals by calling func1 and func2"""

1626

1220

func1(*args, **kwargs)

1627

1221

func2(*args, **kwargs)

1628

# Make wrapper function look like a D-Bus

1629

# signal

1630

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

1631

if name.startswith("_dbus_"):

1632

setattr(call_both, name, attr)

1633

1222

1634

1223

return call_both

1635

1224

# Create the "call_both" function and add it to

1636

1225

# the class

1646

1235

alt_interface,

1647

1236

attribute._dbus_in_signature,

1648

1237

attribute._dbus_out_signature)

1649

(copy_function(attribute)))

1238

(types.FunctionType(attribute.func_code,

1239

attribute.func_globals,

1240

attribute.func_name,

1241

attribute.func_defaults,

1242

attribute.func_closure)))

1650

1243

# Copy annotations, if any

1651

1244

try:

1652

1245

attr[attrname]._dbus_annotations = dict(

1664

1257

attribute._dbus_access,

1665

1258

attribute._dbus_get_args_options

1666

1259

["byte_arrays"])

1667

(copy_function(attribute)))

1260

(types.FunctionType(

1261

attribute.func_code,

1262

attribute.func_globals,

1263

attribute.func_name,

1264

attribute.func_defaults,

1265

attribute.func_closure)))

1668

1266

# Copy annotations, if any

1669

1267

try:

1670

1268

attr[attrname]._dbus_annotations = dict(

1679

1277

# to the class.

1680

1278

attr[attrname] = (

1681

1279

dbus_interface_annotations(alt_interface)

1682

(copy_function(attribute)))

1280

(types.FunctionType(attribute.func_code,

1281

attribute.func_globals,

1282

attribute.func_name,

1283

attribute.func_defaults,

1284

attribute.func_closure)))

1683

1285

if deprecate:

1684

1286

# Deprecate all alternate interfaces

1685

iname = "_AlternateDBusNames_interface_annotation{}"

1287

iname="_AlternateDBusNames_interface_annotation{}"

1686

1288

for interface_name in interface_names:

1687

1289

1688

1290

@dbus_interface_annotations(interface_name)

1689

1291

def func(self):

1690

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

1691

"true"}

1292

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

1293

"true" }

1692

1294

# Find an unused name

1693

1295

for aname in (iname.format(i)

1694

1296

for i in itertools.count()):

1698

1300

if interface_names:

1699

1301

# Replace the class with a new subclass of it with

1700

1302

# methods, signals, etc. as created above.

1701

if sys.version_info.major == 2:

1702

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

1703

(cls, ), attr)

1704

else:

1705

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

1706

(cls, ), attr)

1303

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

1304

(cls, ), attr)

1707

1305

return cls

1708

1306

1709

1307

return wrapper

1710

1308

1711

1309

1713

1311

"se.bsnet.fukt.Mandos"})

1714

1312

class ClientDBus(Client, DBusObjectWithProperties):

1715

1313

"""A Client class using D-Bus

1716

1314

1717

1315

Attributes:

1718

1316

dbus_object_path: dbus.ObjectPath

1719

1317

bus: dbus.SystemBus()

1720

1318

"""

1721

1319

1722

1320

runtime_expansions = (Client.runtime_expansions

1723

1321

+ ("dbus_object_path", ))

1724

1322

1725

1323

_interface = "se.recompile.Mandos.Client"

1726

1324

1727

1325

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

1728

1729

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

1326

1327

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

1730

1328

self.bus = bus

1731

1329

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

1732

1330

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

1738

1336

"/clients/" + client_object_name)

1739

1337

DBusObjectWithProperties.__init__(self, self.bus,

1740

1338

self.dbus_object_path)

1741

1339

1742

1340

def notifychangeproperty(transform_func, dbus_name,

1743

1341

type_func=lambda x: x,

1744

1342

variant_level=1,

1746

1344

_interface=_interface):

1747

1345

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

1748

1346

its changes to DBus.

1749

1347

1750

1348

transform_fun: Function that takes a value and a variant_level

1751

1349

and transforms it to a D-Bus type.

1752

1350

dbus_name: D-Bus name of the variable

1755

1353

variant_level: D-Bus variant level. Default: 1

1756

1354

"""

1757

1355

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

1758

1356

1759

1357

def setter(self, value):

1760

1358

if hasattr(self, "dbus_object_path"):

1761

1359

if (not hasattr(self, attrname) or

1768

1366

else:

1769

1367

dbus_value = transform_func(

1770

1368

type_func(value),

1771

variant_level=variant_level)

1369

variant_level = variant_level)

1772

1370

self.PropertyChanged(dbus.String(dbus_name),

1773

1371

dbus_value)

1774

1372

self.PropertiesChanged(

1775

1373

_interface,

1776

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

1777

dbus_value}),

1374

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

1375

dbus_value }),

1778

1376

dbus.Array())

1779

1377

setattr(self, attrname, value)

1780

1378

1781

1379

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

1782

1380

1783

1381

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1784

1382

approvals_pending = notifychangeproperty(dbus.Boolean,

1785

1383

"ApprovalPending",

1786

type_func=bool)

1384

type_func = bool)

1787

1385

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

1788

1386

last_enabled = notifychangeproperty(datetime_to_dbus,

1789

1387

"LastEnabled")

1790

1388

checker = notifychangeproperty(

1791

1389

dbus.Boolean, "CheckerRunning",

1792

type_func=lambda checker: checker is not None)

1390

type_func = lambda checker: checker is not None)

1793

1391

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1794

1392

"LastCheckedOK")

1795

1393

last_checker_status = notifychangeproperty(dbus.Int16,

1800

1398

"ApprovedByDefault")

1801

1399

approval_delay = notifychangeproperty(

1802

1400

dbus.UInt64, "ApprovalDelay",

1803

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

1401

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

1804

1402

approval_duration = notifychangeproperty(

1805

1403

dbus.UInt64, "ApprovalDuration",

1806

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

1404

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

1807

1405

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

1808

1406

timeout = notifychangeproperty(

1809

1407

dbus.UInt64, "Timeout",

1810

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

1408

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

1811

1409

extended_timeout = notifychangeproperty(

1812

1410

dbus.UInt64, "ExtendedTimeout",

1813

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

1411

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

1814

1412

interval = notifychangeproperty(

1815

1413

dbus.UInt64, "Interval",

1816

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

1414

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

1817

1415

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

1818

1416

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

1819

1417

invalidate_only=True)

1820

1418

1821

1419

del notifychangeproperty

1822

1420

1823

1421

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

1824

1422

try:

1825

1423

self.remove_from_connection()

1828

1426

if hasattr(DBusObjectWithProperties, "__del__"):

1829

1427

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

1830

1428

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

1831

1429

1832

1430

def checker_callback(self, source, condition,

1833

1431

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

1834

1432

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

1850

1448

| self.last_checker_signal),

1851

1449

dbus.String(command))

1852

1450

return ret

1853

1451

1854

1452

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

1855

1453

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

1856

1454

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

1860

1458

# Emit D-Bus signal

1861

1459

self.CheckerStarted(self.current_checker_command)

1862

1460

return r

1863

1461

1864

1462

def _reset_approved(self):

1865

1463

self.approved = None

1866

1464

return False

1867

1465

1868

1466

def approve(self, value=True):

1869

1467

self.approved = value

1870

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

1871

* 1000), self._reset_approved)

1468

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

1469

* 1000), self._reset_approved)

1872

1470

self.send_changedstate()

1873

1874

# D-Bus methods, signals & properties

1875

1876

# Interfaces

1877

1878

# Signals

1879

1471

1472

## D-Bus methods, signals & properties

1473

1474

## Interfaces

1475

1476

## Signals

1477

1880

1478

# CheckerCompleted - signal

1881

1479

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

1882

1480

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

1883

1481

"D-Bus signal"

1884

1482

pass

1885

1483

1886

1484

# CheckerStarted - signal

1887

1485

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

1888

1486

def CheckerStarted(self, command):

1889

1487

"D-Bus signal"

1890

1488

pass

1891

1489

1892

1490

# PropertyChanged - signal

1893

1491

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

1894

1492

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

1895

1493

def PropertyChanged(self, property, value):

1896

1494

"D-Bus signal"

1897

1495

pass

1898

1496

1899

1497

# GotSecret - signal

1900

1498

@dbus.service.signal(_interface)

1901

1499

def GotSecret(self):

1904

1502

server to mandos-client

1905

1503

"""

1906

1504

pass

1907

1505

1908

1506

# Rejected - signal

1909

1507

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

1910

1508

def Rejected(self, reason):

1911

1509

"D-Bus signal"

1912

1510

pass

1913

1511

1914

1512

# NeedApproval - signal

1915

1513

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

1916

1514

def NeedApproval(self, timeout, default):

1917

1515

"D-Bus signal"

1918

1516

return self.need_approval()

1919

1920

# Methods

1921

1517

1518

## Methods

1519

1922

1520

# Approve - method

1923

1521

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

1924

1522

def Approve(self, value):

1925

1523

self.approve(value)

1926

1524

1927

1525

# CheckedOK - method

1928

1526

@dbus.service.method(_interface)

1929

1527

def CheckedOK(self):

1930

1528

self.checked_ok()

1931

1529

1932

1530

# Enable - method

1933

1531

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

1934

1532

@dbus.service.method(_interface)

1935

1533

def Enable(self):

1936

1534

"D-Bus method"

1937

1535

self.enable()

1938

1536

1939

1537

# StartChecker - method

1940

1538

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

1941

1539

@dbus.service.method(_interface)

1942

1540

def StartChecker(self):

1943

1541

"D-Bus method"

1944

1542

self.start_checker()

1945

1543

1946

1544

# Disable - method

1947

1545

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

1948

1546

@dbus.service.method(_interface)

1949

1547

def Disable(self):

1950

1548

"D-Bus method"

1951

1549

self.disable()

1952

1550

1953

1551

# StopChecker - method

1954

1552

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

1955

1553

@dbus.service.method(_interface)

1956

1554

def StopChecker(self):

1957

1555

self.stop_checker()

1958

1959

# Properties

1960

1556

1557

## Properties

1558

1961

1559

# ApprovalPending - property

1962

1560

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

1963

1561

def ApprovalPending_dbus_property(self):

1964

1562

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

1965

1563

1966

1564

# ApprovedByDefault - property

1967

1565

@dbus_service_property(_interface,

1968

1566

signature="b",

1971

1569

if value is None: # get

1972

1570

return dbus.Boolean(self.approved_by_default)

1973

1571

self.approved_by_default = bool(value)

1974

1572

1975

1573

# ApprovalDelay - property

1976

1574

@dbus_service_property(_interface,

1977

1575

signature="t",

1981

1579

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

1982

1580

* 1000)

1983

1581

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

1984

1582

1985

1583

# ApprovalDuration - property

1986

1584

@dbus_service_property(_interface,

1987

1585

signature="t",

1991

1589

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

1992

1590

* 1000)

1993

1591

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

1994

1592

1995

1593

# Name - property

1996

1594

@dbus_annotations(

1997

1595

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

1998

1596

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

1999

1597

def Name_dbus_property(self):

2000

1598

return dbus.String(self.name)

2001

1599

2002

1600

# Fingerprint - property

2003

1601

@dbus_annotations(

2004

1602

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

2005

1603

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

2006

1604

def Fingerprint_dbus_property(self):

2007

1605

return dbus.String(self.fingerprint)

2008

1606

2009

1607

# Host - property

2010

1608

@dbus_service_property(_interface,

2011

1609

signature="s",

2014

1612

if value is None: # get

2015

1613

return dbus.String(self.host)

2016

1614

self.host = str(value)

2017

1615

2018

1616

# Created - property

2019

1617

@dbus_annotations(

2020

1618

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

2021

1619

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

2022

1620

def Created_dbus_property(self):

2023

1621

return datetime_to_dbus(self.created)

2024

1622

2025

1623

# LastEnabled - property

2026

1624

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

2027

1625

def LastEnabled_dbus_property(self):

2028

1626

return datetime_to_dbus(self.last_enabled)

2029

1627

2030

1628

# Enabled - property

2031

1629

@dbus_service_property(_interface,

2032

1630

signature="b",

2038

1636

self.enable()

2039

1637

else:

2040

1638

self.disable()

2041

1639

2042

1640

# LastCheckedOK - property

2043

1641

@dbus_service_property(_interface,

2044

1642

signature="s",

2048

1646

self.checked_ok()

2049

1647

return

2050

1648

return datetime_to_dbus(self.last_checked_ok)

2051

1649

2052

1650

# LastCheckerStatus - property

2053

1651

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

2054

1652

def LastCheckerStatus_dbus_property(self):

2055

1653

return dbus.Int16(self.last_checker_status)

2056

1654

2057

1655

# Expires - property

2058

1656

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

2059

1657

def Expires_dbus_property(self):

2060

1658

return datetime_to_dbus(self.expires)

2061

1659

2062

1660

# LastApprovalRequest - property

2063

1661

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

2064

1662

def LastApprovalRequest_dbus_property(self):

2065

1663

return datetime_to_dbus(self.last_approval_request)

2066

1664

2067

1665

# Timeout - property

2068

1666

@dbus_service_property(_interface,

2069

1667

signature="t",

2084

1682

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

2085

1683

is None):

2086

1684

return

2087

GLib.source_remove(self.disable_initiator_tag)

2088

self.disable_initiator_tag = GLib.timeout_add(

1685

gobject.source_remove(self.disable_initiator_tag)

1686

self.disable_initiator_tag = gobject.timeout_add(

2089

1687

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

2090

1688

self.disable)

2091

1689

2092

1690

# ExtendedTimeout - property

2093

1691

@dbus_service_property(_interface,

2094

1692

signature="t",

2098

1696

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

2099

1697

* 1000)

2100

1698

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

2101

1699

2102

1700

# Interval - property

2103

1701

@dbus_service_property(_interface,

2104

1702

signature="t",

2111

1709

return

2112

1710

if self.enabled:

2113

1711

# Reschedule checker run

2114

GLib.source_remove(self.checker_initiator_tag)

2115

self.checker_initiator_tag = GLib.timeout_add(

1712

gobject.source_remove(self.checker_initiator_tag)

1713

self.checker_initiator_tag = gobject.timeout_add(

2116

1714

value, self.start_checker)

2117

self.start_checker() # Start one now, too

2118

1715

self.start_checker() # Start one now, too

1716

2119

1717

# Checker - property

2120

1718

@dbus_service_property(_interface,

2121

1719

signature="s",

2124

1722

if value is None: # get

2125

1723

return dbus.String(self.checker_command)

2126

1724

self.checker_command = str(value)

2127

1725

2128

1726

# CheckerRunning - property

2129

1727

@dbus_service_property(_interface,

2130

1728

signature="b",

2136

1734

self.start_checker()

2137

1735

else:

2138

1736

self.stop_checker()

2139

1737

2140

1738

# ObjectPath - property

2141

1739

@dbus_annotations(

2142

1740

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

2143

1741

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

2144

1742

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

2145

1743

def ObjectPath_dbus_property(self):

2146

return self.dbus_object_path # is already a dbus.ObjectPath

2147

1744

return self.dbus_object_path # is already a dbus.ObjectPath

1745

2148

1746

# Secret = property

2149

1747

@dbus_annotations(

2150

1748

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

2155

1753

byte_arrays=True)

2156

1754

def Secret_dbus_property(self, value):

2157

1755

self.secret = bytes(value)

2158

1756

2159

1757

del _interface

2160

1758

2161

1759

2165

1763

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

2166

1764

if not self._pipe.recv():

2167

1765

raise KeyError(fpr)

2168

1766

2169

1767

def __getattribute__(self, name):

2170

1768

if name == '_pipe':

2171

1769

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

2174

1772

if data[0] == 'data':

2175

1773

return data[1]

2176

1774

if data[0] == 'function':

2177

1775

2178

1776

def func(*args, **kwargs):

2179

1777

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

2180

1778

return self._pipe.recv()[1]

2181

1779

2182

1780

return func

2183

1781

2184

1782

def __setattr__(self, name, value):

2185

1783

if name == '_pipe':

2186

1784

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

2189

1787

2190

1788

class ClientHandler(socketserver.BaseRequestHandler, object):

2191

1789

"""A class to handle client connections.

2192

1790

2193

1791

Instantiated once for each connection to handle it.

2194

1792

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

2195

1793

2196

1794

def handle(self):

2197

1795

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

2198

1796

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

2199

1797

str(self.client_address))

2200

1798

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

2201

1799

self.server.child_pipe.fileno())

2202

2203

session = gnutls.ClientSession(self.request)

2204

2205

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

2206

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

2207

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

2208

# "+DHE-DSS"))

1800

1801

session = gnutls.connection.ClientSession(

1802

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

1803

1804

# Note: gnutls.connection.X509Credentials is really a

1805

# generic GnuTLS certificate credentials object so long as

1806

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

1807

# here despite using OpenPGP certificates.

1808

1809

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

1810

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

1811

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

1812

# "+DHE-DSS"))

2209

1813

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

2210

1814

priority = self.server.gnutls_priority

2211

1815

if priority is None:

2212

1816

priority = "NORMAL"

2213

gnutls.priority_set_direct(session._c_object,

2214

priority.encode("utf-8"),

2215

None)

2216

1817

gnutls.library.functions.gnutls_priority_set_direct(

1818

session._c_object, priority, None)

1819

2217

1820

# Start communication using the Mandos protocol

2218

1821

# Get protocol number

2219

1822

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

2224

1827

except (ValueError, IndexError, RuntimeError) as error:

2225

1828

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

2226

1829

return

2227

1830

2228

1831

# Start GnuTLS connection

2229

1832

try:

2230

1833

session.handshake()

2231

except gnutls.Error as error:

1834

except gnutls.errors.GNUTLSError as error:

2232

1835

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

2233

1836

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

2234

1837

# established. Just abandon the request.

2235

1838

return

2236

1839

logger.debug("Handshake succeeded")

2237

1840

2238

1841

approval_required = False

2239

1842

try:

2240

1843

try:

2241

1844

fpr = self.fingerprint(

2242

1845

self.peer_certificate(session))

2243

except (TypeError, gnutls.Error) as error:

1846

except (TypeError,

1847

gnutls.errors.GNUTLSError) as error:

2244

1848

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

2245

1849

return

2246

1850

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

2247

1851

2248

1852

try:

2249

1853

client = ProxyClient(child_pipe, fpr,

2250

1854

self.client_address)

2251

1855

except KeyError:

2252

1856

return

2253

1857

2254

1858

if client.approval_delay:

2255

1859

delay = client.approval_delay

2256

1860

client.approvals_pending += 1

2257

1861

approval_required = True

2258

1862

2259

1863

while True:

2260

1864

if not client.enabled:

2261

1865

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

2264

1868

# Emit D-Bus signal

2265

1869

client.Rejected("Disabled")

2266

1870

return

2267

1871

2268

1872

if client.approved or not client.approval_delay:

2269

# We are approved or approval is disabled

1873

#We are approved or approval is disabled

2270

1874

break

2271

1875

elif client.approved is None:

2272

1876

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

2283

1887

# Emit D-Bus signal

2284

1888

client.Rejected("Denied")

2285

1889

return

2286

2287

# wait until timeout or approved

1890

1891

#wait until timeout or approved

2288

1892

time = datetime.datetime.now()

2289

1893

client.changedstate.acquire()

2290

1894

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

2303

1907

break

2304

1908

else:

2305

1909

delay -= time2 - time

2306

2307

try:

2308

session.send(client.secret)

2309

except gnutls.Error as error:

2310

logger.warning("gnutls send failed",

2311

exc_info=error)

2312

return

2313

1910

1911

sent_size = 0

1912

while sent_size < len(client.secret):

1913

try:

1914

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

1915

except gnutls.errors.GNUTLSError as error:

1916

logger.warning("gnutls send failed",

1917

exc_info=error)

1918

return

1919

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

1920

len(client.secret) - (sent_size

1921

+ sent))

1922

sent_size += sent

1923

2314

1924

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

2315

1925

# bump the timeout using extended_timeout

2316

1926

client.bump_timeout(client.extended_timeout)

2317

1927

if self.server.use_dbus:

2318

1928

# Emit D-Bus signal

2319

1929

client.GotSecret()

2320

1930

2321

1931

finally:

2322

1932

if approval_required:

2323

1933

client.approvals_pending -= 1

2324

1934

try:

2325

1935

session.bye()

2326

except gnutls.Error as error:

1936

except gnutls.errors.GNUTLSError as error:

2327

1937

logger.warning("GnuTLS bye failed",

2328

1938

exc_info=error)

2329

1939

2330

1940

@staticmethod

2331

1941

def peer_certificate(session):

2332

1942

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

2333

1943

# If not an OpenPGP certificate...

2334

if (gnutls.certificate_type_get(session._c_object)

2335

!= gnutls.CRT_OPENPGP):

2336

# ...return invalid data

2337

return b""

1944

if (gnutls.library.functions.gnutls_certificate_type_get(

1945

session._c_object)

1946

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

1947

# ...do the normal thing

1948

return session.peer_certificate

2338

1949

list_size = ctypes.c_uint(1)

2339

cert_list = (gnutls.certificate_get_peers

1950

cert_list = (gnutls.library.functions

1951

.gnutls_certificate_get_peers

2340

1952

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

2341

1953

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

2342

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

1954

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

1955

" certificate")

2343

1956

if list_size.value == 0:

2344

1957

return None

2345

1958

cert = cert_list[0]

2346

1959

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

2347

1960

2348

1961

@staticmethod

2349

1962

def fingerprint(openpgp):

2350

1963

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2351

1964

# New GnuTLS "datum" with the OpenPGP public key

2352

datum = gnutls.datum_t(

1965

datum = gnutls.library.types.gnutls_datum_t(

2353

1966

ctypes.cast(ctypes.c_char_p(openpgp),

2354

1967

ctypes.POINTER(ctypes.c_ubyte)),

2355

1968

ctypes.c_uint(len(openpgp)))

2356

1969

# New empty GnuTLS certificate

2357

crt = gnutls.openpgp_crt_t()

2358

gnutls.openpgp_crt_init(ctypes.byref(crt))

1970

crt = gnutls.library.types.gnutls_openpgp_crt_t()

1971

gnutls.library.functions.gnutls_openpgp_crt_init(

1972

ctypes.byref(crt))

2359

1973

# Import the OpenPGP public key into the certificate

2360

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

2361

gnutls.OPENPGP_FMT_RAW)

1974

gnutls.library.functions.gnutls_openpgp_crt_import(

1975

crt, ctypes.byref(datum),

1976

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

2362

1977

# Verify the self signature in the key

2363

1978

crtverify = ctypes.c_uint()

2364

gnutls.openpgp_crt_verify_self(crt, 0,

2365

ctypes.byref(crtverify))

1979

gnutls.library.functions.gnutls_openpgp_crt_verify_self(

1980

crt, 0, ctypes.byref(crtverify))

2366

1981

if crtverify.value != 0:

2367

gnutls.openpgp_crt_deinit(crt)

2368

raise gnutls.CertificateSecurityError(code

2369

=crtverify.value)

1982

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

1983

raise gnutls.errors.CertificateSecurityError(

1984

"Verify failed")

2370

1985

# New buffer for the fingerprint

2371

1986

buf = ctypes.create_string_buffer(20)

2372

1987

buf_len = ctypes.c_size_t()

2373

1988

# Get the fingerprint from the certificate into the buffer

2374

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

2375

ctypes.byref(buf_len))

1989

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(

1990

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

2376

1991

# Deinit the certificate

2377

gnutls.openpgp_crt_deinit(crt)

1992

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2378

1993

# Convert the buffer to a Python bytestring

2379

1994

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

2380

1995

# Convert the bytestring to hexadecimal notation

2384

1999

2385

2000

class MultiprocessingMixIn(object):

2386

2001

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

2387

2002

2388

2003

def sub_process_main(self, request, address):

2389

2004

try:

2390

2005

self.finish_request(request, address)

2391

2006

except Exception:

2392

2007

self.handle_error(request, address)

2393

2008

self.close_request(request)

2394

2009

2395

2010

def process_request(self, request, address):

2396

2011

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

2397

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

2398

args=(request, address))

2012

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

2013

args = (request, address))

2399

2014

proc.start()

2400

2015

return proc

2401

2016

2402

2017

2403

2018

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2404

2019

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

2405

2020

2406

2021

def process_request(self, request, client_address):

2407

2022

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

2408

2023

2409

2024

This function creates a new pipe in self.pipe

2410

2025

"""

2411

2026

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2412

2027

2413

2028

proc = MultiprocessingMixIn.process_request(self, request,

2414

2029

client_address)

2415

2030

self.child_pipe.close()

2416

2031

self.add_pipe(parent_pipe, proc)

2417

2032

2418

2033

def add_pipe(self, parent_pipe, proc):

2419

2034

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

2420

2035

raise NotImplementedError()

2423

2038

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2424

2039

socketserver.TCPServer, object):

2425

2040

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

2426

2041

2427

2042

Attributes:

2428

2043

enabled: Boolean; whether this server is activated yet

2429

2044

interface: None or a network interface name (string)

2430

2045

use_ipv6: Boolean; to use IPv6 or not

2431

2046

"""

2432

2047

2433

2048

def __init__(self, server_address, RequestHandlerClass,

2434

2049

interface=None,

2435

2050

use_ipv6=True,

2445

2060

self.socketfd = socketfd

2446

2061

# Save the original socket.socket() function

2447

2062

self.socket_socket = socket.socket

2448

2449

2063

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

2450

#

2064

#

2451

2065

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

2452

2066

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

2453

2067

# patching socket.socket.)

2454

#

2068

#

2455

2069

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

2456

2070

@functools.wraps(socket.socket)

2457

2071

def socket_wrapper(*args, **kwargs):

2469

2083

# socket_wrapper(), if socketfd was set.

2470

2084

socketserver.TCPServer.__init__(self, server_address,

2471

2085

RequestHandlerClass)

2472

2086

2473

2087

def server_bind(self):

2474

2088

"""This overrides the normal server_bind() function

2475

2089

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

2476

2090

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

2477

global SO_BINDTODEVICE

2478

2091

if self.interface is not None:

2479

2092

if SO_BINDTODEVICE is None:

2480

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

2481

# common enough.

2482

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

2483

SO_BINDTODEVICE = 25

2484

try:

2485

self.socket.setsockopt(

2486

socket.SOL_SOCKET, SO_BINDTODEVICE,

2487

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

2488

except socket.error as error:

2489

if error.errno == errno.EPERM:

2490

logger.error("No permission to bind to"

2491

" interface %s", self.interface)

2492

elif error.errno == errno.ENOPROTOOPT:

2493

logger.error("SO_BINDTODEVICE not available;"

2494

" cannot bind to interface %s",

2495

self.interface)

2496

elif error.errno == errno.ENODEV:

2497

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

2498

" cannot bind", self.interface)

2499

else:

2500

raise

2093

logger.error("SO_BINDTODEVICE does not exist;"

2094

" cannot bind to interface %s",

2095

self.interface)

2096

else:

2097

try:

2098

self.socket.setsockopt(

2099

socket.SOL_SOCKET, SO_BINDTODEVICE,

2100

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

2101

except socket.error as error:

2102

if error.errno == errno.EPERM:

2103

logger.error("No permission to bind to"

2104

" interface %s", self.interface)

2105

elif error.errno == errno.ENOPROTOOPT:

2106

logger.error("SO_BINDTODEVICE not available;"

2107

" cannot bind to interface %s",

2108

self.interface)

2109

elif error.errno == errno.ENODEV:

2110

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

2111

" cannot bind", self.interface)

2112

else:

2113

raise

2501

2114

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

2502

2115

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

2503

2116

if not self.server_address[0]:

2504

2117

if self.address_family == socket.AF_INET6:

2505

any_address = "::" # in6addr_any

2118

any_address = "::" # in6addr_any

2506

2119

else:

2507

any_address = "0.0.0.0" # INADDR_ANY

2120

any_address = "0.0.0.0" # INADDR_ANY

2508

2121

self.server_address = (any_address,

2509

2122

self.server_address[1])

2510

2123

elif not self.server_address[1]:

2520

2133

2521

2134

class MandosServer(IPv6_TCPServer):

2522

2135

"""Mandos server.

2523

2136

2524

2137

Attributes:

2525

2138

clients: set of Client objects

2526

2139

gnutls_priority GnuTLS priority string

2527

2140

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

2528

2529

Assumes a GLib.MainLoop event loop.

2141

2142

Assumes a gobject.MainLoop event loop.

2530

2143

"""

2531

2144

2532

2145

def __init__(self, server_address, RequestHandlerClass,

2533

2146

interface=None,

2534

2147

use_ipv6=True,

2544

2157

self.gnutls_priority = gnutls_priority

2545

2158

IPv6_TCPServer.__init__(self, server_address,

2546

2159

RequestHandlerClass,

2547

interface=interface,

2548

use_ipv6=use_ipv6,

2549

socketfd=socketfd)

2550

2160

interface = interface,

2161

use_ipv6 = use_ipv6,

2162

socketfd = socketfd)

2163

2551

2164

def server_activate(self):

2552

2165

if self.enabled:

2553

2166

return socketserver.TCPServer.server_activate(self)

2554

2167

2555

2168

def enable(self):

2556

2169

self.enabled = True

2557

2170

2558

2171

def add_pipe(self, parent_pipe, proc):

2559

2172

# Call "handle_ipc" for both data and EOF events

2560

GLib.io_add_watch(

2173

gobject.io_add_watch(

2561

2174

parent_pipe.fileno(),

2562

GLib.IO_IN | GLib.IO_HUP,

2175

gobject.IO_IN | gobject.IO_HUP,

2563

2176

functools.partial(self.handle_ipc,

2564

parent_pipe=parent_pipe,

2565

proc=proc))

2566

2177

parent_pipe = parent_pipe,

2178

proc = proc))

2179

2567

2180

def handle_ipc(self, source, condition,

2568

2181

parent_pipe=None,

2569

proc=None,

2182

proc = None,

2570

2183

client_object=None):

2571

2184

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

2572

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

2185

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

2573

2186

# Wait for other process to exit

2574

2187

proc.join()

2575

2188

return False

2576

2189

2577

2190

# Read a request from the child

2578

2191

request = parent_pipe.recv()

2579

2192

command = request[0]

2580

2193

2581

2194

if command == 'init':

2582

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

2195

fpr = request[1]

2583

2196

address = request[2]

2584

2585

for c in self.clients.values():

2197

2198

for c in self.clients.itervalues():

2586

2199

if c.fingerprint == fpr:

2587

2200

client = c

2588

2201

break

2595

2208

address[0])

2596

2209

parent_pipe.send(False)

2597

2210

return False

2598

2599

GLib.io_add_watch(

2211

2212

gobject.io_add_watch(

2600

2213

parent_pipe.fileno(),

2601

GLib.IO_IN | GLib.IO_HUP,

2214

gobject.IO_IN | gobject.IO_HUP,

2602

2215

functools.partial(self.handle_ipc,

2603

parent_pipe=parent_pipe,

2604

proc=proc,

2605

client_object=client))

2216

parent_pipe = parent_pipe,

2217

proc = proc,

2218

client_object = client))

2606

2219

parent_pipe.send(True)

2607

2220

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

2608

2221

# same fileno

2611

2224

funcname = request[1]

2612

2225

args = request[2]

2613

2226

kwargs = request[3]

2614

2227

2615

2228

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

2616

2229

funcname)(*args,

2617

2230

**kwargs)))

2618

2231

2619

2232

if command == 'getattr':

2620

2233

attrname = request[1]

2621

2234

if isinstance(client_object.__getattribute__(attrname),

2624

2237

else:

2625

2238

parent_pipe.send((

2626

2239

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

2627

2240

2628

2241

if command == 'setattr':

2629

2242

attrname = request[1]

2630

2243

value = request[2]

2631

2244

setattr(client_object, attrname, value)

2632

2245

2633

2246

return True

2634

2247

2635

2248

2636

2249

def rfc3339_duration_to_delta(duration):

2637

2250

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

2638

2251

2639

2252

>>> rfc3339_duration_to_delta("P7D")

2640

2253

datetime.timedelta(7)

2641

2254

>>> rfc3339_duration_to_delta("PT60S")

2651

2264

>>> rfc3339_duration_to_delta("P1DT3M20S")

2652

2265

datetime.timedelta(1, 200)

2653

2266

"""

2654

2267

2655

2268

# Parsing an RFC 3339 duration with regular expressions is not

2656

2269

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

2657

2270

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

2658

2271

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

2659

2272

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

2660

2273

# avoid excessive use of external libraries.

2661

2274

2662

2275

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

2663

2276

Token = collections.namedtuple("Token", (

2664

2277

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

2697

2310

frozenset((token_year, token_month,

2698

2311

token_day, token_time,

2699

2312

token_week)))

2700

# Define starting values:

2701

# Value so far

2702

value = datetime.timedelta()

2313

# Define starting values

2314

value = datetime.timedelta() # Value so far

2703

2315

found_token = None

2704

# Following valid tokens

2705

followers = frozenset((token_duration, ))

2706

# String left to parse

2707

s = duration

2316

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

2317

s = duration # String left to parse

2708

2318

# Loop until end token is found

2709

2319

while found_token is not token_end:

2710

2320

# Search for any currently valid tokens

2734

2344

2735

2345

def string_to_delta(interval):

2736

2346

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

2737

2347

2738

2348

>>> string_to_delta('7d')

2739

2349

datetime.timedelta(7)

2740

2350

>>> string_to_delta('60s')

2748

2358

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

2749

2359

datetime.timedelta(0, 330)

2750

2360

"""

2751

2361

2752

2362

try:

2753

2363

return rfc3339_duration_to_delta(interval)

2754

2364

except ValueError:

2755

2365

pass

2756

2366

2757

2367

timevalue = datetime.timedelta(0)

2758

2368

for s in interval.split():

2759

2369

try:

2777

2387

return timevalue

2778

2388

2779

2389

2780

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

2390

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

2781

2391

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

2782

2392

2783

2393

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

2784

2394

if os.fork():

2785

2395

sys.exit()

2803

2413

2804

2414

2805

2415

def main():

2806

2416

2807

2417

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

2808

2418

# Parsing of options, both command line and config file

2809

2419

2810

2420

parser = argparse.ArgumentParser()

2811

2421

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

2812

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

2422

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

2813

2423

help="show version number and exit")

2814

2424

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

2815

2425

help="Bind to interface IF")

2851

2461

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

2852

2462

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

2853

2463

default=None)

2854

2464

2855

2465

options = parser.parse_args()

2856

2466

2857

2467

if options.check:

2858

2468

import doctest

2859

2469

fail_count, test_count = doctest.testmod()

2860

2470

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

2861

2471

2862

2472

# Default values for config file for server-global settings

2863

server_defaults = {"interface": "",

2864

"address": "",

2865

"port": "",

2866

"debug": "False",

2867

"priority":

2868

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

2869

":+SIGN-DSA-SHA256",

2870

"servicename": "Mandos",

2871

"use_dbus": "True",

2872

"use_ipv6": "True",

2873

"debuglevel": "",

2874

"restore": "True",

2875

"socket": "",

2876

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

2877

"foreground": "False",

2878

"zeroconf": "True",

2879

}

2880

2473

server_defaults = { "interface": "",

2474

"address": "",

2475

"port": "",

2476

"debug": "False",

2477

"priority":

2478

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

2479

":+SIGN-DSA-SHA256",

2480

"servicename": "Mandos",

2481

"use_dbus": "True",

2482

"use_ipv6": "True",

2483

"debuglevel": "",

2484

"restore": "True",

2485

"socket": "",

2486

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

2487

"foreground": "False",

2488

"zeroconf": "True",

2489

}

2490

2881

2491

# Parse config file for server-global settings

2882

2492

server_config = configparser.SafeConfigParser(server_defaults)

2883

2493

del server_defaults

2885

2495

# Convert the SafeConfigParser object to a dict

2886

2496

server_settings = server_config.defaults()

2887

2497

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

2888

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

2889

"foreground", "zeroconf"):

2498

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

2890

2499

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

2891

2500

option)

2892

2501

if server_settings["port"]:

2902

2511

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

2903

2512

["socket"])

2904

2513

del server_config

2905

2514

2906

2515

# Override the settings from the config file with command line

2907

2516

# options, if set.

2908

2517

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

2926

2535

if server_settings["debug"]:

2927

2536

server_settings["foreground"] = True

2928

2537

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

2929

2538

2930

2539

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

2931

2540

2932

2541

if (not server_settings["zeroconf"]

2933

2542

and not (server_settings["port"]

2934

2543

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

2935

2544

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

2936

2545

2937

2546

# For convenience

2938

2547

debug = server_settings["debug"]

2939

2548

debuglevel = server_settings["debuglevel"]

2943

2552

stored_state_file)

2944

2553

foreground = server_settings["foreground"]

2945

2554

zeroconf = server_settings["zeroconf"]

2946

2555

2947

2556

if debug:

2948

2557

initlogger(debug, logging.DEBUG)

2949

2558

else:

2952

2561

else:

2953

2562

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

2954

2563

initlogger(debug, level)

2955

2564

2956

2565

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

2957

2566

syslogger.setFormatter(

2958

2567

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

2959

2568

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

2960

2569

server_settings["servicename"])))

2961

2570

2962

2571

# Parse config file with clients

2963

2572

client_config = configparser.SafeConfigParser(Client

2964

2573

.client_defaults)

2965

2574

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

2966

2575

"clients.conf"))

2967

2576

2968

2577

global mandos_dbus_service

2969

2578

mandos_dbus_service = None

2970

2579

2971

2580

socketfd = None

2972

2581

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

2973

2582

socketfd = server_settings["socket"]

2989

2598

except IOError as e:

2990

2599

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

2991

2600

exc_info=e)

2992

2993

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

2994

("mandos", "mandos"),

2995

("nobody", "nogroup")):

2601

2602

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

2996

2603

try:

2997

2604

uid = pwd.getpwnam(name).pw_uid

2998

gid = pwd.getpwnam(group).pw_gid

2605

gid = pwd.getpwnam(name).pw_gid

2999

2606

break

3000

2607

except KeyError:

3001

2608

continue

3005

2612

try:

3006

2613

os.setgid(gid)

3007

2614

os.setuid(uid)

3008

if debug:

3009

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

3010

gid))

3011

2615

except OSError as error:

3012

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

3013

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

3014

2616

if error.errno != errno.EPERM:

3015

2617

raise

3016

2618

3017

2619

if debug:

3018

2620

# Enable all possible GnuTLS debugging

3019

2621

3020

2622

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

3021

2623

# - GnuTLS manual

3022

gnutls.global_set_log_level(11)

3023

3024

@gnutls.log_func

2624

gnutls.library.functions.gnutls_global_set_log_level(11)

2625

2626

@gnutls.library.types.gnutls_log_func

3025

2627

def debug_gnutls(level, string):

3026

2628

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

3027

3028

gnutls.global_set_log_function(debug_gnutls)

3029

2629

2630

gnutls.library.functions.gnutls_global_set_log_function(

2631

debug_gnutls)

2632

3030

2633

# Redirect stdin so all checkers get /dev/null

3031

2634

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

3032

2635

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

3033

2636

if null > 2:

3034

2637

os.close(null)

3035

2638

3036

2639

# Need to fork before connecting to D-Bus

3037

2640

if not foreground:

3038

2641

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

3039

2642

daemon()

3040

3041

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

3042

# to inform GLib that threads will be used.

3043

GLib.threads_init()

3044

2643

2644

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

2645

# need to inform gobject that threads will be used.

2646

gobject.threads_init()

2647

3045

2648

global main_loop

3046

2649

# From the Avahi example code

3047

2650

DBusGMainLoop(set_as_default=True)

3048

main_loop = GLib.MainLoop()

2651

main_loop = gobject.MainLoop()

3049

2652

bus = dbus.SystemBus()

3050

2653

# End of Avahi example code

3051

2654

if use_dbus:

3064

2667

if zeroconf:

3065

2668

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3066

2669

service = AvahiServiceToSyslog(

3067

name=server_settings["servicename"],

3068

servicetype="_mandos._tcp",

3069

protocol=protocol,

3070

bus=bus)

2670

name = server_settings["servicename"],

2671

servicetype = "_mandos._tcp",

2672

protocol = protocol,

2673

bus = bus)

3071

2674

if server_settings["interface"]:

3072

2675

service.interface = if_nametoindex(

3073

2676

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

3074

2677

3075

2678

global multiprocessing_manager

3076

2679

multiprocessing_manager = multiprocessing.Manager()

3077

2680

3078

2681

client_class = Client

3079

2682

if use_dbus:

3080

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

3081

2683

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

2684

3082

2685

client_settings = Client.config_parser(client_config)

3083

2686

old_client_settings = {}

3084

2687

clients_data = {}

3085

2688

3086

2689

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

3087

2690

global wnull

3088

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

2691

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

3089

2692

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

3090

2693

# mode

3091

2694

if debug or not foreground:

3092

2695

wnull.close()

3093

2696

3094

2697

# Get client data and settings from last running state.

3095

2698

if server_settings["restore"]:

3096

2699

try:

3097

2700

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

3098

if sys.version_info.major == 2:

3099

clients_data, old_client_settings = pickle.load(

3100

stored_state)

3101

else:

3102

bytes_clients_data, bytes_old_client_settings = (

3103

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

3104

# Fix bytes to strings

3105

# clients_data

3106

# .keys()

3107

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

3108

if isinstance(key, bytes)

3109

else key): value

3110

for key, value in

3111

bytes_clients_data.items()}

3112

del bytes_clients_data

3113

for key in clients_data:

3114

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

3115

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

3116

for k, v in

3117

clients_data[key].items()}

3118

clients_data[key] = value

3119

# .client_structure

3120

value["client_structure"] = [

3121

(s.decode("utf-8")

3122

if isinstance(s, bytes)

3123

else s) for s in

3124

value["client_structure"]]

3125

# .name & .host

3126

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

3127

if isinstance(value[k], bytes):

3128

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

3129

# old_client_settings

3130

# .keys()

3131

old_client_settings = {

3132

(key.decode("utf-8")

3133

if isinstance(key, bytes)

3134

else key): value

3135

for key, value in

3136

bytes_old_client_settings.items()}

3137

del bytes_old_client_settings

3138

# .host

3139

for value in old_client_settings.values():

3140

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

3141

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

3142

.decode("utf-8"))

2701

clients_data, old_client_settings = pickle.load(

2702

stored_state)

3143

2703

os.remove(stored_state_path)

3144

2704

except IOError as e:

3145

2705

if e.errno == errno.ENOENT:

3153

2713

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

3154

2714

"EOFError:",

3155

2715

exc_info=e)

3156

2716

3157

2717

with PGPEngine() as pgp:

3158

2718

for client_name, client in clients_data.items():

3159

2719

# Skip removed clients

3160

2720

if client_name not in client_settings:

3161

2721

continue

3162

2722

3163

2723

# Decide which value to use after restoring saved state.

3164

2724

# We have three different values: Old config file,

3165

2725

# new config file, and saved state.

3176

2736

client[name] = value

3177

2737

except KeyError:

3178

2738

pass

3179

2739

3180

2740

# Clients who has passed its expire date can still be

3181

2741

# enabled if its last checker was successful. A Client

3182

2742

# whose checker succeeded before we stored its state is

3215

2775

client_name))

3216

2776

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

3217

2777

["secret"])

3218

2778

3219

2779

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

3220

2780

for client_name in (set(old_client_settings)

3221

2781

- set(client_settings)):

3223

2783

for client_name in (set(client_settings)

3224

2784

- set(old_client_settings)):

3225

2785

clients_data[client_name] = client_settings[client_name]

3226

2786

3227

2787

# Create all client objects

3228

2788

for client_name, client in clients_data.items():

3229

2789

tcp_server.clients[client_name] = client_class(

3230

name=client_name,

3231

settings=client,

3232

server_settings=server_settings)

3233

2790

name = client_name,

2791

settings = client,

2792

server_settings = server_settings)

2793

3234

2794

if not tcp_server.clients:

3235

2795

logger.warning("No clients defined")

3236

2796

3237

2797

if not foreground:

3238

2798

if pidfile is not None:

3239

2799

pid = os.getpid()

3245

2805

pidfilename, pid)

3246

2806

del pidfile

3247

2807

del pidfilename

3248

3249

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

3250

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3251

lambda: main_loop.quit() and False)

3252

2808

2809

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

2810

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

2811

3253

2812

if use_dbus:

3254

2813

3255

2814

@alternate_dbus_interfaces(

3256

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

3257

class MandosDBusService(DBusObjectWithObjectManager):

2815

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

2816

class MandosDBusService(DBusObjectWithAnnotations):

3258

2817

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

3259

2818

3260

2819

def __init__(self):

3261

2820

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

3262

2821

3263

2822

_interface = "se.recompile.Mandos"

3264

2823

3265

2824

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

3266

2825

def ClientAdded(self, objpath):

3267

2826

"D-Bus signal"

3268

2827

pass

3269

2828

3270

2829

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

3271

2830

def ClientNotFound(self, fingerprint, address):

3272

2831

"D-Bus signal"

3273

2832

pass

3274

3275

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

3276

"true"})

2833

3277

2834

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

3278

2835

def ClientRemoved(self, objpath, name):

3279

2836

"D-Bus signal"

3280

2837

pass

3281

3282

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

3283

"true"})

2838

3284

2839

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

3285

2840

def GetAllClients(self):

3286

2841

"D-Bus method"

3287

2842

return dbus.Array(c.dbus_object_path for c in

3288

tcp_server.clients.values())

3289

3290

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

3291

"true"})

2843

tcp_server.clients.itervalues())

2844

3292

2845

@dbus.service.method(_interface,

3293

2846

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

3294

2847

def GetAllClientsWithProperties(self):

3295

2848

"D-Bus method"

3296

2849

return dbus.Dictionary(

3297

{c.dbus_object_path: c.GetAll(

3298

"se.recompile.Mandos.Client")

3299

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

2850

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

2851

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

3300

2852

signature="oa{sv}")

3301

2853

3302

2854

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

3303

2855

def RemoveClient(self, object_path):

3304

2856

"D-Bus method"

3305

for c in tcp_server.clients.values():

2857

for c in tcp_server.clients.itervalues():

3306

2858

if c.dbus_object_path == object_path:

3307

2859

del tcp_server.clients[c.name]

3308

2860

c.remove_from_connection()

3309

# Don't signal the disabling

2861

# Don't signal anything except ClientRemoved

3310

2862

c.disable(quiet=True)

3311

# Emit D-Bus signal for removal

3312

self.client_removed_signal(c)

2863

# Emit D-Bus signal

2864

self.ClientRemoved(object_path, c.name)

3313

2865

return

3314

2866

raise KeyError(object_path)

3315

2867

3316

2868

del _interface

3317

3318

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3319

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

3320

def GetManagedObjects(self):

3321

"""D-Bus method"""

3322

return dbus.Dictionary(

3323

{client.dbus_object_path:

3324

dbus.Dictionary(

3325

{interface: client.GetAll(interface)

3326

for interface in

3327

client._get_all_interface_names()})

3328

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

3329

3330

def client_added_signal(self, client):

3331

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

3332

if use_dbus:

3333

# New standard signal

3334

self.InterfacesAdded(

3335

client.dbus_object_path,

3336

dbus.Dictionary(

3337

{interface: client.GetAll(interface)

3338

for interface in

3339

client._get_all_interface_names()}))

3340

# Old signal

3341

self.ClientAdded(client.dbus_object_path)

3342

3343

def client_removed_signal(self, client):

3344

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

3345

if use_dbus:

3346

# New standard signal

3347

self.InterfacesRemoved(

3348

client.dbus_object_path,

3349

client._get_all_interface_names())

3350

# Old signal

3351

self.ClientRemoved(client.dbus_object_path,

3352

client.name)

3353

2869

3354

2870

mandos_dbus_service = MandosDBusService()

3355

3356

# Save modules to variables to exempt the modules from being

3357

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

3358

mp = multiprocessing

3359

wn = wnull

3360

2871

3361

2872

def cleanup():

3362

2873

"Cleanup function; run on exit"

3363

2874

if zeroconf:

3364

2875

service.cleanup()

3365

3366

mp.active_children()

3367

wn.close()

2876

2877

multiprocessing.active_children()

2878

wnull.close()

3368

2879

if not (tcp_server.clients or client_settings):

3369

2880

return

3370

2881

3371

2882

# Store client before exiting. Secrets are encrypted with key

3372

2883

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

3373

2884

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

3374

2885

clients = {}

3375

2886

with PGPEngine() as pgp:

3376

for client in tcp_server.clients.values():

2887

for client in tcp_server.clients.itervalues():

3377

2888

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

3378

2889

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

3379

2890

key)

3380

2891

client_dict = {}

3381

2892

3382

2893

# A list of attributes that can not be pickled

3383

2894

# + secret.

3384

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

3385

"checker", "server_settings"}

2895

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

2896

"checker", "server_settings" }

3386

2897

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

3387

2898

.Object):

3388

2899

exclude.add(name)

3389

2900

3390

2901

client_dict["encrypted_secret"] = (client

3391

2902

.encrypted_secret)

3392

2903

for attr in client.client_structure:

3393

2904

if attr not in exclude:

3394

2905

client_dict[attr] = getattr(client, attr)

3395

2906

3396

2907

clients[client.name] = client_dict

3397

2908

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

3398

2909

3399

2910

try:

3400

2911

with tempfile.NamedTemporaryFile(

3401

2912

mode='wb',

3403

2914

prefix='clients-',

3404

2915

dir=os.path.dirname(stored_state_path),

3405

2916

delete=False) as stored_state:

3406

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

3407

protocol=2)

2917

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

3408

2918

tempname = stored_state.name

3409

2919

os.rename(tempname, stored_state_path)

3410

2920

except (IOError, OSError) as e:

3420

2930

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

3421

2931

exc_info=e)

3422

2932

raise

3423

2933

3424

2934

# Delete all clients, and settings from config

3425

2935

while tcp_server.clients:

3426

2936

name, client = tcp_server.clients.popitem()

3427

2937

if use_dbus:

3428

2938

client.remove_from_connection()

3429

# Don't signal the disabling

2939

# Don't signal anything except ClientRemoved

3430

2940

client.disable(quiet=True)

3431

# Emit D-Bus signal for removal

3432

2941

if use_dbus:

3433

mandos_dbus_service.client_removed_signal(client)

2942

# Emit D-Bus signal

2943

mandos_dbus_service.ClientRemoved(

2944

client.dbus_object_path, client.name)

3434

2945

client_settings.clear()

3435

2946

3436

2947

atexit.register(cleanup)

3437

3438

for client in tcp_server.clients.values():

2948

2949

for client in tcp_server.clients.itervalues():

3439

2950

if use_dbus:

3440

# Emit D-Bus signal for adding

3441

mandos_dbus_service.client_added_signal(client)

2951

# Emit D-Bus signal

2952

mandos_dbus_service.ClientAdded(client.dbus_object_path)

3442

2953

# Need to initiate checking of clients

3443

2954

if client.enabled:

3444

2955

client.init_checker()

3445

2956

3446

2957

tcp_server.enable()

3447

2958

tcp_server.server_activate()

3448

2959

3449

2960

# Find out what port we got

3450

2961

if zeroconf:

3451

2962

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

3456

2967

else: # IPv4

3457

2968

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

3458

2969

*tcp_server.socket.getsockname())

3459

3460

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

3461

2970

2971

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

2972

3462

2973

try:

3463

2974

if zeroconf:

3464

2975

# From the Avahi example code

3469

2980

cleanup()

3470

2981

sys.exit(1)

3471

2982

# End of Avahi example code

3472

3473

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

3474

lambda *args, **kwargs:

3475

(tcp_server.handle_request

3476

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

3477

2983

2984

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

2985

lambda *args, **kwargs:

2986

(tcp_server.handle_request

2987

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

2988

3478

2989

logger.debug("Starting main loop")

3479

2990

main_loop.run()

3480

2991

except AvahiError as error: