/mandos/release : revision 237.7.335

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.16"

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(self, *args,

500

**kwargs)

432

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

501

433

syslogger.setFormatter(logging.Formatter(

502

434

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

503

435

.format(self.name)))

504

436

return ret

505

437

506

507

# Pretend that we have a GnuTLS module

508

class GnuTLS(object):

509

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

510

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

511

512

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

513

if library is None:

514

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

515

_library = ctypes.cdll.LoadLibrary(library)

516

del library

517

_need_version = b"3.3.0"

518

519

def __init__(self):

520

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

521

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

522

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

523

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

524

.format(self._need_version))

525

526

# Unless otherwise indicated, the constants and types below are

527

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

528

529

# Constants

530

E_SUCCESS = 0

531

E_INTERRUPTED = -52

532

E_AGAIN = -28

533

CRT_OPENPGP = 2

534

CLIENT = 2

535

SHUT_RDWR = 0

536

CRD_CERTIFICATE = 1

537

E_NO_CERTIFICATE_FOUND = -49

538

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

539

540

# Types

541

class session_int(ctypes.Structure):

542

_fields_ = []

543

session_t = ctypes.POINTER(session_int)

544

545

class certificate_credentials_st(ctypes.Structure):

546

_fields_ = []

547

certificate_credentials_t = ctypes.POINTER(

548

certificate_credentials_st)

549

certificate_type_t = ctypes.c_int

550

551

class datum_t(ctypes.Structure):

552

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

553

('size', ctypes.c_uint)]

554

555

class openpgp_crt_int(ctypes.Structure):

556

_fields_ = []

557

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

558

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

559

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

560

credentials_type_t = ctypes.c_int

561

transport_ptr_t = ctypes.c_void_p

562

close_request_t = ctypes.c_int

563

564

# Exceptions

565

class Error(Exception):

566

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

567

# exception might be raised from within GnuTLS.__init__,

568

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

569

# global variable has happened.

570

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

571

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

572

# code is passed, convert it to a string with

573

# gnutls.strerror()

574

self.code = code

575

if message is None and code is not None:

576

message = GnuTLS.strerror(code)

577

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

578

message, *args)

579

580

class CertificateSecurityError(Error):

581

pass

582

583

# Classes

584

class Credentials(object):

585

def __init__(self):

586

self._c_object = gnutls.certificate_credentials_t()

587

gnutls.certificate_allocate_credentials(

588

ctypes.byref(self._c_object))

589

self.type = gnutls.CRD_CERTIFICATE

590

591

def __del__(self):

592

gnutls.certificate_free_credentials(self._c_object)

593

594

class ClientSession(object):

595

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

596

self._c_object = gnutls.session_t()

597

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

598

gnutls.set_default_priority(self._c_object)

599

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

600

gnutls.handshake_set_private_extensions(self._c_object,

601

True)

602

self.socket = socket

603

if credentials is None:

604

credentials = gnutls.Credentials()

605

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

606

ctypes.cast(credentials._c_object,

607

ctypes.c_void_p))

608

self.credentials = credentials

609

610

def __del__(self):

611

gnutls.deinit(self._c_object)

612

613

def handshake(self):

614

return gnutls.handshake(self._c_object)

615

616

def send(self, data):

617

data = bytes(data)

618

data_len = len(data)

619

while data_len > 0:

620

data_len -= gnutls.record_send(self._c_object,

621

data[-data_len:],

622

data_len)

623

624

def bye(self):

625

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

626

627

# Error handling functions

628

def _error_code(result):

629

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

630

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

631

if result >= 0:

632

return result

633

if result == gnutls.E_NO_CERTIFICATE_FOUND:

634

raise gnutls.CertificateSecurityError(code=result)

635

raise gnutls.Error(code=result)

636

637

def _retry_on_error(result, func, arguments):

638

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

639

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

640

while result < 0:

641

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

642

return _error_code(result)

643

result = func(*arguments)

644

return result

645

646

# Unless otherwise indicated, the function declarations below are

647

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

648

649

# Functions

650

priority_set_direct = _library.gnutls_priority_set_direct

651

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

652

ctypes.POINTER(ctypes.c_char_p)]

653

priority_set_direct.restype = _error_code

654

655

init = _library.gnutls_init

656

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

657

init.restype = _error_code

658

659

set_default_priority = _library.gnutls_set_default_priority

660

set_default_priority.argtypes = [session_t]

661

set_default_priority.restype = _error_code

662

663

record_send = _library.gnutls_record_send

664

record_send.argtypes = [session_t, ctypes.c_void_p,

665

ctypes.c_size_t]

666

record_send.restype = ctypes.c_ssize_t

667

record_send.errcheck = _retry_on_error

668

669

certificate_allocate_credentials = (

670

_library.gnutls_certificate_allocate_credentials)

671

certificate_allocate_credentials.argtypes = [

672

ctypes.POINTER(certificate_credentials_t)]

673

certificate_allocate_credentials.restype = _error_code

674

675

certificate_free_credentials = (

676

_library.gnutls_certificate_free_credentials)

677

certificate_free_credentials.argtypes = [

678

certificate_credentials_t]

679

certificate_free_credentials.restype = None

680

681

handshake_set_private_extensions = (

682

_library.gnutls_handshake_set_private_extensions)

683

handshake_set_private_extensions.argtypes = [session_t,

684

ctypes.c_int]

685

handshake_set_private_extensions.restype = None

686

687

credentials_set = _library.gnutls_credentials_set

688

credentials_set.argtypes = [session_t, credentials_type_t,

689

ctypes.c_void_p]

690

credentials_set.restype = _error_code

691

692

strerror = _library.gnutls_strerror

693

strerror.argtypes = [ctypes.c_int]

694

strerror.restype = ctypes.c_char_p

695

696

certificate_type_get = _library.gnutls_certificate_type_get

697

certificate_type_get.argtypes = [session_t]

698

certificate_type_get.restype = _error_code

699

700

certificate_get_peers = _library.gnutls_certificate_get_peers

701

certificate_get_peers.argtypes = [session_t,

702

ctypes.POINTER(ctypes.c_uint)]

703

certificate_get_peers.restype = ctypes.POINTER(datum_t)

704

705

global_set_log_level = _library.gnutls_global_set_log_level

706

global_set_log_level.argtypes = [ctypes.c_int]

707

global_set_log_level.restype = None

708

709

global_set_log_function = _library.gnutls_global_set_log_function

710

global_set_log_function.argtypes = [log_func]

711

global_set_log_function.restype = None

712

713

deinit = _library.gnutls_deinit

714

deinit.argtypes = [session_t]

715

deinit.restype = None

716

717

handshake = _library.gnutls_handshake

718

handshake.argtypes = [session_t]

719

handshake.restype = _error_code

720

handshake.errcheck = _retry_on_error

721

722

transport_set_ptr = _library.gnutls_transport_set_ptr

723

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

724

transport_set_ptr.restype = None

725

726

bye = _library.gnutls_bye

727

bye.argtypes = [session_t, close_request_t]

728

bye.restype = _error_code

729

bye.errcheck = _retry_on_error

730

731

check_version = _library.gnutls_check_version

732

check_version.argtypes = [ctypes.c_char_p]

733

check_version.restype = ctypes.c_char_p

734

735

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

736

737

openpgp_crt_init = _library.gnutls_openpgp_crt_init

738

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

739

openpgp_crt_init.restype = _error_code

740

741

openpgp_crt_import = _library.gnutls_openpgp_crt_import

742

openpgp_crt_import.argtypes = [openpgp_crt_t,

743

ctypes.POINTER(datum_t),

744

openpgp_crt_fmt_t]

745

openpgp_crt_import.restype = _error_code

746

747

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

748

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

749

ctypes.POINTER(ctypes.c_uint)]

750

openpgp_crt_verify_self.restype = _error_code

751

752

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

753

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

754

openpgp_crt_deinit.restype = None

755

756

openpgp_crt_get_fingerprint = (

757

_library.gnutls_openpgp_crt_get_fingerprint)

758

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

759

ctypes.c_void_p,

760

ctypes.POINTER(

761

ctypes.c_size_t)]

762

openpgp_crt_get_fingerprint.restype = _error_code

763

764

# Remove non-public functions

765

del _error_code, _retry_on_error

766

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

767

gnutls = GnuTLS()

768

769

770

438

def call_pipe(connection, # : multiprocessing.Connection

771

439

func, *args, **kwargs):

772

440

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

773

441

774

442

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

775

443

return value on the provided multiprocessing.Connection.

776

444

"""

777

445

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

778

446

connection.close()

779

447

780

781

448

class Client(object):

782

449

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

783

450

784

451

Attributes:

785

452

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

786

453

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

788

455

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

789

456

to see if the client lives.

790

457

'None' if no process is running.

791

checker_callback_tag: a GLib event source tag, or None

458

checker_callback_tag: a gobject event source tag, or None

792

459

checker_command: string; External command which is run to check

793

460

if client lives. %() expansions are done at

794

461

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

795

462

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

796

checker_initiator_tag: a GLib event source tag, or None

463

checker_initiator_tag: a gobject event source tag, or None

797

464

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

798

465

client_structure: Object describing what attributes a client has

799

466

and is used for storing the client at exit

800

467

current_checker_command: string; current running checker_command

801

disable_initiator_tag: a GLib event source tag, or None

468

disable_initiator_tag: a gobject event source tag, or None

802

469

enabled: bool()

803

470

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

804

471

uniquely identify the client

823

490

disabled, or None

824

491

server_settings: The server_settings dict from main()

825

492

"""

826

493

827

494

runtime_expansions = ("approval_delay", "approval_duration",

828

495

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

829

496

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

840

507

"approved_by_default": "True",

841

508

"enabled": "True",

842

509

}

843

510

844

511

@staticmethod

845

512

def config_parser(config):

846

513

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

853

520

for client_name in config.sections():

854

521

section = dict(config.items(client_name))

855

522

client = settings[client_name] = {}

856

523

857

524

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

858

525

# Reformat values from string types to Python types

859

526

client["approved_by_default"] = config.getboolean(

860

527

client_name, "approved_by_default")

861

528

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

862

529

"enabled")

863

530

864

531

# Uppercase and remove spaces from fingerprint for later

865

532

# comparison purposes with return value from the

866

533

# fingerprint() function

867

534

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

868

535

.replace(" ", ""))

869

536

if "secret" in section:

870

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

871

.encode("utf-8"),

872

"base64")

537

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

873

538

elif "secfile" in section:

874

539

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

875

540

(section["secfile"])),

890

555

client["last_approval_request"] = None

891

556

client["last_checked_ok"] = None

892

557

client["last_checker_status"] = -2

893

558

894

559

return settings

895

896

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

560

561

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

897

562

self.name = name

898

563

if server_settings is None:

899

564

server_settings = {}

901

566

# adding all client settings

902

567

for setting, value in settings.items():

903

568

setattr(self, setting, value)

904

569

905

570

if self.enabled:

906

571

if not hasattr(self, "last_enabled"):

907

572

self.last_enabled = datetime.datetime.utcnow()

911

576

else:

912

577

self.last_enabled = None

913

578

self.expires = None

914

579

915

580

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

916

581

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

917

582

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

918

583

datetime.datetime.utcnow())

919

584

920

585

# attributes specific for this server instance

921

586

self.checker = None

922

587

self.checker_initiator_tag = None

928

593

self.changedstate = multiprocessing_manager.Condition(

929

594

multiprocessing_manager.Lock())

930

595

self.client_structure = [attr

931

for attr in self.__dict__.keys()

596

for attr in self.__dict__.iterkeys()

932

597

if not attr.startswith("_")]

933

598

self.client_structure.append("client_structure")

934

599

935

600

for name, t in inspect.getmembers(

936

601

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

937

602

if not name.startswith("_"):

938

603

self.client_structure.append(name)

939

604

940

605

# Send notice to process children that client state has changed

941

606

def send_changedstate(self):

942

607

with self.changedstate:

943

608

self.changedstate.notify_all()

944

609

945

610

def enable(self):

946

611

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

947

612

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

952

617

self.last_enabled = datetime.datetime.utcnow()

953

618

self.init_checker()

954

619

self.send_changedstate()

955

620

956

621

def disable(self, quiet=True):

957

622

"""Disable this client."""

958

623

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

960

625

if not quiet:

961

626

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

962

627

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

963

GLib.source_remove(self.disable_initiator_tag)

628

gobject.source_remove(self.disable_initiator_tag)

964

629

self.disable_initiator_tag = None

965

630

self.expires = None

966

631

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

967

GLib.source_remove(self.checker_initiator_tag)

632

gobject.source_remove(self.checker_initiator_tag)

968

633

self.checker_initiator_tag = None

969

634

self.stop_checker()

970

635

self.enabled = False

971

636

if not quiet:

972

637

self.send_changedstate()

973

# 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

974

639

return False

975

640

976

641

def __del__(self):

977

642

self.disable()

978

643

979

644

def init_checker(self):

980

645

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

981

646

# and every interval from then on.

982

647

if self.checker_initiator_tag is not None:

983

GLib.source_remove(self.checker_initiator_tag)

984

self.checker_initiator_tag = GLib.timeout_add(

648

gobject.source_remove(self.checker_initiator_tag)

649

self.checker_initiator_tag = gobject.timeout_add(

985

650

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

986

651

self.start_checker)

987

652

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

988

653

if self.disable_initiator_tag is not None:

989

GLib.source_remove(self.disable_initiator_tag)

990

self.disable_initiator_tag = GLib.timeout_add(

654

gobject.source_remove(self.disable_initiator_tag)

655

self.disable_initiator_tag = gobject.timeout_add(

991

656

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

992

657

# Also start a new checker *right now*.

993

658

self.start_checker()

994

659

995

660

def checker_callback(self, source, condition, connection,

996

661

command):

997

662

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

1000

665

# Read return code from connection (see call_pipe)

1001

666

returncode = connection.recv()

1002

667

connection.close()

1003

668

1004

669

if returncode >= 0:

1005

670

self.last_checker_status = returncode

1006

671

self.last_checker_signal = None

1016

681

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

1017

682

vars(self))

1018

683

return False

1019

684

1020

685

def checked_ok(self):

1021

686

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

1022

687

self.last_checked_ok = datetime.datetime.utcnow()

1023

688

self.last_checker_status = 0

1024

689

self.last_checker_signal = None

1025

690

self.bump_timeout()

1026

691

1027

692

def bump_timeout(self, timeout=None):

1028

693

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

1029

694

if timeout is None:

1030

695

timeout = self.timeout

1031

696

if self.disable_initiator_tag is not None:

1032

GLib.source_remove(self.disable_initiator_tag)

697

gobject.source_remove(self.disable_initiator_tag)

1033

698

self.disable_initiator_tag = None

1034

699

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

1035

self.disable_initiator_tag = GLib.timeout_add(

700

self.disable_initiator_tag = gobject.timeout_add(

1036

701

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

1037

702

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

1038

703

1039

704

def need_approval(self):

1040

705

self.last_approval_request = datetime.datetime.utcnow()

1041

706

1042

707

def start_checker(self):

1043

708

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

1044

709

1045

710

If a checker already exists, leave it running and do

1046

711

nothing."""

1047

712

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

1052

717

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

1053

718

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

1054

719

# should be.

1055

720

1056

721

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

1057

722

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

1058

723

self.checker.join()

1062

727

# Escape attributes for the shell

1063

728

escaped_attrs = {

1064

729

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

1065

for attr in self.runtime_expansions}

730

for attr in self.runtime_expansions }

1066

731

try:

1067

732

command = self.checker_command % escaped_attrs

1068

733

except TypeError as error:

1080

745

# The exception is when not debugging but nevertheless

1081

746

# running in the foreground; use the previously

1082

747

# created wnull.

1083

popen_args = {"close_fds": True,

1084

"shell": True,

1085

"cwd": "/"}

748

popen_args = { "close_fds": True,

749

"shell": True,

750

"cwd": "/" }

1086

751

if (not self.server_settings["debug"]

1087

752

and self.server_settings["foreground"]):

1088

753

popen_args.update({"stdout": wnull,

1089

"stderr": wnull})

1090

pipe = multiprocessing.Pipe(duplex=False)

754

"stderr": wnull })

755

pipe = multiprocessing.Pipe(duplex = False)

1091

756

self.checker = multiprocessing.Process(

1092

target=call_pipe,

1093

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

1094

kwargs=popen_args)

757

target = call_pipe,

758

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

759

kwargs = popen_args)

1095

760

self.checker.start()

1096

self.checker_callback_tag = GLib.io_add_watch(

1097

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

761

self.checker_callback_tag = gobject.io_add_watch(

762

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

1098

763

self.checker_callback, pipe[0], command)

1099

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

764

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

1100

765

return True

1101

766

1102

767

def stop_checker(self):

1103

768

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

1104

769

if self.checker_callback_tag:

1105

GLib.source_remove(self.checker_callback_tag)

770

gobject.source_remove(self.checker_callback_tag)

1106

771

self.checker_callback_tag = None

1107

772

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

1108

773

return

1117

782

byte_arrays=False):

1118

783

"""Decorators for marking methods of a DBusObjectWithProperties to

1119

784

become properties on the D-Bus.

1120

785

1121

786

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

1122

787

and with one argument by "Set".

1123

788

1124

789

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

1125

790

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

1126

791

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

1130

795

if byte_arrays and signature != "ay":

1131

796

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

1132

797

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

1133

798

1134

799

def decorator(func):

1135

800

func._dbus_is_property = True

1136

801

func._dbus_interface = dbus_interface

1139

804

func._dbus_name = func.__name__

1140

805

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

1141

806

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

1142

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

807

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1143

808

return func

1144

809

1145

810

return decorator

1146

811

1147

812

1148

813

def dbus_interface_annotations(dbus_interface):

1149

814

"""Decorator for marking functions returning interface annotations

1150

815

1151

816

Usage:

1152

817

1153

818

@dbus_interface_annotations("org.example.Interface")

1154

819

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

1155

820

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

1156

821

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

1157

822

"false"}

1158

823

"""

1159

824

1160

825

def decorator(func):

1161

826

func._dbus_is_interface = True

1162

827

func._dbus_interface = dbus_interface

1163

828

func._dbus_name = dbus_interface

1164

829

return func

1165

830

1166

831

return decorator

1167

832

1168

833

1169

834

def dbus_annotations(annotations):

1170

835

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

1171

836

Usage:

1172

837

1173

838

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

1174

839

"org.freedesktop.DBus.Property."

1175

840

"EmitsChangedSignal": "false"})

1177

842

access="r")

1178

843

def Property_dbus_property(self):

1179

844

return dbus.Boolean(False)

1180

845

1181

846

See also the DBusObjectWithAnnotations class.

1182

847

"""

1183

848

1184

849

def decorator(func):

1185

850

func._dbus_annotations = annotations

1186

851

return func

1187

852

1188

853

return decorator

1189

854

1190

855

1208

873

1209

874

class DBusObjectWithAnnotations(dbus.service.Object):

1210

875

"""A D-Bus object with annotations.

1211

876

1212

877

Classes inheriting from this can use the dbus_annotations

1213

878

decorator to add annotations to methods or signals.

1214

879

"""

1215

880

1216

881

@staticmethod

1217

882

def _is_dbus_thing(thing):

1218

883

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

1219

884

1220

885

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

1221

886

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

1222

887

"""

1223

888

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

1224

889

False)

1225

890

1226

891

def _get_all_dbus_things(self, thing):

1227

892

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

1228

893

"""

1231

896

for cls in self.__class__.__mro__

1232

897

for name, athing in

1233

898

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

1234

899

1235

900

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1236

out_signature="s",

1237

path_keyword='object_path',

1238

connection_keyword='connection')

901

out_signature = "s",

902

path_keyword = 'object_path',

903

connection_keyword = 'connection')

1239

904

def Introspect(self, object_path, connection):

1240

905

"""Overloading of standard D-Bus method.

1241

906

1242

907

Inserts annotation tags on methods and signals.

1243

908

"""

1244

909

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

1245

910

connection)

1246

911

try:

1247

912

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

1248

913

1249

914

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

1250

915

# Add annotation tags

1251

916

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

1278

943

if_tag.appendChild(ann_tag)

1279

944

# Fix argument name for the Introspect method itself

1280

945

if (if_tag.getAttribute("name")

1281

== dbus.INTROSPECTABLE_IFACE):

946

== dbus.INTROSPECTABLE_IFACE):

1282

947

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

1283

948

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

1284

949

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

1297

962

1298

963

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1299

964

"""A D-Bus object with properties.

1300

965

1301

966

Classes inheriting from this can use the dbus_service_property

1302

967

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

1303

968

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

1304

969

"""

1305

970

1306

971

def _get_dbus_property(self, interface_name, property_name):

1307

972

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

1308

973

property with the specified name and interface.

1313

978

if (value._dbus_name == property_name

1314

979

and value._dbus_interface == interface_name):

1315

980

return value.__get__(self)

1316

981

1317

982

# No such property

1318

983

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

1319

984

self.dbus_object_path, interface_name, property_name))

1320

985

1321

986

@classmethod

1322

987

def _get_all_interface_names(cls):

1323

988

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

1326

991

for x in (inspect.getmro(cls))

1327

992

for attr in dir(x))

1328

993

if name is not None)

1329

994

1330

995

@dbus.service.method(dbus.PROPERTIES_IFACE,

1331

996

in_signature="ss",

1332

997

out_signature="v")

1340

1005

if not hasattr(value, "variant_level"):

1341

1006

return value

1342

1007

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

1343

1008

1344

1009

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

1345

1010

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

1346

1011

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

1358

1023

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

1359

1024

for byte in value))

1360

1025

prop(value)

1361

1026

1362

1027

@dbus.service.method(dbus.PROPERTIES_IFACE,

1363

1028

in_signature="s",

1364

1029

out_signature="a{sv}")

1365

1030

def GetAll(self, interface_name):

1366

1031

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

1367

1032

standard.

1368

1033

1369

1034

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

1370

1035

"""

1371

1036

properties = {}

1382

1047

properties[name] = value

1383

1048

continue

1384

1049

properties[name] = type(value)(

1385

value, variant_level=value.variant_level + 1)

1050

value, variant_level = value.variant_level + 1)

1386

1051

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

1387

1052

1388

1053

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

1389

1054

def PropertiesChanged(self, interface_name, changed_properties,

1390

1055

invalidated_properties):

1392

1057

standard.

1393

1058

"""

1394

1059

pass

1395

1060

1396

1061

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1397

1062

out_signature="s",

1398

1063

path_keyword='object_path',

1399

1064

connection_keyword='connection')

1400

1065

def Introspect(self, object_path, connection):

1401

1066

"""Overloading of standard D-Bus method.

1402

1067

1403

1068

Inserts property tags and interface annotation tags.

1404

1069

"""

1405

1070

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1407

1072

connection)

1408

1073

try:

1409

1074

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

1410

1075

1411

1076

def make_tag(document, name, prop):

1412

1077

e = document.createElement("property")

1413

1078

e.setAttribute("name", name)

1414

1079

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

1415

1080

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

1416

1081

return e

1417

1082

1418

1083

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

1419

1084

# Add property tags

1420

1085

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

1462

1127

exc_info=error)

1463

1128

return xmlstring

1464

1129

1465

1466

1130

try:

1467

1131

dbus.OBJECT_MANAGER_IFACE

1468

1132

except AttributeError:

1469

1133

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

1470

1134

1471

1472

1135

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1473

1136

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

1474

1137

1475

1138

Classes inheriting from this exposes the standard

1476

1139

GetManagedObjects call and the InterfacesAdded and

1477

1140

InterfacesRemoved signals on the standard

1478

1141

"org.freedesktop.DBus.ObjectManager" interface.

1479

1142

1480

1143

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

1481

1144

manually.

1482

1145

"""

1483

1146

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1484

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

1147

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

1485

1148

def GetManagedObjects(self):

1486

1149

"""This function must be overridden"""

1487

1150

raise NotImplementedError()

1488

1151

1489

1152

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1490

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

1153

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

1491

1154

def InterfacesAdded(self, object_path, interfaces_and_properties):

1492

1155

pass

1493

1494

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

1156

1157

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

1495

1158

def InterfacesRemoved(self, object_path, interfaces):

1496

1159

pass

1497

1160

1498

1161

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1499

out_signature="s",

1500

path_keyword='object_path',

1501

connection_keyword='connection')

1162

out_signature = "s",

1163

path_keyword = 'object_path',

1164

connection_keyword = 'connection')

1502

1165

def Introspect(self, object_path, connection):

1503

1166

"""Overloading of standard D-Bus method.

1504

1167

1505

1168

Override return argument name of GetManagedObjects to be

1506

1169

"objpath_interfaces_and_properties"

1507

1170

"""

1510

1173

connection)

1511

1174

try:

1512

1175

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

1513

1176

1514

1177

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

1515

1178

# Fix argument name for the GetManagedObjects method

1516

1179

if (if_tag.getAttribute("name")

1517

== dbus.OBJECT_MANAGER_IFACE):

1180

== dbus.OBJECT_MANAGER_IFACE):

1518

1181

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

1519

1182

if (cn.getAttribute("name")

1520

1183

== "GetManagedObjects"):

1530

1193

except (AttributeError, xml.dom.DOMException,

1531

1194

xml.parsers.expat.ExpatError) as error:

1532

1195

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

1533

exc_info=error)

1196

exc_info = error)

1534

1197

return xmlstring

1535

1198

1536

1537

1199

def datetime_to_dbus(dt, variant_level=0):

1538

1200

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

1539

1201

if dt is None:

1540

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

1202

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

1541

1203

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

1542

1204

1543

1205

1546

1208

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

1547

1209

interface names according to the "alt_interface_names" mapping.

1548

1210

Usage:

1549

1211

1550

1212

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

1551

1213

"net.example.AlternateInterface"})

1552

1214

class SampleDBusObject(dbus.service.Object):

1553

1215

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

1554

1216

def SampleDBusMethod():

1555

1217

pass

1556

1218

1557

1219

The above "SampleDBusMethod" on "SampleDBusObject" will be

1558

1220

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

1559

1221

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

1560

1222

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

1561

1223

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

1562

1224

1563

1225

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

1564

1226

(from DBusObjectWithProperties) and interfaces (from the

1565

1227

dbus_interface_annotations decorator).

1566

1228

"""

1567

1229

1568

1230

def wrapper(cls):

1569

1231

for orig_interface_name, alt_interface_name in (

1570

1232

alt_interface_names.items()):

1585

1247

interface_names.add(alt_interface)

1586

1248

# Is this a D-Bus signal?

1587

1249

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

1588

# Extract the original non-method undecorated

1589

# function by black magic

1590

1250

if sys.version_info.major == 2:

1251

# Extract the original non-method undecorated

1252

# function by black magic

1591

1253

nonmethod_func = (dict(

1592

1254

zip(attribute.func_code.co_freevars,

1593

1255

attribute.__closure__))

1594

1256

["func"].cell_contents)

1595

1257

else:

1596

nonmethod_func = (dict(

1597

zip(attribute.__code__.co_freevars,

1598

attribute.__closure__))

1599

["func"].cell_contents)

1258

nonmethod_func = attribute

1600

1259

# Create a new, but exactly alike, function

1601

1260

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

1602

1261

# with the alternate D-Bus interface name

1603

new_function = copy_function(nonmethod_func)

1262

if sys.version_info.major == 2:

1263

new_function = types.FunctionType(

1264

nonmethod_func.func_code,

1265

nonmethod_func.func_globals,

1266

nonmethod_func.func_name,

1267

nonmethod_func.func_defaults,

1268

nonmethod_func.func_closure)

1269

else:

1270

new_function = types.FunctionType(

1271

nonmethod_func.__code__,

1272

nonmethod_func.__globals__,

1273

nonmethod_func.__name__,

1274

nonmethod_func.__defaults__,

1275

nonmethod_func.__closure__)

1604

1276

new_function = (dbus.service.signal(

1605

1277

alt_interface,

1606

1278

attribute._dbus_signature)(new_function))

1610

1282

attribute._dbus_annotations)

1611

1283

except AttributeError:

1612

1284

pass

1613

1614

1285

# Define a creator of a function to call both the

1615

1286

# original and alternate functions, so both the

1616

1287

# original and alternate signals gets sent when

1619

1290

"""This function is a scope container to pass

1620

1291

func1 and func2 to the "call_both" function

1621

1292

outside of its arguments"""

1622

1293

1623

1294

@functools.wraps(func2)

1624

1295

def call_both(*args, **kwargs):

1625

1296

"""This function will emit two D-Bus

1626

1297

signals by calling func1 and func2"""

1627

1298

func1(*args, **kwargs)

1628

1299

func2(*args, **kwargs)

1629

# Make wrapper function look like a D-Bus

1630

# signal

1300

# Make wrapper function look like a D-Bus signal

1631

1301

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

1632

1302

if name.startswith("_dbus_"):

1633

1303

setattr(call_both, name, attr)

1634

1304

1635

1305

return call_both

1636

1306

# Create the "call_both" function and add it to

1637

1307

# the class

1647

1317

alt_interface,

1648

1318

attribute._dbus_in_signature,

1649

1319

attribute._dbus_out_signature)

1650

(copy_function(attribute)))

1320

(types.FunctionType(attribute.func_code,

1321

attribute.func_globals,

1322

attribute.func_name,

1323

attribute.func_defaults,

1324

attribute.func_closure)))

1651

1325

# Copy annotations, if any

1652

1326

try:

1653

1327

attr[attrname]._dbus_annotations = dict(

1665

1339

attribute._dbus_access,

1666

1340

attribute._dbus_get_args_options

1667

1341

["byte_arrays"])

1668

(copy_function(attribute)))

1342

(types.FunctionType(

1343

attribute.func_code,

1344

attribute.func_globals,

1345

attribute.func_name,

1346

attribute.func_defaults,

1347

attribute.func_closure)))

1669

1348

# Copy annotations, if any

1670

1349

try:

1671

1350

attr[attrname]._dbus_annotations = dict(

1680

1359

# to the class.

1681

1360

attr[attrname] = (

1682

1361

dbus_interface_annotations(alt_interface)

1683

(copy_function(attribute)))

1362

(types.FunctionType(attribute.func_code,

1363

attribute.func_globals,

1364

attribute.func_name,

1365

attribute.func_defaults,

1366

attribute.func_closure)))

1684

1367

if deprecate:

1685

1368

# Deprecate all alternate interfaces

1686

iname = "_AlternateDBusNames_interface_annotation{}"

1369

iname="_AlternateDBusNames_interface_annotation{}"

1687

1370

for interface_name in interface_names:

1688

1371

1689

1372

@dbus_interface_annotations(interface_name)

1690

1373

def func(self):

1691

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

1692

"true"}

1374

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

1375

"true" }

1693

1376

# Find an unused name

1694

1377

for aname in (iname.format(i)

1695

1378

for i in itertools.count()):

1699

1382

if interface_names:

1700

1383

# Replace the class with a new subclass of it with

1701

1384

# methods, signals, etc. as created above.

1702

if sys.version_info.major == 2:

1703

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

1704

(cls, ), attr)

1705

else:

1706

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

1707

(cls, ), attr)

1385

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

1386

(cls, ), attr)

1708

1387

return cls

1709

1388

1710

1389

return wrapper

1711

1390

1712

1391

1714

1393

"se.bsnet.fukt.Mandos"})

1715

1394

class ClientDBus(Client, DBusObjectWithProperties):

1716

1395

"""A Client class using D-Bus

1717

1396

1718

1397

Attributes:

1719

1398

dbus_object_path: dbus.ObjectPath

1720

1399

bus: dbus.SystemBus()

1721

1400

"""

1722

1401

1723

1402

runtime_expansions = (Client.runtime_expansions

1724

1403

+ ("dbus_object_path", ))

1725

1404

1726

1405

_interface = "se.recompile.Mandos.Client"

1727

1406

1728

1407

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

1729

1730

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

1408

1409

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

1731

1410

self.bus = bus

1732

1411

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

1733

1412

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

1739

1418

"/clients/" + client_object_name)

1740

1419

DBusObjectWithProperties.__init__(self, self.bus,

1741

1420

self.dbus_object_path)

1742

1421

1743

1422

def notifychangeproperty(transform_func, dbus_name,

1744

1423

type_func=lambda x: x,

1745

1424

variant_level=1,

1747

1426

_interface=_interface):

1748

1427

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

1749

1428

its changes to DBus.

1750

1429

1751

1430

transform_fun: Function that takes a value and a variant_level

1752

1431

and transforms it to a D-Bus type.

1753

1432

dbus_name: D-Bus name of the variable

1756

1435

variant_level: D-Bus variant level. Default: 1

1757

1436

"""

1758

1437

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

1759

1438

1760

1439

def setter(self, value):

1761

1440

if hasattr(self, "dbus_object_path"):

1762

1441

if (not hasattr(self, attrname) or

1769

1448

else:

1770

1449

dbus_value = transform_func(

1771

1450

type_func(value),

1772

variant_level=variant_level)

1451

variant_level = variant_level)

1773

1452

self.PropertyChanged(dbus.String(dbus_name),

1774

1453

dbus_value)

1775

1454

self.PropertiesChanged(

1776

1455

_interface,

1777

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

1778

dbus_value}),

1456

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

1457

dbus_value }),

1779

1458

dbus.Array())

1780

1459

setattr(self, attrname, value)

1781

1460

1782

1461

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

1783

1462

1784

1463

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1785

1464

approvals_pending = notifychangeproperty(dbus.Boolean,

1786

1465

"ApprovalPending",

1787

type_func=bool)

1466

type_func = bool)

1788

1467

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

1789

1468

last_enabled = notifychangeproperty(datetime_to_dbus,

1790

1469

"LastEnabled")

1791

1470

checker = notifychangeproperty(

1792

1471

dbus.Boolean, "CheckerRunning",

1793

type_func=lambda checker: checker is not None)

1472

type_func = lambda checker: checker is not None)

1794

1473

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1795

1474

"LastCheckedOK")

1796

1475

last_checker_status = notifychangeproperty(dbus.Int16,

1801

1480

"ApprovedByDefault")

1802

1481

approval_delay = notifychangeproperty(

1803

1482

dbus.UInt64, "ApprovalDelay",

1804

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

1483

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

1805

1484

approval_duration = notifychangeproperty(

1806

1485

dbus.UInt64, "ApprovalDuration",

1807

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

1486

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

1808

1487

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

1809

1488

timeout = notifychangeproperty(

1810

1489

dbus.UInt64, "Timeout",

1811

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

1490

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

1812

1491

extended_timeout = notifychangeproperty(

1813

1492

dbus.UInt64, "ExtendedTimeout",

1814

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

1493

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

1815

1494

interval = notifychangeproperty(

1816

1495

dbus.UInt64, "Interval",

1817

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

1496

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

1818

1497

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

1819

1498

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

1820

1499

invalidate_only=True)

1821

1500

1822

1501

del notifychangeproperty

1823

1502

1824

1503

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

1825

1504

try:

1826

1505

self.remove_from_connection()

1829

1508

if hasattr(DBusObjectWithProperties, "__del__"):

1830

1509

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

1831

1510

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

1832

1511

1833

1512

def checker_callback(self, source, condition,

1834

1513

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

1835

1514

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

1851

1530

| self.last_checker_signal),

1852

1531

dbus.String(command))

1853

1532

return ret

1854

1533

1855

1534

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

1856

1535

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

1857

1536

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

1861

1540

# Emit D-Bus signal

1862

1541

self.CheckerStarted(self.current_checker_command)

1863

1542

return r

1864

1543

1865

1544

def _reset_approved(self):

1866

1545

self.approved = None

1867

1546

return False

1868

1547

1869

1548

def approve(self, value=True):

1870

1549

self.approved = value

1871

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

1872

* 1000), self._reset_approved)

1550

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

1551

* 1000), self._reset_approved)

1873

1552

self.send_changedstate()

1874

1875

# D-Bus methods, signals & properties

1876

1877

# Interfaces

1878

1879

# Signals

1880

1553

1554

## D-Bus methods, signals & properties

1555

1556

## Interfaces

1557

1558

## Signals

1559

1881

1560

# CheckerCompleted - signal

1882

1561

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

1883

1562

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

1884

1563

"D-Bus signal"

1885

1564

pass

1886

1565

1887

1566

# CheckerStarted - signal

1888

1567

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

1889

1568

def CheckerStarted(self, command):

1890

1569

"D-Bus signal"

1891

1570

pass

1892

1571

1893

1572

# PropertyChanged - signal

1894

1573

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

1895

1574

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

1896

1575

def PropertyChanged(self, property, value):

1897

1576

"D-Bus signal"

1898

1577

pass

1899

1578

1900

1579

# GotSecret - signal

1901

1580

@dbus.service.signal(_interface)

1902

1581

def GotSecret(self):

1905

1584

server to mandos-client

1906

1585

"""

1907

1586

pass

1908

1587

1909

1588

# Rejected - signal

1910

1589

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

1911

1590

def Rejected(self, reason):

1912

1591

"D-Bus signal"

1913

1592

pass

1914

1593

1915

1594

# NeedApproval - signal

1916

1595

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

1917

1596

def NeedApproval(self, timeout, default):

1918

1597

"D-Bus signal"

1919

1598

return self.need_approval()

1920

1921

# Methods

1922

1599

1600

## Methods

1601

1923

1602

# Approve - method

1924

1603

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

1925

1604

def Approve(self, value):

1926

1605

self.approve(value)

1927

1606

1928

1607

# CheckedOK - method

1929

1608

@dbus.service.method(_interface)

1930

1609

def CheckedOK(self):

1931

1610

self.checked_ok()

1932

1611

1933

1612

# Enable - method

1934

1613

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

1935

1614

@dbus.service.method(_interface)

1936

1615

def Enable(self):

1937

1616

"D-Bus method"

1938

1617

self.enable()

1939

1618

1940

1619

# StartChecker - method

1941

1620

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

1942

1621

@dbus.service.method(_interface)

1943

1622

def StartChecker(self):

1944

1623

"D-Bus method"

1945

1624

self.start_checker()

1946

1625

1947

1626

# Disable - method

1948

1627

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

1949

1628

@dbus.service.method(_interface)

1950

1629

def Disable(self):

1951

1630

"D-Bus method"

1952

1631

self.disable()

1953

1632

1954

1633

# StopChecker - method

1955

1634

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

1956

1635

@dbus.service.method(_interface)

1957

1636

def StopChecker(self):

1958

1637

self.stop_checker()

1959

1960

# Properties

1961

1638

1639

## Properties

1640

1962

1641

# ApprovalPending - property

1963

1642

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

1964

1643

def ApprovalPending_dbus_property(self):

1965

1644

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

1966

1645

1967

1646

# ApprovedByDefault - property

1968

1647

@dbus_service_property(_interface,

1969

1648

signature="b",

1972

1651

if value is None: # get

1973

1652

return dbus.Boolean(self.approved_by_default)

1974

1653

self.approved_by_default = bool(value)

1975

1654

1976

1655

# ApprovalDelay - property

1977

1656

@dbus_service_property(_interface,

1978

1657

signature="t",

1982

1661

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

1983

1662

* 1000)

1984

1663

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

1985

1664

1986

1665

# ApprovalDuration - property

1987

1666

@dbus_service_property(_interface,

1988

1667

signature="t",

1992

1671

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

1993

1672

* 1000)

1994

1673

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

1995

1674

1996

1675

# Name - property

1997

1676

@dbus_annotations(

1998

1677

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

1999

1678

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

2000

1679

def Name_dbus_property(self):

2001

1680

return dbus.String(self.name)

2002

1681

2003

1682

# Fingerprint - property

2004

1683

@dbus_annotations(

2005

1684

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

2006

1685

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

2007

1686

def Fingerprint_dbus_property(self):

2008

1687

return dbus.String(self.fingerprint)

2009

1688

2010

1689

# Host - property

2011

1690

@dbus_service_property(_interface,

2012

1691

signature="s",

2015

1694

if value is None: # get

2016

1695

return dbus.String(self.host)

2017

1696

self.host = str(value)

2018

1697

2019

1698

# Created - property

2020

1699

@dbus_annotations(

2021

1700

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

2022

1701

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

2023

1702

def Created_dbus_property(self):

2024

1703

return datetime_to_dbus(self.created)

2025

1704

2026

1705

# LastEnabled - property

2027

1706

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

2028

1707

def LastEnabled_dbus_property(self):

2029

1708

return datetime_to_dbus(self.last_enabled)

2030

1709

2031

1710

# Enabled - property

2032

1711

@dbus_service_property(_interface,

2033

1712

signature="b",

2039

1718

self.enable()

2040

1719

else:

2041

1720

self.disable()

2042

1721

2043

1722

# LastCheckedOK - property

2044

1723

@dbus_service_property(_interface,

2045

1724

signature="s",

2049

1728

self.checked_ok()

2050

1729

return

2051

1730

return datetime_to_dbus(self.last_checked_ok)

2052

1731

2053

1732

# LastCheckerStatus - property

2054

1733

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

2055

1734

def LastCheckerStatus_dbus_property(self):

2056

1735

return dbus.Int16(self.last_checker_status)

2057

1736

2058

1737

# Expires - property

2059

1738

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

2060

1739

def Expires_dbus_property(self):

2061

1740

return datetime_to_dbus(self.expires)

2062

1741

2063

1742

# LastApprovalRequest - property

2064

1743

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

2065

1744

def LastApprovalRequest_dbus_property(self):

2066

1745

return datetime_to_dbus(self.last_approval_request)

2067

1746

2068

1747

# Timeout - property

2069

1748

@dbus_service_property(_interface,

2070

1749

signature="t",

2085

1764

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

2086

1765

is None):

2087

1766

return

2088

GLib.source_remove(self.disable_initiator_tag)

2089

self.disable_initiator_tag = GLib.timeout_add(

1767

gobject.source_remove(self.disable_initiator_tag)

1768

self.disable_initiator_tag = gobject.timeout_add(

2090

1769

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

2091

1770

self.disable)

2092

1771

2093

1772

# ExtendedTimeout - property

2094

1773

@dbus_service_property(_interface,

2095

1774

signature="t",

2099

1778

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

2100

1779

* 1000)

2101

1780

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

2102

1781

2103

1782

# Interval - property

2104

1783

@dbus_service_property(_interface,

2105

1784

signature="t",

2112

1791

return

2113

1792

if self.enabled:

2114

1793

# Reschedule checker run

2115

GLib.source_remove(self.checker_initiator_tag)

2116

self.checker_initiator_tag = GLib.timeout_add(

1794

gobject.source_remove(self.checker_initiator_tag)

1795

self.checker_initiator_tag = gobject.timeout_add(

2117

1796

value, self.start_checker)

2118

self.start_checker() # Start one now, too

2119

1797

self.start_checker() # Start one now, too

1798

2120

1799

# Checker - property

2121

1800

@dbus_service_property(_interface,

2122

1801

signature="s",

2125

1804

if value is None: # get

2126

1805

return dbus.String(self.checker_command)

2127

1806

self.checker_command = str(value)

2128

1807

2129

1808

# CheckerRunning - property

2130

1809

@dbus_service_property(_interface,

2131

1810

signature="b",

2137

1816

self.start_checker()

2138

1817

else:

2139

1818

self.stop_checker()

2140

1819

2141

1820

# ObjectPath - property

2142

1821

@dbus_annotations(

2143

1822

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

2144

1823

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

2145

1824

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

2146

1825

def ObjectPath_dbus_property(self):

2147

return self.dbus_object_path # is already a dbus.ObjectPath

2148

1826

return self.dbus_object_path # is already a dbus.ObjectPath

1827

2149

1828

# Secret = property

2150

1829

@dbus_annotations(

2151

1830

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

2156

1835

byte_arrays=True)

2157

1836

def Secret_dbus_property(self, value):

2158

1837

self.secret = bytes(value)

2159

1838

2160

1839

del _interface

2161

1840

2162

1841

2166

1845

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

2167

1846

if not self._pipe.recv():

2168

1847

raise KeyError(fpr)

2169

1848

2170

1849

def __getattribute__(self, name):

2171

1850

if name == '_pipe':

2172

1851

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

2175

1854

if data[0] == 'data':

2176

1855

return data[1]

2177

1856

if data[0] == 'function':

2178

1857

2179

1858

def func(*args, **kwargs):

2180

1859

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

2181

1860

return self._pipe.recv()[1]

2182

1861

2183

1862

return func

2184

1863

2185

1864

def __setattr__(self, name, value):

2186

1865

if name == '_pipe':

2187

1866

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

2190

1869

2191

1870

class ClientHandler(socketserver.BaseRequestHandler, object):

2192

1871

"""A class to handle client connections.

2193

1872

2194

1873

Instantiated once for each connection to handle it.

2195

1874

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

2196

1875

2197

1876

def handle(self):

2198

1877

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

2199

1878

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

2200

1879

str(self.client_address))

2201

1880

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

2202

1881

self.server.child_pipe.fileno())

2203

2204

session = gnutls.ClientSession(self.request)

2205

2206

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

2207

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

2208

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

2209

# "+DHE-DSS"))

1882

1883

session = gnutls.connection.ClientSession(

1884

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

1885

1886

# Note: gnutls.connection.X509Credentials is really a

1887

# generic GnuTLS certificate credentials object so long as

1888

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

1889

# here despite using OpenPGP certificates.

1890

1891

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

1892

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

1893

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

1894

# "+DHE-DSS"))

2210

1895

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

2211

1896

priority = self.server.gnutls_priority

2212

1897

if priority is None:

2213

1898

priority = "NORMAL"

2214

gnutls.priority_set_direct(session._c_object,

2215

priority.encode("utf-8"),

2216

None)

2217

1899

gnutls.library.functions.gnutls_priority_set_direct(

1900

session._c_object, priority, None)

1901

2218

1902

# Start communication using the Mandos protocol

2219

1903

# Get protocol number

2220

1904

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

2225

1909

except (ValueError, IndexError, RuntimeError) as error:

2226

1910

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

2227

1911

return

2228

1912

2229

1913

# Start GnuTLS connection

2230

1914

try:

2231

1915

session.handshake()

2232

except gnutls.Error as error:

1916

except gnutls.errors.GNUTLSError as error:

2233

1917

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

2234

1918

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

2235

1919

# established. Just abandon the request.

2236

1920

return

2237

1921

logger.debug("Handshake succeeded")

2238

1922

2239

1923

approval_required = False

2240

1924

try:

2241

1925

try:

2242

1926

fpr = self.fingerprint(

2243

1927

self.peer_certificate(session))

2244

except (TypeError, gnutls.Error) as error:

1928

except (TypeError,

1929

gnutls.errors.GNUTLSError) as error:

2245

1930

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

2246

1931

return

2247

1932

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

2248

1933

2249

1934

try:

2250

1935

client = ProxyClient(child_pipe, fpr,

2251

1936

self.client_address)

2252

1937

except KeyError:

2253

1938

return

2254

1939

2255

1940

if client.approval_delay:

2256

1941

delay = client.approval_delay

2257

1942

client.approvals_pending += 1

2258

1943

approval_required = True

2259

1944

2260

1945

while True:

2261

1946

if not client.enabled:

2262

1947

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

2265

1950

# Emit D-Bus signal

2266

1951

client.Rejected("Disabled")

2267

1952

return

2268

1953

2269

1954

if client.approved or not client.approval_delay:

2270

# We are approved or approval is disabled

1955

#We are approved or approval is disabled

2271

1956

break

2272

1957

elif client.approved is None:

2273

1958

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

2284

1969

# Emit D-Bus signal

2285

1970

client.Rejected("Denied")

2286

1971

return

2287

2288

# wait until timeout or approved

1972

1973

#wait until timeout or approved

2289

1974

time = datetime.datetime.now()

2290

1975

client.changedstate.acquire()

2291

1976

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

2304

1989

break

2305

1990

else:

2306

1991

delay -= time2 - time

2307

2308

try:

2309

session.send(client.secret)

2310

except gnutls.Error as error:

2311

logger.warning("gnutls send failed",

2312

exc_info=error)

2313

return

2314

1992

1993

sent_size = 0

1994

while sent_size < len(client.secret):

1995

try:

1996

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

1997

except gnutls.errors.GNUTLSError as error:

1998

logger.warning("gnutls send failed",

1999

exc_info=error)

2000

return

2001

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

2002

len(client.secret) - (sent_size

2003

+ sent))

2004

sent_size += sent

2005

2315

2006

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

2316

2007

# bump the timeout using extended_timeout

2317

2008

client.bump_timeout(client.extended_timeout)

2318

2009

if self.server.use_dbus:

2319

2010

# Emit D-Bus signal

2320

2011

client.GotSecret()

2321

2012

2322

2013

finally:

2323

2014

if approval_required:

2324

2015

client.approvals_pending -= 1

2325

2016

try:

2326

2017

session.bye()

2327

except gnutls.Error as error:

2018

except gnutls.errors.GNUTLSError as error:

2328

2019

logger.warning("GnuTLS bye failed",

2329

2020

exc_info=error)

2330

2021

2331

2022

@staticmethod

2332

2023

def peer_certificate(session):

2333

2024

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

2334

2025

# If not an OpenPGP certificate...

2335

if (gnutls.certificate_type_get(session._c_object)

2336

!= gnutls.CRT_OPENPGP):

2337

# ...return invalid data

2338

return b""

2026

if (gnutls.library.functions.gnutls_certificate_type_get(

2027

session._c_object)

2028

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

2029

# ...do the normal thing

2030

return session.peer_certificate

2339

2031

list_size = ctypes.c_uint(1)

2340

cert_list = (gnutls.certificate_get_peers

2032

cert_list = (gnutls.library.functions

2033

.gnutls_certificate_get_peers

2341

2034

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

2342

2035

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

2343

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

2036

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

2037

" certificate")

2344

2038

if list_size.value == 0:

2345

2039

return None

2346

2040

cert = cert_list[0]

2347

2041

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

2348

2042

2349

2043

@staticmethod

2350

2044

def fingerprint(openpgp):

2351

2045

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2352

2046

# New GnuTLS "datum" with the OpenPGP public key

2353

datum = gnutls.datum_t(

2047

datum = gnutls.library.types.gnutls_datum_t(

2354

2048

ctypes.cast(ctypes.c_char_p(openpgp),

2355

2049

ctypes.POINTER(ctypes.c_ubyte)),

2356

2050

ctypes.c_uint(len(openpgp)))

2357

2051

# New empty GnuTLS certificate

2358

crt = gnutls.openpgp_crt_t()

2359

gnutls.openpgp_crt_init(ctypes.byref(crt))

2052

crt = gnutls.library.types.gnutls_openpgp_crt_t()

2053

gnutls.library.functions.gnutls_openpgp_crt_init(

2054

ctypes.byref(crt))

2360

2055

# Import the OpenPGP public key into the certificate

2361

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

2362

gnutls.OPENPGP_FMT_RAW)

2056

gnutls.library.functions.gnutls_openpgp_crt_import(

2057

crt, ctypes.byref(datum),

2058

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

2363

2059

# Verify the self signature in the key

2364

2060

crtverify = ctypes.c_uint()

2365

gnutls.openpgp_crt_verify_self(crt, 0,

2366

ctypes.byref(crtverify))

2061

gnutls.library.functions.gnutls_openpgp_crt_verify_self(

2062

crt, 0, ctypes.byref(crtverify))

2367

2063

if crtverify.value != 0:

2368

gnutls.openpgp_crt_deinit(crt)

2369

raise gnutls.CertificateSecurityError("Verify failed")

2064

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2065

raise gnutls.errors.CertificateSecurityError(

2066

"Verify failed")

2370

2067

# New buffer for the fingerprint

2371

2068

buf = ctypes.create_string_buffer(20)

2372

2069

buf_len = ctypes.c_size_t()

2373

2070

# Get the fingerprint from the certificate into the buffer

2374

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

2375

ctypes.byref(buf_len))

2071

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(

2072

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

2376

2073

# Deinit the certificate

2377

gnutls.openpgp_crt_deinit(crt)

2074

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2378

2075

# Convert the buffer to a Python bytestring

2379

2076

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

2380

2077

# Convert the bytestring to hexadecimal notation

2384

2081

2385

2082

class MultiprocessingMixIn(object):

2386

2083

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

2387

2084

2388

2085

def sub_process_main(self, request, address):

2389

2086

try:

2390

2087

self.finish_request(request, address)

2391

2088

except Exception:

2392

2089

self.handle_error(request, address)

2393

2090

self.close_request(request)

2394

2091

2395

2092

def process_request(self, request, address):

2396

2093

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

2397

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

2398

args=(request, address))

2094

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

2095

args = (request, address))

2399

2096

proc.start()

2400

2097

return proc

2401

2098

2402

2099

2403

2100

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2404

2101

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

2405

2102

2406

2103

def process_request(self, request, client_address):

2407

2104

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

2408

2105

2409

2106

This function creates a new pipe in self.pipe

2410

2107

"""

2411

2108

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2412

2109

2413

2110

proc = MultiprocessingMixIn.process_request(self, request,

2414

2111

client_address)

2415

2112

self.child_pipe.close()

2416

2113

self.add_pipe(parent_pipe, proc)

2417

2114

2418

2115

def add_pipe(self, parent_pipe, proc):

2419

2116

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

2420

2117

raise NotImplementedError()

2423

2120

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2424

2121

socketserver.TCPServer, object):

2425

2122

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

2426

2123

2427

2124

Attributes:

2428

2125

enabled: Boolean; whether this server is activated yet

2429

2126

interface: None or a network interface name (string)

2430

2127

use_ipv6: Boolean; to use IPv6 or not

2431

2128

"""

2432

2129

2433

2130

def __init__(self, server_address, RequestHandlerClass,

2434

2131

interface=None,

2435

2132

use_ipv6=True,

2445

2142

self.socketfd = socketfd

2446

2143

# Save the original socket.socket() function

2447

2144

self.socket_socket = socket.socket

2448

2449

2145

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

2450

#

2146

#

2451

2147

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

2452

2148

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

2453

2149

# patching socket.socket.)

2454

#

2150

#

2455

2151

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

2456

2152

@functools.wraps(socket.socket)

2457

2153

def socket_wrapper(*args, **kwargs):

2469

2165

# socket_wrapper(), if socketfd was set.

2470

2166

socketserver.TCPServer.__init__(self, server_address,

2471

2167

RequestHandlerClass)

2472

2168

2473

2169

def server_bind(self):

2474

2170

"""This overrides the normal server_bind() function

2475

2171

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

2476

2172

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

2477

global SO_BINDTODEVICE

2478

2173

if self.interface is not None:

2479

2174

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

2175

logger.error("SO_BINDTODEVICE does not exist;"

2176

" cannot bind to interface %s",

2177

self.interface)

2178

else:

2179

try:

2180

self.socket.setsockopt(

2181

socket.SOL_SOCKET, SO_BINDTODEVICE,

2182

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

2183

except socket.error as error:

2184

if error.errno == errno.EPERM:

2185

logger.error("No permission to bind to"

2186

" interface %s", self.interface)

2187

elif error.errno == errno.ENOPROTOOPT:

2188

logger.error("SO_BINDTODEVICE not available;"

2189

" cannot bind to interface %s",

2190

self.interface)

2191

elif error.errno == errno.ENODEV:

2192

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

2193

" cannot bind", self.interface)

2194

else:

2195

raise

2501

2196

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

2502

2197

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

2503

2198

if not self.server_address[0]:

2504

2199

if self.address_family == socket.AF_INET6:

2505

any_address = "::" # in6addr_any

2200

any_address = "::" # in6addr_any

2506

2201

else:

2507

any_address = "0.0.0.0" # INADDR_ANY

2202

any_address = "0.0.0.0" # INADDR_ANY

2508

2203

self.server_address = (any_address,

2509

2204

self.server_address[1])

2510

2205

elif not self.server_address[1]:

2520

2215

2521

2216

class MandosServer(IPv6_TCPServer):

2522

2217

"""Mandos server.

2523

2218

2524

2219

Attributes:

2525

2220

clients: set of Client objects

2526

2221

gnutls_priority GnuTLS priority string

2527

2222

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

2528

2529

Assumes a GLib.MainLoop event loop.

2223

2224

Assumes a gobject.MainLoop event loop.

2530

2225

"""

2531

2226

2532

2227

def __init__(self, server_address, RequestHandlerClass,

2533

2228

interface=None,

2534

2229

use_ipv6=True,

2544

2239

self.gnutls_priority = gnutls_priority

2545

2240

IPv6_TCPServer.__init__(self, server_address,

2546

2241

RequestHandlerClass,

2547

interface=interface,

2548

use_ipv6=use_ipv6,

2549

socketfd=socketfd)

2550

2242

interface = interface,

2243

use_ipv6 = use_ipv6,

2244

socketfd = socketfd)

2245

2551

2246

def server_activate(self):

2552

2247

if self.enabled:

2553

2248

return socketserver.TCPServer.server_activate(self)

2554

2249

2555

2250

def enable(self):

2556

2251

self.enabled = True

2557

2252

2558

2253

def add_pipe(self, parent_pipe, proc):

2559

2254

# Call "handle_ipc" for both data and EOF events

2560

GLib.io_add_watch(

2255

gobject.io_add_watch(

2561

2256

parent_pipe.fileno(),

2562

GLib.IO_IN | GLib.IO_HUP,

2257

gobject.IO_IN | gobject.IO_HUP,

2563

2258

functools.partial(self.handle_ipc,

2564

parent_pipe=parent_pipe,

2565

proc=proc))

2566

2259

parent_pipe = parent_pipe,

2260

proc = proc))

2261

2567

2262

def handle_ipc(self, source, condition,

2568

2263

parent_pipe=None,

2569

proc=None,

2264

proc = None,

2570

2265

client_object=None):

2571

2266

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

2572

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

2267

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

2573

2268

# Wait for other process to exit

2574

2269

proc.join()

2575

2270

return False

2576

2271

2577

2272

# Read a request from the child

2578

2273

request = parent_pipe.recv()

2579

2274

command = request[0]

2580

2275

2581

2276

if command == 'init':

2582

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

2277

fpr = request[1]

2583

2278

address = request[2]

2584

2585

for c in self.clients.values():

2279

2280

for c in self.clients.itervalues():

2586

2281

if c.fingerprint == fpr:

2587

2282

client = c

2588

2283

break

2595

2290

address[0])

2596

2291

parent_pipe.send(False)

2597

2292

return False

2598

2599

GLib.io_add_watch(

2293

2294

gobject.io_add_watch(

2600

2295

parent_pipe.fileno(),

2601

GLib.IO_IN | GLib.IO_HUP,

2296

gobject.IO_IN | gobject.IO_HUP,

2602

2297

functools.partial(self.handle_ipc,

2603

parent_pipe=parent_pipe,

2604

proc=proc,

2605

client_object=client))

2298

parent_pipe = parent_pipe,

2299

proc = proc,

2300

client_object = client))

2606

2301

parent_pipe.send(True)

2607

2302

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

2608

2303

# same fileno

2611

2306

funcname = request[1]

2612

2307

args = request[2]

2613

2308

kwargs = request[3]

2614

2309

2615

2310

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

2616

2311

funcname)(*args,

2617

2312

**kwargs)))

2618

2313

2619

2314

if command == 'getattr':

2620

2315

attrname = request[1]

2621

2316

if isinstance(client_object.__getattribute__(attrname),

2624

2319

else:

2625

2320

parent_pipe.send((

2626

2321

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

2627

2322

2628

2323

if command == 'setattr':

2629

2324

attrname = request[1]

2630

2325

value = request[2]

2631

2326

setattr(client_object, attrname, value)

2632

2327

2633

2328

return True

2634

2329

2635

2330

2636

2331

def rfc3339_duration_to_delta(duration):

2637

2332

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

2638

2333

2639

2334

>>> rfc3339_duration_to_delta("P7D")

2640

2335

datetime.timedelta(7)

2641

2336

>>> rfc3339_duration_to_delta("PT60S")

2651

2346

>>> rfc3339_duration_to_delta("P1DT3M20S")

2652

2347

datetime.timedelta(1, 200)

2653

2348

"""

2654

2349

2655

2350

# Parsing an RFC 3339 duration with regular expressions is not

2656

2351

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

2657

2352

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

2658

2353

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

2659

2354

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

2660

2355

# avoid excessive use of external libraries.

2661

2356

2662

2357

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

2663

2358

Token = collections.namedtuple("Token", (

2664

2359

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

2697

2392

frozenset((token_year, token_month,

2698

2393

token_day, token_time,

2699

2394

token_week)))

2700

# Define starting values:

2701

# Value so far

2702

value = datetime.timedelta()

2395

# Define starting values

2396

value = datetime.timedelta() # Value so far

2703

2397

found_token = None

2704

# Following valid tokens

2705

followers = frozenset((token_duration, ))

2706

# String left to parse

2707

s = duration

2398

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

2399

s = duration # String left to parse

2708

2400

# Loop until end token is found

2709

2401

while found_token is not token_end:

2710

2402

# Search for any currently valid tokens

2734

2426

2735

2427

def string_to_delta(interval):

2736

2428

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

2737

2429

2738

2430

>>> string_to_delta('7d')

2739

2431

datetime.timedelta(7)

2740

2432

>>> string_to_delta('60s')

2748

2440

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

2749

2441

datetime.timedelta(0, 330)

2750

2442

"""

2751

2443

2752

2444

try:

2753

2445

return rfc3339_duration_to_delta(interval)

2754

2446

except ValueError:

2755

2447

pass

2756

2448

2757

2449

timevalue = datetime.timedelta(0)

2758

2450

for s in interval.split():

2759

2451

try:

2777

2469

return timevalue

2778

2470

2779

2471

2780

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

2472

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

2781

2473

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

2782

2474

2783

2475

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

2784

2476

if os.fork():

2785

2477

sys.exit()

2803

2495

2804

2496

2805

2497

def main():

2806

2498

2807

2499

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

2808

2500

# Parsing of options, both command line and config file

2809

2501

2810

2502

parser = argparse.ArgumentParser()

2811

2503

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

2812

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

2504

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

2813

2505

help="show version number and exit")

2814

2506

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

2815

2507

help="Bind to interface IF")

2851

2543

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

2852

2544

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

2853

2545

default=None)

2854

2546

2855

2547

options = parser.parse_args()

2856

2548

2857

2549

if options.check:

2858

2550

import doctest

2859

2551

fail_count, test_count = doctest.testmod()

2860

2552

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

2861

2553

2862

2554

# 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

2555

server_defaults = { "interface": "",

2556

"address": "",

2557

"port": "",

2558

"debug": "False",

2559

"priority":

2560

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

2561

":+SIGN-DSA-SHA256",

2562

"servicename": "Mandos",

2563

"use_dbus": "True",

2564

"use_ipv6": "True",

2565

"debuglevel": "",

2566

"restore": "True",

2567

"socket": "",

2568

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

2569

"foreground": "False",

2570

"zeroconf": "True",

2571

}

2572

2881

2573

# Parse config file for server-global settings

2882

2574

server_config = configparser.SafeConfigParser(server_defaults)

2883

2575

del server_defaults

2885

2577

# Convert the SafeConfigParser object to a dict

2886

2578

server_settings = server_config.defaults()

2887

2579

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

2888

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

2889

"foreground", "zeroconf"):

2580

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

2890

2581

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

2891

2582

option)

2892

2583

if server_settings["port"]:

2902

2593

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

2903

2594

["socket"])

2904

2595

del server_config

2905

2596

2906

2597

# Override the settings from the config file with command line

2907

2598

# options, if set.

2908

2599

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

2926

2617

if server_settings["debug"]:

2927

2618

server_settings["foreground"] = True

2928

2619

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

2929

2620

2930

2621

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

2931

2622

2932

2623

if (not server_settings["zeroconf"]

2933

2624

and not (server_settings["port"]

2934

2625

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

2935

2626

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

2936

2627

2937

2628

# For convenience

2938

2629

debug = server_settings["debug"]

2939

2630

debuglevel = server_settings["debuglevel"]

2943

2634

stored_state_file)

2944

2635

foreground = server_settings["foreground"]

2945

2636

zeroconf = server_settings["zeroconf"]

2946

2637

2947

2638

if debug:

2948

2639

initlogger(debug, logging.DEBUG)

2949

2640

else:

2952

2643

else:

2953

2644

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

2954

2645

initlogger(debug, level)

2955

2646

2956

2647

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

2957

2648

syslogger.setFormatter(

2958

2649

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

2959

2650

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

2960

2651

server_settings["servicename"])))

2961

2652

2962

2653

# Parse config file with clients

2963

2654

client_config = configparser.SafeConfigParser(Client

2964

2655

.client_defaults)

2965

2656

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

2966

2657

"clients.conf"))

2967

2658

2968

2659

global mandos_dbus_service

2969

2660

mandos_dbus_service = None

2970

2661

2971

2662

socketfd = None

2972

2663

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

2973

2664

socketfd = server_settings["socket"]

2989

2680

except IOError as e:

2990

2681

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

2991

2682

exc_info=e)

2992

2993

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

2994

("mandos", "mandos"),

2995

("nobody", "nogroup")):

2683

2684

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

2996

2685

try:

2997

2686

uid = pwd.getpwnam(name).pw_uid

2998

gid = pwd.getpwnam(group).pw_gid

2687

gid = pwd.getpwnam(name).pw_gid

2999

2688

break

3000

2689

except KeyError:

3001

2690

continue

3005

2694

try:

3006

2695

os.setgid(gid)

3007

2696

os.setuid(uid)

3008

if debug:

3009

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

3010

gid))

3011

2697

except OSError as error:

3012

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

3013

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

3014

2698

if error.errno != errno.EPERM:

3015

2699

raise

3016

2700

3017

2701

if debug:

3018

2702

# Enable all possible GnuTLS debugging

3019

2703

3020

2704

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

3021

2705

# - GnuTLS manual

3022

gnutls.global_set_log_level(11)

3023

3024

@gnutls.log_func

2706

gnutls.library.functions.gnutls_global_set_log_level(11)

2707

2708

@gnutls.library.types.gnutls_log_func

3025

2709

def debug_gnutls(level, string):

3026

2710

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

3027

3028

gnutls.global_set_log_function(debug_gnutls)

3029

2711

2712

gnutls.library.functions.gnutls_global_set_log_function(

2713

debug_gnutls)

2714

3030

2715

# Redirect stdin so all checkers get /dev/null

3031

2716

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

3032

2717

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

3033

2718

if null > 2:

3034

2719

os.close(null)

3035

2720

3036

2721

# Need to fork before connecting to D-Bus

3037

2722

if not foreground:

3038

2723

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

3039

2724

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

2725

2726

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

2727

# need to inform gobject that threads will be used.

2728

gobject.threads_init()

2729

3045

2730

global main_loop

3046

2731

# From the Avahi example code

3047

2732

DBusGMainLoop(set_as_default=True)

3048

main_loop = GLib.MainLoop()

2733

main_loop = gobject.MainLoop()

3049

2734

bus = dbus.SystemBus()

3050

2735

# End of Avahi example code

3051

2736

if use_dbus:

3064

2749

if zeroconf:

3065

2750

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3066

2751

service = AvahiServiceToSyslog(

3067

name=server_settings["servicename"],

3068

servicetype="_mandos._tcp",

3069

protocol=protocol,

3070

bus=bus)

2752

name = server_settings["servicename"],

2753

servicetype = "_mandos._tcp",

2754

protocol = protocol,

2755

bus = bus)

3071

2756

if server_settings["interface"]:

3072

2757

service.interface = if_nametoindex(

3073

2758

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

3074

2759

3075

2760

global multiprocessing_manager

3076

2761

multiprocessing_manager = multiprocessing.Manager()

3077

2762

3078

2763

client_class = Client

3079

2764

if use_dbus:

3080

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

3081

2765

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

2766

3082

2767

client_settings = Client.config_parser(client_config)

3083

2768

old_client_settings = {}

3084

2769

clients_data = {}

3085

2770

3086

2771

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

3087

2772

global wnull

3088

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

2773

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

3089

2774

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

3090

2775

# mode

3091

2776

if debug or not foreground:

3092

2777

wnull.close()

3093

2778

3094

2779

# Get client data and settings from last running state.

3095

2780

if server_settings["restore"]:

3096

2781

try:

3097

2782

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

2783

clients_data, old_client_settings = pickle.load(

2784

stored_state)

3143

2785

os.remove(stored_state_path)

3144

2786

except IOError as e:

3145

2787

if e.errno == errno.ENOENT:

3153

2795

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

3154

2796

"EOFError:",

3155

2797

exc_info=e)

3156

2798

3157

2799

with PGPEngine() as pgp:

3158

2800

for client_name, client in clients_data.items():

3159

2801

# Skip removed clients

3160

2802

if client_name not in client_settings:

3161

2803

continue

3162

2804

3163

2805

# Decide which value to use after restoring saved state.

3164

2806

# We have three different values: Old config file,

3165

2807

# new config file, and saved state.

3176

2818

client[name] = value

3177

2819

except KeyError:

3178

2820

pass

3179

2821

3180

2822

# Clients who has passed its expire date can still be

3181

2823

# enabled if its last checker was successful. A Client

3182

2824

# whose checker succeeded before we stored its state is

3215

2857

client_name))

3216

2858

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

3217

2859

["secret"])

3218

2860

3219

2861

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

3220

2862

for client_name in (set(old_client_settings)

3221

2863

- set(client_settings)):

3223

2865

for client_name in (set(client_settings)

3224

2866

- set(old_client_settings)):

3225

2867

clients_data[client_name] = client_settings[client_name]

3226

2868

3227

2869

# Create all client objects

3228

2870

for client_name, client in clients_data.items():

3229

2871

tcp_server.clients[client_name] = client_class(

3230

name=client_name,

3231

settings=client,

3232

server_settings=server_settings)

3233

2872

name = client_name,

2873

settings = client,

2874

server_settings = server_settings)

2875

3234

2876

if not tcp_server.clients:

3235

2877

logger.warning("No clients defined")

3236

2878

3237

2879

if not foreground:

3238

2880

if pidfile is not None:

3239

2881

pid = os.getpid()

3245

2887

pidfilename, pid)

3246

2888

del pidfile

3247

2889

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

2890

2891

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

2892

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

2893

3253

2894

if use_dbus:

3254

2895

3255

2896

@alternate_dbus_interfaces(

3256

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

2897

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

3257

2898

class MandosDBusService(DBusObjectWithObjectManager):

3258

2899

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

3259

2900

3260

2901

def __init__(self):

3261

2902

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

3262

2903

3263

2904

_interface = "se.recompile.Mandos"

3264

2905

3265

2906

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

3266

2907

def ClientAdded(self, objpath):

3267

2908

"D-Bus signal"

3268

2909

pass

3269

2910

3270

2911

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

3271

2912

def ClientNotFound(self, fingerprint, address):

3272

2913

"D-Bus signal"

3273

2914

pass

3274

2915

3275

2916

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

3276

2917

"true"})

3277

2918

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

3278

2919

def ClientRemoved(self, objpath, name):

3279

2920

"D-Bus signal"

3280

2921

pass

3281

2922

3282

2923

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

3283

2924

"true"})

3284

2925

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

3285

2926

def GetAllClients(self):

3286

2927

"D-Bus method"

3287

2928

return dbus.Array(c.dbus_object_path for c in

3288

tcp_server.clients.values())

3289

2929

tcp_server.clients.itervalues())

2930

3290

2931

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

3291

2932

"true"})

3292

2933

@dbus.service.method(_interface,

3294

2935

def GetAllClientsWithProperties(self):

3295

2936

"D-Bus method"

3296

2937

return dbus.Dictionary(

3297

{c.dbus_object_path: c.GetAll(

2938

{ c.dbus_object_path: c.GetAll(

3298

2939

"se.recompile.Mandos.Client")

3299

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

2940

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

3300

2941

signature="oa{sv}")

3301

2942

3302

2943

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

3303

2944

def RemoveClient(self, object_path):

3304

2945

"D-Bus method"

3305

for c in tcp_server.clients.values():

2946

for c in tcp_server.clients.itervalues():

3306

2947

if c.dbus_object_path == object_path:

3307

2948

del tcp_server.clients[c.name]

3308

2949

c.remove_from_connection()

3312

2953

self.client_removed_signal(c)

3313

2954

return

3314

2955

raise KeyError(object_path)

3315

2956

3316

2957

del _interface

3317

2958

3318

2959

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3319

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

2960

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

3320

2961

def GetManagedObjects(self):

3321

2962

"""D-Bus method"""

3322

2963

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

2964

{ client.dbus_object_path:

2965

dbus.Dictionary(

2966

{ interface: client.GetAll(interface)

2967

for interface in

2968

client._get_all_interface_names()})

2969

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

2970

3330

2971

def client_added_signal(self, client):

3331

2972

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

3332

2973

if use_dbus:

3334

2975

self.InterfacesAdded(

3335

2976

client.dbus_object_path,

3336

2977

dbus.Dictionary(

3337

{interface: client.GetAll(interface)

3338

for interface in

3339

client._get_all_interface_names()}))

2978

{ interface: client.GetAll(interface)

2979

for interface in

2980

client._get_all_interface_names()}))

3340

2981

# Old signal

3341

2982

self.ClientAdded(client.dbus_object_path)

3342

2983

3343

2984

def client_removed_signal(self, client):

3344

2985

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

3345

2986

if use_dbus:

3350

2991

# Old signal

3351

2992

self.ClientRemoved(client.dbus_object_path,

3352

2993

client.name)

3353

2994

3354

2995

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

2996

3361

2997

def cleanup():

3362

2998

"Cleanup function; run on exit"

3363

2999

if zeroconf:

3364

3000

service.cleanup()

3365

3366

mp.active_children()

3367

wn.close()

3001

3002

multiprocessing.active_children()

3003

wnull.close()

3368

3004

if not (tcp_server.clients or client_settings):

3369

3005

return

3370

3006

3371

3007

# Store client before exiting. Secrets are encrypted with key

3372

3008

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

3373

3009

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

3374

3010

clients = {}

3375

3011

with PGPEngine() as pgp:

3376

for client in tcp_server.clients.values():

3012

for client in tcp_server.clients.itervalues():

3377

3013

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

3378

3014

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

3379

3015

key)

3380

3016

client_dict = {}

3381

3017

3382

3018

# A list of attributes that can not be pickled

3383

3019

# + secret.

3384

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

3385

"checker", "server_settings"}

3020

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

3021

"checker", "server_settings" }

3386

3022

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

3387

3023

.Object):

3388

3024

exclude.add(name)

3389

3025

3390

3026

client_dict["encrypted_secret"] = (client

3391

3027

.encrypted_secret)

3392

3028

for attr in client.client_structure:

3393

3029

if attr not in exclude:

3394

3030

client_dict[attr] = getattr(client, attr)

3395

3031

3396

3032

clients[client.name] = client_dict

3397

3033

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

3398

3034

3399

3035

try:

3400

3036

with tempfile.NamedTemporaryFile(

3401

3037

mode='wb',

3403

3039

prefix='clients-',

3404

3040

dir=os.path.dirname(stored_state_path),

3405

3041

delete=False) as stored_state:

3406

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

3407

protocol=2)

3042

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

3408

3043

tempname = stored_state.name

3409

3044

os.rename(tempname, stored_state_path)

3410

3045

except (IOError, OSError) as e:

3420

3055

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

3421

3056

exc_info=e)

3422

3057

raise

3423

3058

3424

3059

# Delete all clients, and settings from config

3425

3060

while tcp_server.clients:

3426

3061

name, client = tcp_server.clients.popitem()

3429

3064

# Don't signal the disabling

3430

3065

client.disable(quiet=True)

3431

3066

# Emit D-Bus signal for removal

3432

if use_dbus:

3433

mandos_dbus_service.client_removed_signal(client)

3067

mandos_dbus_service.client_removed_signal(client)

3434

3068

client_settings.clear()

3435

3069

3436

3070

atexit.register(cleanup)

3437

3438

for client in tcp_server.clients.values():

3071

3072

for client in tcp_server.clients.itervalues():

3439

3073

if use_dbus:

3440

3074

# Emit D-Bus signal for adding

3441

3075

mandos_dbus_service.client_added_signal(client)

3442

3076

# Need to initiate checking of clients

3443

3077

if client.enabled:

3444

3078

client.init_checker()

3445

3079

3446

3080

tcp_server.enable()

3447

3081

tcp_server.server_activate()

3448

3082

3449

3083

# Find out what port we got

3450

3084

if zeroconf:

3451

3085

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

3456

3090

else: # IPv4

3457

3091

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

3458

3092

*tcp_server.socket.getsockname())

3459

3460

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

3461

3093

3094

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

3095

3462

3096

try:

3463

3097

if zeroconf:

3464

3098

# From the Avahi example code

3469

3103

cleanup()

3470

3104

sys.exit(1)

3471

3105

# 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

3106

3107

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

3108

lambda *args, **kwargs:

3109

(tcp_server.handle_request

3110

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

3111

3478

3112

logger.debug("Starting main loop")

3479

3113

main_loop.run()

3480

3114

except AvahiError as error: