/mandos/release : revision 237.7.502

1

#!/usr/bin/python2.7

1

#!/usr/bin/python

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 program is free software: you can redistribute it and/or modify

18

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

14

15

16

#

17

# This file is part of Mandos.

18

#

19

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

20

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

19

21

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

20

22

# (at your option) any later version.

21

23

#

22

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

23

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

24

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

25

# WITHOUT ANY WARRANTY; without even the implied warranty of

24

26

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

25

27

# GNU General Public License for more details.

26

#

28

#

27

29

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

28

# along with this program. If not, see

29

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

30

#

30

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

31

#

31

32

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

32

#

33

#

33

34

35

from __future__ import (division, absolute_import, print_function,

35

36

unicode_literals)

36

37

from future_builtins import *

38

try:

39

from future_builtins import *

40

except ImportError:

41

pass

38

42

39

43

try:

40

44

import SocketServer as socketserver

44

48

import argparse

45

49

import datetime

46

50

import errno

47

import gnutls.connection

48

import gnutls.errors

49

import gnutls.library.functions

50

import gnutls.library.constants

51

import gnutls.library.types

52

51

try:

53

52

import ConfigParser as configparser

54

53

except ImportError:

81

80

82

81

import dbus

83

82

import dbus.service

84

try:

85

import gobject

86

except ImportError:

87

from gi.repository import GObject as gobject

88

import avahi

83

from gi.repository import GLib

89

84

from dbus.mainloop.glib import DBusGMainLoop

90

85

import ctypes

91

86

import ctypes.util

92

87

import xml.dom.minidom

93

88

import inspect

94

89

90

# Try to find the value of SO_BINDTODEVICE:

95

91

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:

96

94

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

97

95

except AttributeError:

98

96

try:

97

# This is where SO_BINDTODEVICE was up to and including Python

98

# 2.6, and also 3.2:

99

from IN import SO_BINDTODEVICE

100

except ImportError:

101

SO_BINDTODEVICE = None

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

114

103

115

if sys.version_info.major == 2:

104

116

str = unicode

105

117

106

version = "1.7.1"

118

version = "1.7.19"

107

119

stored_state_file = "clients.pickle"

108

120

109

121

logger = logging.getLogger()

113

125

if_nametoindex = ctypes.cdll.LoadLibrary(

114

126

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

115

127

except (OSError, AttributeError):

116

128

117

129

def if_nametoindex(interface):

118

130

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

119

131

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

124

136

return interface_index

125

137

126

138

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

127

155

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

128

156

"""init logger and add loglevel"""

129

157

130

158

global syslogger

131

159

syslogger = (logging.handlers.SysLogHandler(

132

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

133

address = "/dev/log"))

160

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

161

address="/dev/log"))

134

162

syslogger.setFormatter(logging.Formatter

135

163

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

136

164

' %(message)s'))

137

165

logger.addHandler(syslogger)

138

166

139

167

if debug:

140

168

console = logging.StreamHandler()

141

169

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

153

181

154

182

class PGPEngine(object):

155

183

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

156

184

157

185

def __init__(self):

158

186

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

159

198

self.gnupgargs = ['--batch',

160

'--home', self.tempdir,

199

'--homedir', self.tempdir,

161

200

'--force-mdc',

162

'--quiet',

163

'--no-use-agent']

164

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

165

206

def __enter__(self):

166

207

return self

167

208

168

209

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

169

210

self._cleanup()

170

211

return False

171

212

172

213

def __del__(self):

173

214

self._cleanup()

174

215

175

216

def _cleanup(self):

176

217

if self.tempdir is not None:

177

218

# Delete contents of tempdir

178

219

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

179

topdown = False):

220

topdown=False):

180

221

for filename in files:

181

222

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

182

223

for dirname in dirs:

184

225

# Remove tempdir

185

226

os.rmdir(self.tempdir)

186

227

self.tempdir = None

187

228

188

229

def password_encode(self, password):

189

230

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

190

231

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

195

236

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

196

237

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

197

238

return encoded

198

239

199

240

def encrypt(self, data, password):

200

241

passphrase = self.password_encode(password)

201

242

with tempfile.NamedTemporaryFile(

202

243

dir=self.tempdir) as passfile:

203

244

passfile.write(passphrase)

204

245

passfile.flush()

205

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

246

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

206

247

'--passphrase-file',

207

248

passfile.name]

208

249

+ self.gnupgargs,

209

stdin = subprocess.PIPE,

210

stdout = subprocess.PIPE,

211

stderr = subprocess.PIPE)

212

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

250

stdin=subprocess.PIPE,

251

stdout=subprocess.PIPE,

252

stderr=subprocess.PIPE)

253

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

213

254

if proc.returncode != 0:

214

255

raise PGPError(err)

215

256

return ciphertext

216

257

217

258

def decrypt(self, data, password):

218

259

passphrase = self.password_encode(password)

219

260

with tempfile.NamedTemporaryFile(

220

dir = self.tempdir) as passfile:

261

dir=self.tempdir) as passfile:

221

262

passfile.write(passphrase)

222

263

passfile.flush()

223

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

264

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

224

265

'--passphrase-file',

225

266

passfile.name]

226

267

+ self.gnupgargs,

227

stdin = subprocess.PIPE,

228

stdout = subprocess.PIPE,

229

stderr = subprocess.PIPE)

230

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

268

stdin=subprocess.PIPE,

269

stdout=subprocess.PIPE,

270

stderr=subprocess.PIPE)

271

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

231

272

if proc.returncode != 0:

232

273

raise PGPError(err)

233

274

return decrypted_plaintext

234

275

235

276

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

236

304

class AvahiError(Exception):

237

305

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

238

306

self.value = value

250

318

251

319

class AvahiService(object):

252

320

"""An Avahi (Zeroconf) service.

253

321

254

322

Attributes:

255

323

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

256

324

Used to optionally bind to the specified interface.

268

336

server: D-Bus Server

269

337

bus: dbus.SystemBus()

270

338

"""

271

339

272

340

def __init__(self,

273

interface = avahi.IF_UNSPEC,

274

name = None,

275

servicetype = None,

276

port = None,

277

TXT = None,

278

domain = "",

279

host = "",

280

max_renames = 32768,

281

protocol = avahi.PROTO_UNSPEC,

282

bus = None):

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

283

351

self.interface = interface

284

352

self.name = name

285

353

self.type = servicetype

294

362

self.server = None

295

363

self.bus = bus

296

364

self.entry_group_state_changed_match = None

297

365

298

366

def rename(self, remove=True):

299

367

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

300

368

if self.rename_count >= self.max_renames:

320

388

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

321

389

self.cleanup()

322

390

os._exit(1)

323

391

324

392

def remove(self):

325

393

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

326

394

if self.entry_group_state_changed_match is not None:

328

396

self.entry_group_state_changed_match = None

329

397

if self.group is not None:

330

398

self.group.Reset()

331

399

332

400

def add(self):

333

401

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

334

402

self.remove()

351

419

dbus.UInt16(self.port),

352

420

avahi.string_array_to_txt_array(self.TXT))

353

421

self.group.Commit()

354

422

355

423

def entry_group_state_changed(self, state, error):

356

424

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

357

425

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

358

426

359

427

if state == avahi.ENTRY_GROUP_ESTABLISHED:

360

428

logger.debug("Zeroconf service established.")

361

429

elif state == avahi.ENTRY_GROUP_COLLISION:

365

433

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

366

434

str(error))

367

435

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

368

436

369

437

def cleanup(self):

370

438

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

371

439

if self.group is not None:

376

444

pass

377

445

self.group = None

378

446

self.remove()

379

447

380

448

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

381

449

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

382

450

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

411

479

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

412

480

else:

413

481

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

414

482

415

483

def activate(self):

416

484

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

417

485

if self.server is None:

428

496

class AvahiServiceToSyslog(AvahiService):

429

497

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

430

498

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

431

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

499

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

432

500

syslogger.setFormatter(logging.Formatter(

433

501

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

434

502

.format(self.name)))

435

503

return ret

436

504

505

506

# Pretend that we have a GnuTLS module

507

class GnuTLS(object):

508

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

509

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

510

511

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

512

if library is None:

513

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

514

_library = ctypes.cdll.LoadLibrary(library)

515

del library

516

_need_version = b"3.3.0"

517

518

def __init__(self):

519

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

520

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

521

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

522

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

523

.format(self._need_version))

524

525

# Unless otherwise indicated, the constants and types below are

526

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

527

528

# Constants

529

E_SUCCESS = 0

530

E_INTERRUPTED = -52

531

E_AGAIN = -28

532

CRT_OPENPGP = 2

533

CLIENT = 2

534

SHUT_RDWR = 0

535

CRD_CERTIFICATE = 1

536

E_NO_CERTIFICATE_FOUND = -49

537

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

538

539

# Types

540

class session_int(ctypes.Structure):

541

_fields_ = []

542

session_t = ctypes.POINTER(session_int)

543

544

class certificate_credentials_st(ctypes.Structure):

545

_fields_ = []

546

certificate_credentials_t = ctypes.POINTER(

547

certificate_credentials_st)

548

certificate_type_t = ctypes.c_int

549

550

class datum_t(ctypes.Structure):

551

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

552

('size', ctypes.c_uint)]

553

554

class openpgp_crt_int(ctypes.Structure):

555

_fields_ = []

556

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

557

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

558

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

559

credentials_type_t = ctypes.c_int

560

transport_ptr_t = ctypes.c_void_p

561

close_request_t = ctypes.c_int

562

563

# Exceptions

564

class Error(Exception):

565

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

566

# exception might be raised from within GnuTLS.__init__,

567

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

568

# global variable has happened.

569

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

570

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

571

# code is passed, convert it to a string with

572

# gnutls.strerror()

573

self.code = code

574

if message is None and code is not None:

575

message = GnuTLS.strerror(code)

576

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

577

message, *args)

578

579

class CertificateSecurityError(Error):

580

pass

581

582

# Classes

583

class Credentials(object):

584

def __init__(self):

585

self._c_object = gnutls.certificate_credentials_t()

586

gnutls.certificate_allocate_credentials(

587

ctypes.byref(self._c_object))

588

self.type = gnutls.CRD_CERTIFICATE

589

590

def __del__(self):

591

gnutls.certificate_free_credentials(self._c_object)

592

593

class ClientSession(object):

594

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

595

self._c_object = gnutls.session_t()

596

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

597

gnutls.set_default_priority(self._c_object)

598

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

599

gnutls.handshake_set_private_extensions(self._c_object,

600

True)

601

self.socket = socket

602

if credentials is None:

603

credentials = gnutls.Credentials()

604

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

605

ctypes.cast(credentials._c_object,

606

ctypes.c_void_p))

607

self.credentials = credentials

608

609

def __del__(self):

610

gnutls.deinit(self._c_object)

611

612

def handshake(self):

613

return gnutls.handshake(self._c_object)

614

615

def send(self, data):

616

data = bytes(data)

617

data_len = len(data)

618

while data_len > 0:

619

data_len -= gnutls.record_send(self._c_object,

620

data[-data_len:],

621

data_len)

622

623

def bye(self):

624

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

625

626

# Error handling functions

627

def _error_code(result):

628

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

629

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

630

if result >= 0:

631

return result

632

if result == gnutls.E_NO_CERTIFICATE_FOUND:

633

raise gnutls.CertificateSecurityError(code=result)

634

raise gnutls.Error(code=result)

635

636

def _retry_on_error(result, func, arguments):

637

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

638

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

639

while result < 0:

640

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

641

return _error_code(result)

642

result = func(*arguments)

643

return result

644

645

# Unless otherwise indicated, the function declarations below are

646

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

647

648

# Functions

649

priority_set_direct = _library.gnutls_priority_set_direct

650

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

651

ctypes.POINTER(ctypes.c_char_p)]

652

priority_set_direct.restype = _error_code

653

654

init = _library.gnutls_init

655

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

656

init.restype = _error_code

657

658

set_default_priority = _library.gnutls_set_default_priority

659

set_default_priority.argtypes = [session_t]

660

set_default_priority.restype = _error_code

661

662

record_send = _library.gnutls_record_send

663

record_send.argtypes = [session_t, ctypes.c_void_p,

664

ctypes.c_size_t]

665

record_send.restype = ctypes.c_ssize_t

666

record_send.errcheck = _retry_on_error

667

668

certificate_allocate_credentials = (

669

_library.gnutls_certificate_allocate_credentials)

670

certificate_allocate_credentials.argtypes = [

671

ctypes.POINTER(certificate_credentials_t)]

672

certificate_allocate_credentials.restype = _error_code

673

674

certificate_free_credentials = (

675

_library.gnutls_certificate_free_credentials)

676

certificate_free_credentials.argtypes = [

677

certificate_credentials_t]

678

certificate_free_credentials.restype = None

679

680

handshake_set_private_extensions = (

681

_library.gnutls_handshake_set_private_extensions)

682

handshake_set_private_extensions.argtypes = [session_t,

683

ctypes.c_int]

684

handshake_set_private_extensions.restype = None

685

686

credentials_set = _library.gnutls_credentials_set

687

credentials_set.argtypes = [session_t, credentials_type_t,

688

ctypes.c_void_p]

689

credentials_set.restype = _error_code

690

691

strerror = _library.gnutls_strerror

692

strerror.argtypes = [ctypes.c_int]

693

strerror.restype = ctypes.c_char_p

694

695

certificate_type_get = _library.gnutls_certificate_type_get

696

certificate_type_get.argtypes = [session_t]

697

certificate_type_get.restype = _error_code

698

699

certificate_get_peers = _library.gnutls_certificate_get_peers

700

certificate_get_peers.argtypes = [session_t,

701

ctypes.POINTER(ctypes.c_uint)]

702

certificate_get_peers.restype = ctypes.POINTER(datum_t)

703

704

global_set_log_level = _library.gnutls_global_set_log_level

705

global_set_log_level.argtypes = [ctypes.c_int]

706

global_set_log_level.restype = None

707

708

global_set_log_function = _library.gnutls_global_set_log_function

709

global_set_log_function.argtypes = [log_func]

710

global_set_log_function.restype = None

711

712

deinit = _library.gnutls_deinit

713

deinit.argtypes = [session_t]

714

deinit.restype = None

715

716

handshake = _library.gnutls_handshake

717

handshake.argtypes = [session_t]

718

handshake.restype = _error_code

719

handshake.errcheck = _retry_on_error

720

721

transport_set_ptr = _library.gnutls_transport_set_ptr

722

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

723

transport_set_ptr.restype = None

724

725

bye = _library.gnutls_bye

726

bye.argtypes = [session_t, close_request_t]

727

bye.restype = _error_code

728

bye.errcheck = _retry_on_error

729

730

check_version = _library.gnutls_check_version

731

check_version.argtypes = [ctypes.c_char_p]

732

check_version.restype = ctypes.c_char_p

733

734

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

735

736

openpgp_crt_init = _library.gnutls_openpgp_crt_init

737

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

738

openpgp_crt_init.restype = _error_code

739

740

openpgp_crt_import = _library.gnutls_openpgp_crt_import

741

openpgp_crt_import.argtypes = [openpgp_crt_t,

742

ctypes.POINTER(datum_t),

743

openpgp_crt_fmt_t]

744

openpgp_crt_import.restype = _error_code

745

746

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

747

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

748

ctypes.POINTER(ctypes.c_uint)]

749

openpgp_crt_verify_self.restype = _error_code

750

751

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

752

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

753

openpgp_crt_deinit.restype = None

754

755

openpgp_crt_get_fingerprint = (

756

_library.gnutls_openpgp_crt_get_fingerprint)

757

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

758

ctypes.c_void_p,

759

ctypes.POINTER(

760

ctypes.c_size_t)]

761

openpgp_crt_get_fingerprint.restype = _error_code

762

763

# Remove non-public functions

764

del _error_code, _retry_on_error

765

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

766

gnutls = GnuTLS()

767

768

437

769

def call_pipe(connection, # : multiprocessing.Connection

438

770

func, *args, **kwargs):

439

771

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

440

772

441

773

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

442

774

return value on the provided multiprocessing.Connection.

443

775

"""

444

776

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

445

777

connection.close()

446

778

779

447

780

class Client(object):

448

781

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

449

782

450

783

Attributes:

451

784

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

452

785

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

454

787

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

455

788

to see if the client lives.

456

789

'None' if no process is running.

457

checker_callback_tag: a gobject event source tag, or None

790

checker_callback_tag: a GLib event source tag, or None

458

791

checker_command: string; External command which is run to check

459

792

if client lives. %() expansions are done at

460

793

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

461

794

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

462

checker_initiator_tag: a gobject event source tag, or None

795

checker_initiator_tag: a GLib event source tag, or None

463

796

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

464

797

client_structure: Object describing what attributes a client has

465

798

and is used for storing the client at exit

466

799

current_checker_command: string; current running checker_command

467

disable_initiator_tag: a gobject event source tag, or None

800

disable_initiator_tag: a GLib event source tag, or None

468

801

enabled: bool()

469

802

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

470

803

uniquely identify the client

489

822

disabled, or None

490

823

server_settings: The server_settings dict from main()

491

824

"""

492

825

493

826

runtime_expansions = ("approval_delay", "approval_duration",

494

827

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

495

828

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

506

839

"approved_by_default": "True",

507

840

"enabled": "True",

508

841

}

509

842

510

843

@staticmethod

511

844

def config_parser(config):

512

845

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

519

852

for client_name in config.sections():

520

853

section = dict(config.items(client_name))

521

854

client = settings[client_name] = {}

522

855

523

856

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

524

857

# Reformat values from string types to Python types

525

858

client["approved_by_default"] = config.getboolean(

526

859

client_name, "approved_by_default")

527

860

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

528

861

"enabled")

529

862

530

863

# Uppercase and remove spaces from fingerprint for later

531

864

# comparison purposes with return value from the

532

865

# fingerprint() function

533

866

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

534

867

.replace(" ", ""))

535

868

if "secret" in section:

536

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

869

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

870

.encode("utf-8"),

871

"base64")

537

872

elif "secfile" in section:

538

873

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

539

874

(section["secfile"])),

554

889

client["last_approval_request"] = None

555

890

client["last_checked_ok"] = None

556

891

client["last_checker_status"] = -2

557

892

558

893

return settings

559

560

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

894

895

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

561

896

self.name = name

562

897

if server_settings is None:

563

898

server_settings = {}

565

900

# adding all client settings

566

901

for setting, value in settings.items():

567

902

setattr(self, setting, value)

568

903

569

904

if self.enabled:

570

905

if not hasattr(self, "last_enabled"):

571

906

self.last_enabled = datetime.datetime.utcnow()

575

910

else:

576

911

self.last_enabled = None

577

912

self.expires = None

578

913

579

914

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

580

915

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

581

916

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

582

917

datetime.datetime.utcnow())

583

918

584

919

# attributes specific for this server instance

585

920

self.checker = None

586

921

self.checker_initiator_tag = None

592

927

self.changedstate = multiprocessing_manager.Condition(

593

928

multiprocessing_manager.Lock())

594

929

self.client_structure = [attr

595

for attr in self.__dict__.iterkeys()

930

for attr in self.__dict__.keys()

596

931

if not attr.startswith("_")]

597

932

self.client_structure.append("client_structure")

598

933

599

934

for name, t in inspect.getmembers(

600

935

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

601

936

if not name.startswith("_"):

602

937

self.client_structure.append(name)

603

938

604

939

# Send notice to process children that client state has changed

605

940

def send_changedstate(self):

606

941

with self.changedstate:

607

942

self.changedstate.notify_all()

608

943

609

944

def enable(self):

610

945

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

611

946

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

616

951

self.last_enabled = datetime.datetime.utcnow()

617

952

self.init_checker()

618

953

self.send_changedstate()

619

954

620

955

def disable(self, quiet=True):

621

956

"""Disable this client."""

622

957

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

624

959

if not quiet:

625

960

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

626

961

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

627

gobject.source_remove(self.disable_initiator_tag)

962

GLib.source_remove(self.disable_initiator_tag)

628

963

self.disable_initiator_tag = None

629

964

self.expires = None

630

965

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

631

gobject.source_remove(self.checker_initiator_tag)

966

GLib.source_remove(self.checker_initiator_tag)

632

967

self.checker_initiator_tag = None

633

968

self.stop_checker()

634

969

self.enabled = False

635

970

if not quiet:

636

971

self.send_changedstate()

637

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

972

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

638

973

return False

639

974

640

975

def __del__(self):

641

976

self.disable()

642

977

643

978

def init_checker(self):

644

979

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

645

980

# and every interval from then on.

646

981

if self.checker_initiator_tag is not None:

647

gobject.source_remove(self.checker_initiator_tag)

648

self.checker_initiator_tag = gobject.timeout_add(

982

GLib.source_remove(self.checker_initiator_tag)

983

self.checker_initiator_tag = GLib.timeout_add(

649

984

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

650

985

self.start_checker)

651

986

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

652

987

if self.disable_initiator_tag is not None:

653

gobject.source_remove(self.disable_initiator_tag)

654

self.disable_initiator_tag = gobject.timeout_add(

988

GLib.source_remove(self.disable_initiator_tag)

989

self.disable_initiator_tag = GLib.timeout_add(

655

990

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

656

991

# Also start a new checker *right now*.

657

992

self.start_checker()

658

993

659

994

def checker_callback(self, source, condition, connection,

660

995

command):

661

996

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

664

999

# Read return code from connection (see call_pipe)

665

1000

returncode = connection.recv()

666

1001

connection.close()

667

1002

668

1003

if returncode >= 0:

669

1004

self.last_checker_status = returncode

670

1005

self.last_checker_signal = None

680

1015

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

681

1016

vars(self))

682

1017

return False

683

1018

684

1019

def checked_ok(self):

685

1020

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

686

1021

self.last_checked_ok = datetime.datetime.utcnow()

687

1022

self.last_checker_status = 0

688

1023

self.last_checker_signal = None

689

1024

self.bump_timeout()

690

1025

691

1026

def bump_timeout(self, timeout=None):

692

1027

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

693

1028

if timeout is None:

694

1029

timeout = self.timeout

695

1030

if self.disable_initiator_tag is not None:

696

gobject.source_remove(self.disable_initiator_tag)

1031

GLib.source_remove(self.disable_initiator_tag)

697

1032

self.disable_initiator_tag = None

698

1033

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

699

self.disable_initiator_tag = gobject.timeout_add(

1034

self.disable_initiator_tag = GLib.timeout_add(

700

1035

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

701

1036

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

702

1037

703

1038

def need_approval(self):

704

1039

self.last_approval_request = datetime.datetime.utcnow()

705

1040

706

1041

def start_checker(self):

707

1042

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

708

1043

709

1044

If a checker already exists, leave it running and do

710

1045

nothing."""

711

1046

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

716

1051

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

717

1052

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

718

1053

# should be.

719

1054

720

1055

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

721

1056

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

722

1057

self.checker.join()

726

1061

# Escape attributes for the shell

727

1062

escaped_attrs = {

728

1063

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

729

for attr in self.runtime_expansions }

1064

for attr in self.runtime_expansions}

730

1065

try:

731

1066

command = self.checker_command % escaped_attrs

732

1067

except TypeError as error:

744

1079

# The exception is when not debugging but nevertheless

745

1080

# running in the foreground; use the previously

746

1081

# created wnull.

747

popen_args = { "close_fds": True,

748

"shell": True,

749

"cwd": "/" }

1082

popen_args = {"close_fds": True,

1083

"shell": True,

1084

"cwd": "/"}

750

1085

if (not self.server_settings["debug"]

751

1086

and self.server_settings["foreground"]):

752

1087

popen_args.update({"stdout": wnull,

753

"stderr": wnull })

754

pipe = multiprocessing.Pipe(duplex = False)

1088

"stderr": wnull})

1089

pipe = multiprocessing.Pipe(duplex=False)

755

1090

self.checker = multiprocessing.Process(

756

target = call_pipe,

757

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

758

kwargs = popen_args)

1091

target=call_pipe,

1092

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

1093

kwargs=popen_args)

759

1094

self.checker.start()

760

self.checker_callback_tag = gobject.io_add_watch(

761

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

1095

self.checker_callback_tag = GLib.io_add_watch(

1096

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

762

1097

self.checker_callback, pipe[0], command)

763

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

1098

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

764

1099

return True

765

1100

766

1101

def stop_checker(self):

767

1102

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

768

1103

if self.checker_callback_tag:

769

gobject.source_remove(self.checker_callback_tag)

1104

GLib.source_remove(self.checker_callback_tag)

770

1105

self.checker_callback_tag = None

771

1106

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

772

1107

return

781

1116

byte_arrays=False):

782

1117

"""Decorators for marking methods of a DBusObjectWithProperties to

783

1118

become properties on the D-Bus.

784

1119

785

1120

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

786

1121

and with one argument by "Set".

787

1122

788

1123

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

789

1124

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

790

1125

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

794

1129

if byte_arrays and signature != "ay":

795

1130

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

796

1131

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

797

1132

798

1133

def decorator(func):

799

1134

func._dbus_is_property = True

800

1135

func._dbus_interface = dbus_interface

803

1138

func._dbus_name = func.__name__

804

1139

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

805

1140

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

806

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1141

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

807

1142

return func

808

1143

809

1144

return decorator

810

1145

811

1146

812

1147

def dbus_interface_annotations(dbus_interface):

813

1148

"""Decorator for marking functions returning interface annotations

814

1149

815

1150

Usage:

816

1151

817

1152

@dbus_interface_annotations("org.example.Interface")

818

1153

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

819

1154

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

820

1155

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

821

1156

"false"}

822

1157

"""

823

1158

824

1159

def decorator(func):

825

1160

func._dbus_is_interface = True

826

1161

func._dbus_interface = dbus_interface

827

1162

func._dbus_name = dbus_interface

828

1163

return func

829

1164

830

1165

return decorator

831

1166

832

1167

833

1168

def dbus_annotations(annotations):

834

1169

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

835

1170

Usage:

836

1171

837

1172

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

838

1173

"org.freedesktop.DBus.Property."

839

1174

"EmitsChangedSignal": "false"})

841

1176

access="r")

842

1177

def Property_dbus_property(self):

843

1178

return dbus.Boolean(False)

844

1179

845

1180

See also the DBusObjectWithAnnotations class.

846

1181

"""

847

1182

848

1183

def decorator(func):

849

1184

func._dbus_annotations = annotations

850

1185

return func

851

1186

852

1187

return decorator

853

1188

854

1189

872

1207

873

1208

class DBusObjectWithAnnotations(dbus.service.Object):

874

1209

"""A D-Bus object with annotations.

875

1210

876

1211

Classes inheriting from this can use the dbus_annotations

877

1212

decorator to add annotations to methods or signals.

878

1213

"""

879

1214

880

1215

@staticmethod

881

1216

def _is_dbus_thing(thing):

882

1217

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

883

1218

884

1219

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

885

1220

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

886

1221

"""

887

1222

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

888

1223

False)

889

1224

890

1225

def _get_all_dbus_things(self, thing):

891

1226

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

892

1227

"""

895

1230

for cls in self.__class__.__mro__

896

1231

for name, athing in

897

1232

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

898

1233

899

1234

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

900

out_signature = "s",

901

path_keyword = 'object_path',

902

connection_keyword = 'connection')

1235

out_signature="s",

1236

path_keyword='object_path',

1237

connection_keyword='connection')

903

1238

def Introspect(self, object_path, connection):

904

1239

"""Overloading of standard D-Bus method.

905

1240

906

1241

Inserts annotation tags on methods and signals.

907

1242

"""

908

1243

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

909

1244

connection)

910

1245

try:

911

1246

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

912

1247

913

1248

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

914

1249

# Add annotation tags

915

1250

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

942

1277

if_tag.appendChild(ann_tag)

943

1278

# Fix argument name for the Introspect method itself

944

1279

if (if_tag.getAttribute("name")

945

== dbus.INTROSPECTABLE_IFACE):

1280

== dbus.INTROSPECTABLE_IFACE):

946

1281

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

947

1282

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

948

1283

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

961

1296

962

1297

class DBusObjectWithProperties(DBusObjectWithAnnotations):

963

1298

"""A D-Bus object with properties.

964

1299

965

1300

Classes inheriting from this can use the dbus_service_property

966

1301

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

967

1302

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

968

1303

"""

969

1304

970

1305

def _get_dbus_property(self, interface_name, property_name):

971

1306

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

972

1307

property with the specified name and interface.

977

1312

if (value._dbus_name == property_name

978

1313

and value._dbus_interface == interface_name):

979

1314

return value.__get__(self)

980

1315

981

1316

# No such property

982

1317

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

983

1318

self.dbus_object_path, interface_name, property_name))

984

1319

985

1320

@classmethod

986

1321

def _get_all_interface_names(cls):

987

1322

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

990

1325

for x in (inspect.getmro(cls))

991

1326

for attr in dir(x))

992

1327

if name is not None)

993

1328

994

1329

@dbus.service.method(dbus.PROPERTIES_IFACE,

995

1330

in_signature="ss",

996

1331

out_signature="v")

1004

1339

if not hasattr(value, "variant_level"):

1005

1340

return value

1006

1341

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

1007

1342

1008

1343

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

1009

1344

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

1010

1345

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

1022

1357

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

1023

1358

for byte in value))

1024

1359

prop(value)

1025

1360

1026

1361

@dbus.service.method(dbus.PROPERTIES_IFACE,

1027

1362

in_signature="s",

1028

1363

out_signature="a{sv}")

1029

1364

def GetAll(self, interface_name):

1030

1365

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

1031

1366

standard.

1032

1367

1033

1368

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

1034

1369

"""

1035

1370

properties = {}

1046

1381

properties[name] = value

1047

1382

continue

1048

1383

properties[name] = type(value)(

1049

value, variant_level = value.variant_level + 1)

1384

value, variant_level=value.variant_level + 1)

1050

1385

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

1051

1386

1052

1387

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

1053

1388

def PropertiesChanged(self, interface_name, changed_properties,

1054

1389

invalidated_properties):

1056

1391

standard.

1057

1392

"""

1058

1393

pass

1059

1394

1060

1395

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1061

1396

out_signature="s",

1062

1397

path_keyword='object_path',

1063

1398

connection_keyword='connection')

1064

1399

def Introspect(self, object_path, connection):

1065

1400

"""Overloading of standard D-Bus method.

1066

1401

1067

1402

Inserts property tags and interface annotation tags.

1068

1403

"""

1069

1404

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1071

1406

connection)

1072

1407

try:

1073

1408

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

1074

1409

1075

1410

def make_tag(document, name, prop):

1076

1411

e = document.createElement("property")

1077

1412

e.setAttribute("name", name)

1078

1413

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

1079

1414

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

1080

1415

return e

1081

1416

1082

1417

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

1083

1418

# Add property tags

1084

1419

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

1126

1461

exc_info=error)

1127

1462

return xmlstring

1128

1463

1464

1129

1465

try:

1130

1466

dbus.OBJECT_MANAGER_IFACE

1131

1467

except AttributeError:

1132

1468

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

1133

1469

1470

1134

1471

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1135

1472

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

1136

1473

1137

1474

Classes inheriting from this exposes the standard

1138

1475

GetManagedObjects call and the InterfacesAdded and

1139

1476

InterfacesRemoved signals on the standard

1140

1477

"org.freedesktop.DBus.ObjectManager" interface.

1141

1478

1142

1479

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

1143

1480

manually.

1144

1481

"""

1145

1482

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1146

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

1483

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

1147

1484

def GetManagedObjects(self):

1148

1485

"""This function must be overridden"""

1149

1486

raise NotImplementedError()

1150

1487

1151

1488

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1152

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

1489

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

1153

1490

def InterfacesAdded(self, object_path, interfaces_and_properties):

1154

1491

pass

1155

1156

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

1492

1493

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

1157

1494

def InterfacesRemoved(self, object_path, interfaces):

1158

1495

pass

1159

1496

1160

1497

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1161

out_signature = "s",

1162

path_keyword = 'object_path',

1163

connection_keyword = 'connection')

1498

out_signature="s",

1499

path_keyword='object_path',

1500

connection_keyword='connection')

1164

1501

def Introspect(self, object_path, connection):

1165

1502

"""Overloading of standard D-Bus method.

1166

1503

1167

1504

Override return argument name of GetManagedObjects to be

1168

1505

"objpath_interfaces_and_properties"

1169

1506

"""

1172

1509

connection)

1173

1510

try:

1174

1511

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

1175

1512

1176

1513

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

1177

1514

# Fix argument name for the GetManagedObjects method

1178

1515

if (if_tag.getAttribute("name")

1179

== dbus.OBJECT_MANAGER_IFACE):

1516

== dbus.OBJECT_MANAGER_IFACE):

1180

1517

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

1181

1518

if (cn.getAttribute("name")

1182

1519

== "GetManagedObjects"):

1192

1529

except (AttributeError, xml.dom.DOMException,

1193

1530

xml.parsers.expat.ExpatError) as error:

1194

1531

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

1195

exc_info = error)

1532

exc_info=error)

1196

1533

return xmlstring

1197

1534

1535

1198

1536

def datetime_to_dbus(dt, variant_level=0):

1199

1537

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

1200

1538

if dt is None:

1201

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

1539

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

1202

1540

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

1203

1541

1204

1542

1207

1545

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

1208

1546

interface names according to the "alt_interface_names" mapping.

1209

1547

Usage:

1210

1548

1211

1549

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

1212

1550

"net.example.AlternateInterface"})

1213

1551

class SampleDBusObject(dbus.service.Object):

1214

1552

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

1215

1553

def SampleDBusMethod():

1216

1554

pass

1217

1555

1218

1556

The above "SampleDBusMethod" on "SampleDBusObject" will be

1219

1557

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

1220

1558

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

1221

1559

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

1222

1560

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

1223

1561

1224

1562

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

1225

1563

(from DBusObjectWithProperties) and interfaces (from the

1226

1564

dbus_interface_annotations decorator).

1227

1565

"""

1228

1566

1229

1567

def wrapper(cls):

1230

1568

for orig_interface_name, alt_interface_name in (

1231

1569

alt_interface_names.items()):

1246

1584

interface_names.add(alt_interface)

1247

1585

# Is this a D-Bus signal?

1248

1586

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

1587

# Extract the original non-method undecorated

1588

# function by black magic

1249

1589

if sys.version_info.major == 2:

1250

# Extract the original non-method undecorated

1251

# function by black magic

1252

1590

nonmethod_func = (dict(

1253

1591

zip(attribute.func_code.co_freevars,

1254

1592

attribute.__closure__))

1255

1593

["func"].cell_contents)

1256

1594

else:

1257

nonmethod_func = attribute

1595

nonmethod_func = (dict(

1596

zip(attribute.__code__.co_freevars,

1597

attribute.__closure__))

1598

["func"].cell_contents)

1258

1599

# Create a new, but exactly alike, function

1259

1600

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

1260

1601

# with the alternate D-Bus interface name

1261

if sys.version_info.major == 2:

1262

new_function = types.FunctionType(

1263

nonmethod_func.func_code,

1264

nonmethod_func.func_globals,

1265

nonmethod_func.func_name,

1266

nonmethod_func.func_defaults,

1267

nonmethod_func.func_closure)

1268

else:

1269

new_function = types.FunctionType(

1270

nonmethod_func.__code__,

1271

nonmethod_func.__globals__,

1272

nonmethod_func.__name__,

1273

nonmethod_func.__defaults__,

1274

nonmethod_func.__closure__)

1602

new_function = copy_function(nonmethod_func)

1275

1603

new_function = (dbus.service.signal(

1276

1604

alt_interface,

1277

1605

attribute._dbus_signature)(new_function))

1281

1609

attribute._dbus_annotations)

1282

1610

except AttributeError:

1283

1611

pass

1612

1284

1613

# Define a creator of a function to call both the

1285

1614

# original and alternate functions, so both the

1286

1615

# original and alternate signals gets sent when

1289

1618

"""This function is a scope container to pass

1290

1619

func1 and func2 to the "call_both" function

1291

1620

outside of its arguments"""

1292

1621

1293

1622

@functools.wraps(func2)

1294

1623

def call_both(*args, **kwargs):

1295

1624

"""This function will emit two D-Bus

1296

1625

signals by calling func1 and func2"""

1297

1626

func1(*args, **kwargs)

1298

1627

func2(*args, **kwargs)

1299

# Make wrapper function look like a D-Bus signal

1628

# Make wrapper function look like a D-Bus

1629

# signal

1300

1630

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

1301

1631

if name.startswith("_dbus_"):

1302

1632

setattr(call_both, name, attr)

1303

1633

1304

1634

return call_both

1305

1635

# Create the "call_both" function and add it to

1306

1636

# the class

1316

1646

alt_interface,

1317

1647

attribute._dbus_in_signature,

1318

1648

attribute._dbus_out_signature)

1319

(types.FunctionType(attribute.func_code,

1320

attribute.func_globals,

1321

attribute.func_name,

1322

attribute.func_defaults,

1323

attribute.func_closure)))

1649

(copy_function(attribute)))

1324

1650

# Copy annotations, if any

1325

1651

try:

1326

1652

attr[attrname]._dbus_annotations = dict(

1338

1664

attribute._dbus_access,

1339

1665

attribute._dbus_get_args_options

1340

1666

["byte_arrays"])

1341

(types.FunctionType(

1342

attribute.func_code,

1343

attribute.func_globals,

1344

attribute.func_name,

1345

attribute.func_defaults,

1346

attribute.func_closure)))

1667

(copy_function(attribute)))

1347

1668

# Copy annotations, if any

1348

1669

try:

1349

1670

attr[attrname]._dbus_annotations = dict(

1358

1679

# to the class.

1359

1680

attr[attrname] = (

1360

1681

dbus_interface_annotations(alt_interface)

1361

(types.FunctionType(attribute.func_code,

1362

attribute.func_globals,

1363

attribute.func_name,

1364

attribute.func_defaults,

1365

attribute.func_closure)))

1682

(copy_function(attribute)))

1366

1683

if deprecate:

1367

1684

# Deprecate all alternate interfaces

1368

iname="_AlternateDBusNames_interface_annotation{}"

1685

iname = "_AlternateDBusNames_interface_annotation{}"

1369

1686

for interface_name in interface_names:

1370

1687

1371

1688

@dbus_interface_annotations(interface_name)

1372

1689

def func(self):

1373

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

1374

"true" }

1690

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

1691

"true"}

1375

1692

# Find an unused name

1376

1693

for aname in (iname.format(i)

1377

1694

for i in itertools.count()):

1381

1698

if interface_names:

1382

1699

# Replace the class with a new subclass of it with

1383

1700

# methods, signals, etc. as created above.

1384

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

1385

(cls, ), attr)

1701

if sys.version_info.major == 2:

1702

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

1703

(cls, ), attr)

1704

else:

1705

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

1706

(cls, ), attr)

1386

1707

return cls

1387

1708

1388

1709

return wrapper

1389

1710

1390

1711

1392

1713

"se.bsnet.fukt.Mandos"})

1393

1714

class ClientDBus(Client, DBusObjectWithProperties):

1394

1715

"""A Client class using D-Bus

1395

1716

1396

1717

Attributes:

1397

1718

dbus_object_path: dbus.ObjectPath

1398

1719

bus: dbus.SystemBus()

1399

1720

"""

1400

1721

1401

1722

runtime_expansions = (Client.runtime_expansions

1402

1723

+ ("dbus_object_path", ))

1403

1724

1404

1725

_interface = "se.recompile.Mandos.Client"

1405

1726

1406

1727

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

1407

1408

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

1728

1729

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

1409

1730

self.bus = bus

1410

1731

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

1411

1732

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

1417

1738

"/clients/" + client_object_name)

1418

1739

DBusObjectWithProperties.__init__(self, self.bus,

1419

1740

self.dbus_object_path)

1420

1741

1421

1742

def notifychangeproperty(transform_func, dbus_name,

1422

1743

type_func=lambda x: x,

1423

1744

variant_level=1,

1425

1746

_interface=_interface):

1426

1747

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

1427

1748

its changes to DBus.

1428

1749

1429

1750

transform_fun: Function that takes a value and a variant_level

1430

1751

and transforms it to a D-Bus type.

1431

1752

dbus_name: D-Bus name of the variable

1434

1755

variant_level: D-Bus variant level. Default: 1

1435

1756

"""

1436

1757

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

1437

1758

1438

1759

def setter(self, value):

1439

1760

if hasattr(self, "dbus_object_path"):

1440

1761

if (not hasattr(self, attrname) or

1447

1768

else:

1448

1769

dbus_value = transform_func(

1449

1770

type_func(value),

1450

variant_level = variant_level)

1771

variant_level=variant_level)

1451

1772

self.PropertyChanged(dbus.String(dbus_name),

1452

1773

dbus_value)

1453

1774

self.PropertiesChanged(

1454

1775

_interface,

1455

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

1456

dbus_value }),

1776

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

1777

dbus_value}),

1457

1778

dbus.Array())

1458

1779

setattr(self, attrname, value)

1459

1780

1460

1781

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

1461

1782

1462

1783

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1463

1784

approvals_pending = notifychangeproperty(dbus.Boolean,

1464

1785

"ApprovalPending",

1465

type_func = bool)

1786

type_func=bool)

1466

1787

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

1467

1788

last_enabled = notifychangeproperty(datetime_to_dbus,

1468

1789

"LastEnabled")

1469

1790

checker = notifychangeproperty(

1470

1791

dbus.Boolean, "CheckerRunning",

1471

type_func = lambda checker: checker is not None)

1792

type_func=lambda checker: checker is not None)

1472

1793

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1473

1794

"LastCheckedOK")

1474

1795

last_checker_status = notifychangeproperty(dbus.Int16,

1479

1800

"ApprovedByDefault")

1480

1801

approval_delay = notifychangeproperty(

1481

1802

dbus.UInt64, "ApprovalDelay",

1482

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

1803

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

1483

1804

approval_duration = notifychangeproperty(

1484

1805

dbus.UInt64, "ApprovalDuration",

1485

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

1806

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

1486

1807

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

1487

1808

timeout = notifychangeproperty(

1488

1809

dbus.UInt64, "Timeout",

1489

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

1810

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

1490

1811

extended_timeout = notifychangeproperty(

1491

1812

dbus.UInt64, "ExtendedTimeout",

1492

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

1813

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

1493

1814

interval = notifychangeproperty(

1494

1815

dbus.UInt64, "Interval",

1495

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

1816

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

1496

1817

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

1497

1818

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

1498

1819

invalidate_only=True)

1499

1820

1500

1821

del notifychangeproperty

1501

1822

1502

1823

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

1503

1824

try:

1504

1825

self.remove_from_connection()

1507

1828

if hasattr(DBusObjectWithProperties, "__del__"):

1508

1829

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

1509

1830

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

1510

1831

1511

1832

def checker_callback(self, source, condition,

1512

1833

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

1513

1834

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

1529

1850

| self.last_checker_signal),

1530

1851

dbus.String(command))

1531

1852

return ret

1532

1853

1533

1854

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

1534

1855

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

1535

1856

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

1539

1860

# Emit D-Bus signal

1540

1861

self.CheckerStarted(self.current_checker_command)

1541

1862

return r

1542

1863

1543

1864

def _reset_approved(self):

1544

1865

self.approved = None

1545

1866

return False

1546

1867

1547

1868

def approve(self, value=True):

1548

1869

self.approved = value

1549

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

1550

* 1000), self._reset_approved)

1870

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

1871

* 1000), self._reset_approved)

1551

1872

self.send_changedstate()

1552

1553

## D-Bus methods, signals & properties

1554

1555

## Interfaces

1556

1557

## Signals

1558

1873

1874

# D-Bus methods, signals & properties

1875

1876

# Interfaces

1877

1878

# Signals

1879

1559

1880

# CheckerCompleted - signal

1560

1881

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

1561

1882

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

1562

1883

"D-Bus signal"

1563

1884

pass

1564

1885

1565

1886

# CheckerStarted - signal

1566

1887

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

1567

1888

def CheckerStarted(self, command):

1568

1889

"D-Bus signal"

1569

1890

pass

1570

1891

1571

1892

# PropertyChanged - signal

1572

1893

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

1573

1894

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

1574

1895

def PropertyChanged(self, property, value):

1575

1896

"D-Bus signal"

1576

1897

pass

1577

1898

1578

1899

# GotSecret - signal

1579

1900

@dbus.service.signal(_interface)

1580

1901

def GotSecret(self):

1583

1904

server to mandos-client

1584

1905

"""

1585

1906

pass

1586

1907

1587

1908

# Rejected - signal

1588

1909

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

1589

1910

def Rejected(self, reason):

1590

1911

"D-Bus signal"

1591

1912

pass

1592

1913

1593

1914

# NeedApproval - signal

1594

1915

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

1595

1916

def NeedApproval(self, timeout, default):

1596

1917

"D-Bus signal"

1597

1918

return self.need_approval()

1598

1599

## Methods

1600

1919

1920

# Methods

1921

1601

1922

# Approve - method

1602

1923

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

1603

1924

def Approve(self, value):

1604

1925

self.approve(value)

1605

1926

1606

1927

# CheckedOK - method

1607

1928

@dbus.service.method(_interface)

1608

1929

def CheckedOK(self):

1609

1930

self.checked_ok()

1610

1931

1611

1932

# Enable - method

1612

1933

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

1613

1934

@dbus.service.method(_interface)

1614

1935

def Enable(self):

1615

1936

"D-Bus method"

1616

1937

self.enable()

1617

1938

1618

1939

# StartChecker - method

1619

1940

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

1620

1941

@dbus.service.method(_interface)

1621

1942

def StartChecker(self):

1622

1943

"D-Bus method"

1623

1944

self.start_checker()

1624

1945

1625

1946

# Disable - method

1626

1947

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

1627

1948

@dbus.service.method(_interface)

1628

1949

def Disable(self):

1629

1950

"D-Bus method"

1630

1951

self.disable()

1631

1952

1632

1953

# StopChecker - method

1633

1954

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

1634

1955

@dbus.service.method(_interface)

1635

1956

def StopChecker(self):

1636

1957

self.stop_checker()

1637

1638

## Properties

1639

1958

1959

# Properties

1960

1640

1961

# ApprovalPending - property

1641

1962

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

1642

1963

def ApprovalPending_dbus_property(self):

1643

1964

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

1644

1965

1645

1966

# ApprovedByDefault - property

1646

1967

@dbus_service_property(_interface,

1647

1968

signature="b",

1650

1971

if value is None: # get

1651

1972

return dbus.Boolean(self.approved_by_default)

1652

1973

self.approved_by_default = bool(value)

1653

1974

1654

1975

# ApprovalDelay - property

1655

1976

@dbus_service_property(_interface,

1656

1977

signature="t",

1660

1981

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

1661

1982

* 1000)

1662

1983

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

1663

1984

1664

1985

# ApprovalDuration - property

1665

1986

@dbus_service_property(_interface,

1666

1987

signature="t",

1670

1991

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

1671

1992

* 1000)

1672

1993

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

1673

1994

1674

1995

# Name - property

1675

1996

@dbus_annotations(

1676

1997

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

1677

1998

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

1678

1999

def Name_dbus_property(self):

1679

2000

return dbus.String(self.name)

1680

2001

1681

2002

# Fingerprint - property

1682

2003

@dbus_annotations(

1683

2004

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

1684

2005

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

1685

2006

def Fingerprint_dbus_property(self):

1686

2007

return dbus.String(self.fingerprint)

1687

2008

1688

2009

# Host - property

1689

2010

@dbus_service_property(_interface,

1690

2011

signature="s",

1693

2014

if value is None: # get

1694

2015

return dbus.String(self.host)

1695

2016

self.host = str(value)

1696

2017

1697

2018

# Created - property

1698

2019

@dbus_annotations(

1699

2020

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

1700

2021

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

1701

2022

def Created_dbus_property(self):

1702

2023

return datetime_to_dbus(self.created)

1703

2024

1704

2025

# LastEnabled - property

1705

2026

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

1706

2027

def LastEnabled_dbus_property(self):

1707

2028

return datetime_to_dbus(self.last_enabled)

1708

2029

1709

2030

# Enabled - property

1710

2031

@dbus_service_property(_interface,

1711

2032

signature="b",

1717

2038

self.enable()

1718

2039

else:

1719

2040

self.disable()

1720

2041

1721

2042

# LastCheckedOK - property

1722

2043

@dbus_service_property(_interface,

1723

2044

signature="s",

1727

2048

self.checked_ok()

1728

2049

return

1729

2050

return datetime_to_dbus(self.last_checked_ok)

1730

2051

1731

2052

# LastCheckerStatus - property

1732

2053

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

1733

2054

def LastCheckerStatus_dbus_property(self):

1734

2055

return dbus.Int16(self.last_checker_status)

1735

2056

1736

2057

# Expires - property

1737

2058

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

1738

2059

def Expires_dbus_property(self):

1739

2060

return datetime_to_dbus(self.expires)

1740

2061

1741

2062

# LastApprovalRequest - property

1742

2063

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

1743

2064

def LastApprovalRequest_dbus_property(self):

1744

2065

return datetime_to_dbus(self.last_approval_request)

1745

2066

1746

2067

# Timeout - property

1747

2068

@dbus_service_property(_interface,

1748

2069

signature="t",

1763

2084

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

1764

2085

is None):

1765

2086

return

1766

gobject.source_remove(self.disable_initiator_tag)

1767

self.disable_initiator_tag = gobject.timeout_add(

2087

GLib.source_remove(self.disable_initiator_tag)

2088

self.disable_initiator_tag = GLib.timeout_add(

1768

2089

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

1769

2090

self.disable)

1770

2091

1771

2092

# ExtendedTimeout - property

1772

2093

@dbus_service_property(_interface,

1773

2094

signature="t",

1777

2098

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

1778

2099

* 1000)

1779

2100

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

1780

2101

1781

2102

# Interval - property

1782

2103

@dbus_service_property(_interface,

1783

2104

signature="t",

1790

2111

return

1791

2112

if self.enabled:

1792

2113

# Reschedule checker run

1793

gobject.source_remove(self.checker_initiator_tag)

1794

self.checker_initiator_tag = gobject.timeout_add(

2114

GLib.source_remove(self.checker_initiator_tag)

2115

self.checker_initiator_tag = GLib.timeout_add(

1795

2116

value, self.start_checker)

1796

self.start_checker() # Start one now, too

1797

2117

self.start_checker() # Start one now, too

2118

1798

2119

# Checker - property

1799

2120

@dbus_service_property(_interface,

1800

2121

signature="s",

1803

2124

if value is None: # get

1804

2125

return dbus.String(self.checker_command)

1805

2126

self.checker_command = str(value)

1806

2127

1807

2128

# CheckerRunning - property

1808

2129

@dbus_service_property(_interface,

1809

2130

signature="b",

1815

2136

self.start_checker()

1816

2137

else:

1817

2138

self.stop_checker()

1818

2139

1819

2140

# ObjectPath - property

1820

2141

@dbus_annotations(

1821

2142

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

1822

2143

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

1823

2144

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

1824

2145

def ObjectPath_dbus_property(self):

1825

return self.dbus_object_path # is already a dbus.ObjectPath

1826

2146

return self.dbus_object_path # is already a dbus.ObjectPath

2147

1827

2148

# Secret = property

1828

2149

@dbus_annotations(

1829

2150

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

1834

2155

byte_arrays=True)

1835

2156

def Secret_dbus_property(self, value):

1836

2157

self.secret = bytes(value)

1837

2158

1838

2159

del _interface

1839

2160

1840

2161

1844

2165

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

1845

2166

if not self._pipe.recv():

1846

2167

raise KeyError(fpr)

1847

2168

1848

2169

def __getattribute__(self, name):

1849

2170

if name == '_pipe':

1850

2171

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

1853

2174

if data[0] == 'data':

1854

2175

return data[1]

1855

2176

if data[0] == 'function':

1856

2177

1857

2178

def func(*args, **kwargs):

1858

2179

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

1859

2180

return self._pipe.recv()[1]

1860

2181

1861

2182

return func

1862

2183

1863

2184

def __setattr__(self, name, value):

1864

2185

if name == '_pipe':

1865

2186

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

1868

2189

1869

2190

class ClientHandler(socketserver.BaseRequestHandler, object):

1870

2191

"""A class to handle client connections.

1871

2192

1872

2193

Instantiated once for each connection to handle it.

1873

2194

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

1874

2195

1875

2196

def handle(self):

1876

2197

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

1877

2198

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

1878

2199

str(self.client_address))

1879

2200

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

1880

2201

self.server.child_pipe.fileno())

1881

1882

session = gnutls.connection.ClientSession(

1883

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

1884

1885

# Note: gnutls.connection.X509Credentials is really a

1886

# generic GnuTLS certificate credentials object so long as

1887

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

1888

# here despite using OpenPGP certificates.

1889

1890

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

1891

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

1892

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

1893

# "+DHE-DSS"))

2202

2203

session = gnutls.ClientSession(self.request)

2204

2205

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

2206

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

2207

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

2208

# "+DHE-DSS"))

1894

2209

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

1895

2210

priority = self.server.gnutls_priority

1896

2211

if priority is None:

1897

2212

priority = "NORMAL"

1898

gnutls.library.functions.gnutls_priority_set_direct(

1899

session._c_object, priority, None)

1900

2213

gnutls.priority_set_direct(session._c_object,

2214

priority.encode("utf-8"),

2215

None)

2216

1901

2217

# Start communication using the Mandos protocol

1902

2218

# Get protocol number

1903

2219

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

1908

2224

except (ValueError, IndexError, RuntimeError) as error:

1909

2225

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

1910

2226

return

1911

2227

1912

2228

# Start GnuTLS connection

1913

2229

try:

1914

2230

session.handshake()

1915

except gnutls.errors.GNUTLSError as error:

2231

except gnutls.Error as error:

1916

2232

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

1917

2233

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

1918

2234

# established. Just abandon the request.

1919

2235

return

1920

2236

logger.debug("Handshake succeeded")

1921

2237

1922

2238

approval_required = False

1923

2239

try:

1924

2240

try:

1925

2241

fpr = self.fingerprint(

1926

2242

self.peer_certificate(session))

1927

except (TypeError,

1928

gnutls.errors.GNUTLSError) as error:

2243

except (TypeError, gnutls.Error) as error:

1929

2244

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

1930

2245

return

1931

2246

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

1932

2247

1933

2248

try:

1934

2249

client = ProxyClient(child_pipe, fpr,

1935

2250

self.client_address)

1936

2251

except KeyError:

1937

2252

return

1938

2253

1939

2254

if client.approval_delay:

1940

2255

delay = client.approval_delay

1941

2256

client.approvals_pending += 1

1942

2257

approval_required = True

1943

2258

1944

2259

while True:

1945

2260

if not client.enabled:

1946

2261

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

1949

2264

# Emit D-Bus signal

1950

2265

client.Rejected("Disabled")

1951

2266

return

1952

2267

1953

2268

if client.approved or not client.approval_delay:

1954

#We are approved or approval is disabled

2269

# We are approved or approval is disabled

1955

2270

break

1956

2271

elif client.approved is None:

1957

2272

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

1968

2283

# Emit D-Bus signal

1969

2284

client.Rejected("Denied")

1970

2285

return

1971

1972

#wait until timeout or approved

2286

2287

# wait until timeout or approved

1973

2288

time = datetime.datetime.now()

1974

2289

client.changedstate.acquire()

1975

2290

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

1988

2303

break

1989

2304

else:

1990

2305

delay -= time2 - time

1991

1992

sent_size = 0

1993

while sent_size < len(client.secret):

1994

try:

1995

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

1996

except gnutls.errors.GNUTLSError as error:

1997

logger.warning("gnutls send failed",

1998

exc_info=error)

1999

return

2000

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

2001

len(client.secret) - (sent_size

2002

+ sent))

2003

sent_size += sent

2004

2306

2307

try:

2308

session.send(client.secret)

2309

except gnutls.Error as error:

2310

logger.warning("gnutls send failed",

2311

exc_info=error)

2312

return

2313

2005

2314

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

2006

2315

# bump the timeout using extended_timeout

2007

2316

client.bump_timeout(client.extended_timeout)

2008

2317

if self.server.use_dbus:

2009

2318

# Emit D-Bus signal

2010

2319

client.GotSecret()

2011

2320

2012

2321

finally:

2013

2322

if approval_required:

2014

2323

client.approvals_pending -= 1

2015

2324

try:

2016

2325

session.bye()

2017

except gnutls.errors.GNUTLSError as error:

2326

except gnutls.Error as error:

2018

2327

logger.warning("GnuTLS bye failed",

2019

2328

exc_info=error)

2020

2329

2021

2330

@staticmethod

2022

2331

def peer_certificate(session):

2023

2332

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

2024

2333

# If not an OpenPGP certificate...

2025

if (gnutls.library.functions.gnutls_certificate_type_get(

2026

session._c_object)

2027

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

2028

# ...do the normal thing

2029

return session.peer_certificate

2334

if (gnutls.certificate_type_get(session._c_object)

2335

!= gnutls.CRT_OPENPGP):

2336

# ...return invalid data

2337

return b""

2030

2338

list_size = ctypes.c_uint(1)

2031

cert_list = (gnutls.library.functions

2032

.gnutls_certificate_get_peers

2339

cert_list = (gnutls.certificate_get_peers

2033

2340

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

2034

2341

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

2035

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

2036

" certificate")

2342

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

2037

2343

if list_size.value == 0:

2038

2344

return None

2039

2345

cert = cert_list[0]

2040

2346

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

2041

2347

2042

2348

@staticmethod

2043

2349

def fingerprint(openpgp):

2044

2350

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2045

2351

# New GnuTLS "datum" with the OpenPGP public key

2046

datum = gnutls.library.types.gnutls_datum_t(

2352

datum = gnutls.datum_t(

2047

2353

ctypes.cast(ctypes.c_char_p(openpgp),

2048

2354

ctypes.POINTER(ctypes.c_ubyte)),

2049

2355

ctypes.c_uint(len(openpgp)))

2050

2356

# New empty GnuTLS certificate

2051

crt = gnutls.library.types.gnutls_openpgp_crt_t()

2052

gnutls.library.functions.gnutls_openpgp_crt_init(

2053

ctypes.byref(crt))

2357

crt = gnutls.openpgp_crt_t()

2358

gnutls.openpgp_crt_init(ctypes.byref(crt))

2054

2359

# Import the OpenPGP public key into the certificate

2055

gnutls.library.functions.gnutls_openpgp_crt_import(

2056

crt, ctypes.byref(datum),

2057

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

2360

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

2361

gnutls.OPENPGP_FMT_RAW)

2058

2362

# Verify the self signature in the key

2059

2363

crtverify = ctypes.c_uint()

2060

gnutls.library.functions.gnutls_openpgp_crt_verify_self(

2061

crt, 0, ctypes.byref(crtverify))

2364

gnutls.openpgp_crt_verify_self(crt, 0,

2365

ctypes.byref(crtverify))

2062

2366

if crtverify.value != 0:

2063

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2064

raise gnutls.errors.CertificateSecurityError(

2065

"Verify failed")

2367

gnutls.openpgp_crt_deinit(crt)

2368

raise gnutls.CertificateSecurityError(code

2369

=crtverify.value)

2066

2370

# New buffer for the fingerprint

2067

2371

buf = ctypes.create_string_buffer(20)

2068

2372

buf_len = ctypes.c_size_t()

2069

2373

# Get the fingerprint from the certificate into the buffer

2070

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(

2071

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

2374

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

2375

ctypes.byref(buf_len))

2072

2376

# Deinit the certificate

2073

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2377

gnutls.openpgp_crt_deinit(crt)

2074

2378

# Convert the buffer to a Python bytestring

2075

2379

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

2076

2380

# Convert the bytestring to hexadecimal notation

2080

2384

2081

2385

class MultiprocessingMixIn(object):

2082

2386

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

2083

2387

2084

2388

def sub_process_main(self, request, address):

2085

2389

try:

2086

2390

self.finish_request(request, address)

2087

2391

except Exception:

2088

2392

self.handle_error(request, address)

2089

2393

self.close_request(request)

2090

2394

2091

2395

def process_request(self, request, address):

2092

2396

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

2093

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

2094

args = (request, address))

2397

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

2398

args=(request, address))

2095

2399

proc.start()

2096

2400

return proc

2097

2401

2098

2402

2099

2403

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2100

2404

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

2101

2405

2102

2406

def process_request(self, request, client_address):

2103

2407

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

2104

2408

2105

2409

This function creates a new pipe in self.pipe

2106

2410

"""

2107

2411

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2108

2412

2109

2413

proc = MultiprocessingMixIn.process_request(self, request,

2110

2414

client_address)

2111

2415

self.child_pipe.close()

2112

2416

self.add_pipe(parent_pipe, proc)

2113

2417

2114

2418

def add_pipe(self, parent_pipe, proc):

2115

2419

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

2116

2420

raise NotImplementedError()

2119

2423

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2120

2424

socketserver.TCPServer, object):

2121

2425

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

2122

2426

2123

2427

Attributes:

2124

2428

enabled: Boolean; whether this server is activated yet

2125

2429

interface: None or a network interface name (string)

2126

2430

use_ipv6: Boolean; to use IPv6 or not

2127

2431

"""

2128

2432

2129

2433

def __init__(self, server_address, RequestHandlerClass,

2130

2434

interface=None,

2131

2435

use_ipv6=True,

2141

2445

self.socketfd = socketfd

2142

2446

# Save the original socket.socket() function

2143

2447

self.socket_socket = socket.socket

2448

2144

2449

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

2145

#

2450

#

2146

2451

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

2147

2452

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

2148

2453

# patching socket.socket.)

2149

#

2454

#

2150

2455

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

2151

2456

@functools.wraps(socket.socket)

2152

2457

def socket_wrapper(*args, **kwargs):

2164

2469

# socket_wrapper(), if socketfd was set.

2165

2470

socketserver.TCPServer.__init__(self, server_address,

2166

2471

RequestHandlerClass)

2167

2472

2168

2473

def server_bind(self):

2169

2474

"""This overrides the normal server_bind() function

2170

2475

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

2171

2476

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

2477

global SO_BINDTODEVICE

2172

2478

if self.interface is not None:

2173

2479

if SO_BINDTODEVICE is None:

2174

logger.error("SO_BINDTODEVICE does not exist;"

2175

" cannot bind to interface %s",

2176

self.interface)

2177

else:

2178

try:

2179

self.socket.setsockopt(

2180

socket.SOL_SOCKET, SO_BINDTODEVICE,

2181

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

2182

except socket.error as error:

2183

if error.errno == errno.EPERM:

2184

logger.error("No permission to bind to"

2185

" interface %s", self.interface)

2186

elif error.errno == errno.ENOPROTOOPT:

2187

logger.error("SO_BINDTODEVICE not available;"

2188

" cannot bind to interface %s",

2189

self.interface)

2190

elif error.errno == errno.ENODEV:

2191

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

2192

" cannot bind", self.interface)

2193

else:

2194

raise

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

2195

2501

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

2196

2502

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

2197

2503

if not self.server_address[0]:

2198

2504

if self.address_family == socket.AF_INET6:

2199

any_address = "::" # in6addr_any

2505

any_address = "::" # in6addr_any

2200

2506

else:

2201

any_address = "0.0.0.0" # INADDR_ANY

2507

any_address = "0.0.0.0" # INADDR_ANY

2202

2508

self.server_address = (any_address,

2203

2509

self.server_address[1])

2204

2510

elif not self.server_address[1]:

2214

2520

2215

2521

class MandosServer(IPv6_TCPServer):

2216

2522

"""Mandos server.

2217

2523

2218

2524

Attributes:

2219

2525

clients: set of Client objects

2220

2526

gnutls_priority GnuTLS priority string

2221

2527

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

2222

2223

Assumes a gobject.MainLoop event loop.

2528

2529

Assumes a GLib.MainLoop event loop.

2224

2530

"""

2225

2531

2226

2532

def __init__(self, server_address, RequestHandlerClass,

2227

2533

interface=None,

2228

2534

use_ipv6=True,

2238

2544

self.gnutls_priority = gnutls_priority

2239

2545

IPv6_TCPServer.__init__(self, server_address,

2240

2546

RequestHandlerClass,

2241

interface = interface,

2242

use_ipv6 = use_ipv6,

2243

socketfd = socketfd)

2244

2547

interface=interface,

2548

use_ipv6=use_ipv6,

2549

socketfd=socketfd)

2550

2245

2551

def server_activate(self):

2246

2552

if self.enabled:

2247

2553

return socketserver.TCPServer.server_activate(self)

2248

2554

2249

2555

def enable(self):

2250

2556

self.enabled = True

2251

2557

2252

2558

def add_pipe(self, parent_pipe, proc):

2253

2559

# Call "handle_ipc" for both data and EOF events

2254

gobject.io_add_watch(

2560

GLib.io_add_watch(

2255

2561

parent_pipe.fileno(),

2256

gobject.IO_IN | gobject.IO_HUP,

2562

GLib.IO_IN | GLib.IO_HUP,

2257

2563

functools.partial(self.handle_ipc,

2258

parent_pipe = parent_pipe,

2259

proc = proc))

2260

2564

parent_pipe=parent_pipe,

2565

proc=proc))

2566

2261

2567

def handle_ipc(self, source, condition,

2262

2568

parent_pipe=None,

2263

proc = None,

2569

proc=None,

2264

2570

client_object=None):

2265

2571

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

2266

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

2572

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

2267

2573

# Wait for other process to exit

2268

2574

proc.join()

2269

2575

return False

2270

2576

2271

2577

# Read a request from the child

2272

2578

request = parent_pipe.recv()

2273

2579

command = request[0]

2274

2580

2275

2581

if command == 'init':

2276

fpr = request[1]

2582

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

2277

2583

address = request[2]

2278

2279

for c in self.clients.itervalues():

2584

2585

for c in self.clients.values():

2280

2586

if c.fingerprint == fpr:

2281

2587

client = c

2282

2588

break

2289

2595

address[0])

2290

2596

parent_pipe.send(False)

2291

2597

return False

2292

2293

gobject.io_add_watch(

2598

2599

GLib.io_add_watch(

2294

2600

parent_pipe.fileno(),

2295

gobject.IO_IN | gobject.IO_HUP,

2601

GLib.IO_IN | GLib.IO_HUP,

2296

2602

functools.partial(self.handle_ipc,

2297

parent_pipe = parent_pipe,

2298

proc = proc,

2299

client_object = client))

2603

parent_pipe=parent_pipe,

2604

proc=proc,

2605

client_object=client))

2300

2606

parent_pipe.send(True)

2301

2607

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

2302

2608

# same fileno

2305

2611

funcname = request[1]

2306

2612

args = request[2]

2307

2613

kwargs = request[3]

2308

2614

2309

2615

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

2310

2616

funcname)(*args,

2311

2617

**kwargs)))

2312

2618

2313

2619

if command == 'getattr':

2314

2620

attrname = request[1]

2315

2621

if isinstance(client_object.__getattribute__(attrname),

2318

2624

else:

2319

2625

parent_pipe.send((

2320

2626

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

2321

2627

2322

2628

if command == 'setattr':

2323

2629

attrname = request[1]

2324

2630

value = request[2]

2325

2631

setattr(client_object, attrname, value)

2326

2632

2327

2633

return True

2328

2634

2329

2635

2330

2636

def rfc3339_duration_to_delta(duration):

2331

2637

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

2332

2638

2333

2639

>>> rfc3339_duration_to_delta("P7D")

2334

2640

datetime.timedelta(7)

2335

2641

>>> rfc3339_duration_to_delta("PT60S")

2345

2651

>>> rfc3339_duration_to_delta("P1DT3M20S")

2346

2652

datetime.timedelta(1, 200)

2347

2653

"""

2348

2654

2349

2655

# Parsing an RFC 3339 duration with regular expressions is not

2350

2656

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

2351

2657

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

2352

2658

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

2353

2659

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

2354

2660

# avoid excessive use of external libraries.

2355

2661

2356

2662

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

2357

2663

Token = collections.namedtuple("Token", (

2358

2664

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

2391

2697

frozenset((token_year, token_month,

2392

2698

token_day, token_time,

2393

2699

token_week)))

2394

# Define starting values

2395

value = datetime.timedelta() # Value so far

2700

# Define starting values:

2701

# Value so far

2702

value = datetime.timedelta()

2396

2703

found_token = None

2397

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

2398

s = duration # String left to parse

2704

# Following valid tokens

2705

followers = frozenset((token_duration, ))

2706

# String left to parse

2707

s = duration

2399

2708

# Loop until end token is found

2400

2709

while found_token is not token_end:

2401

2710

# Search for any currently valid tokens

2425

2734

2426

2735

def string_to_delta(interval):

2427

2736

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

2428

2737

2429

2738

>>> string_to_delta('7d')

2430

2739

datetime.timedelta(7)

2431

2740

>>> string_to_delta('60s')

2439

2748

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

2440

2749

datetime.timedelta(0, 330)

2441

2750

"""

2442

2751

2443

2752

try:

2444

2753

return rfc3339_duration_to_delta(interval)

2445

2754

except ValueError:

2446

2755

pass

2447

2756

2448

2757

timevalue = datetime.timedelta(0)

2449

2758

for s in interval.split():

2450

2759

try:

2468

2777

return timevalue

2469

2778

2470

2779

2471

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

2780

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

2472

2781

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

2473

2782

2474

2783

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

2475

2784

if os.fork():

2476

2785

sys.exit()

2494

2803

2495

2804

2496

2805

def main():

2497

2806

2498

2807

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

2499

2808

# Parsing of options, both command line and config file

2500

2809

2501

2810

parser = argparse.ArgumentParser()

2502

2811

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

2503

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

2812

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

2504

2813

help="show version number and exit")

2505

2814

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

2506

2815

help="Bind to interface IF")

2542

2851

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

2543

2852

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

2544

2853

default=None)

2545

2854

2546

2855

options = parser.parse_args()

2547

2856

2548

2857

if options.check:

2549

2858

import doctest

2550

2859

fail_count, test_count = doctest.testmod()

2551

2860

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

2552

2861

2553

2862

# Default values for config file for server-global settings

2554

server_defaults = { "interface": "",

2555

"address": "",

2556

"port": "",

2557

"debug": "False",

2558

"priority":

2559

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

2560

":+SIGN-DSA-SHA256",

2561

"servicename": "Mandos",

2562

"use_dbus": "True",

2563

"use_ipv6": "True",

2564

"debuglevel": "",

2565

"restore": "True",

2566

"socket": "",

2567

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

2568

"foreground": "False",

2569

"zeroconf": "True",

2570

}

2571

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

2572

2881

# Parse config file for server-global settings

2573

2882

server_config = configparser.SafeConfigParser(server_defaults)

2574

2883

del server_defaults

2576

2885

# Convert the SafeConfigParser object to a dict

2577

2886

server_settings = server_config.defaults()

2578

2887

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

2579

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

2888

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

2889

"foreground", "zeroconf"):

2580

2890

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

2581

2891

option)

2582

2892

if server_settings["port"]:

2592

2902

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

2593

2903

["socket"])

2594

2904

del server_config

2595

2905

2596

2906

# Override the settings from the config file with command line

2597

2907

# options, if set.

2598

2908

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

2616

2926

if server_settings["debug"]:

2617

2927

server_settings["foreground"] = True

2618

2928

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

2619

2929

2620

2930

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

2621

2931

2622

2932

if (not server_settings["zeroconf"]

2623

2933

and not (server_settings["port"]

2624

2934

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

2625

2935

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

2626

2936

2627

2937

# For convenience

2628

2938

debug = server_settings["debug"]

2629

2939

debuglevel = server_settings["debuglevel"]

2633

2943

stored_state_file)

2634

2944

foreground = server_settings["foreground"]

2635

2945

zeroconf = server_settings["zeroconf"]

2636

2946

2637

2947

if debug:

2638

2948

initlogger(debug, logging.DEBUG)

2639

2949

else:

2642

2952

else:

2643

2953

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

2644

2954

initlogger(debug, level)

2645

2955

2646

2956

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

2647

2957

syslogger.setFormatter(

2648

2958

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

2649

2959

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

2650

2960

server_settings["servicename"])))

2651

2961

2652

2962

# Parse config file with clients

2653

2963

client_config = configparser.SafeConfigParser(Client

2654

2964

.client_defaults)

2655

2965

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

2656

2966

"clients.conf"))

2657

2967

2658

2968

global mandos_dbus_service

2659

2969

mandos_dbus_service = None

2660

2970

2661

2971

socketfd = None

2662

2972

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

2663

2973

socketfd = server_settings["socket"]

2679

2989

except IOError as e:

2680

2990

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

2681

2991

exc_info=e)

2682

2683

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

2992

2993

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

2994

("mandos", "mandos"),

2995

("nobody", "nogroup")):

2684

2996

try:

2685

2997

uid = pwd.getpwnam(name).pw_uid

2686

gid = pwd.getpwnam(name).pw_gid

2998

gid = pwd.getpwnam(group).pw_gid

2687

2999

break

2688

3000

except KeyError:

2689

3001

continue

2693

3005

try:

2694

3006

os.setgid(gid)

2695

3007

os.setuid(uid)

3008

if debug:

3009

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

3010

gid))

2696

3011

except OSError as error:

3012

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

3013

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

2697

3014

if error.errno != errno.EPERM:

2698

3015

raise

2699

3016

2700

3017

if debug:

2701

3018

# Enable all possible GnuTLS debugging

2702

3019

2703

3020

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

2704

3021

# - GnuTLS manual

2705

gnutls.library.functions.gnutls_global_set_log_level(11)

2706

2707

@gnutls.library.types.gnutls_log_func

3022

gnutls.global_set_log_level(11)

3023

3024

@gnutls.log_func

2708

3025

def debug_gnutls(level, string):

2709

3026

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

2710

2711

gnutls.library.functions.gnutls_global_set_log_function(

2712

debug_gnutls)

2713

3027

3028

gnutls.global_set_log_function(debug_gnutls)

3029

2714

3030

# Redirect stdin so all checkers get /dev/null

2715

3031

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

2716

3032

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

2717

3033

if null > 2:

2718

3034

os.close(null)

2719

3035

2720

3036

# Need to fork before connecting to D-Bus

2721

3037

if not foreground:

2722

3038

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

2723

3039

daemon()

2724

2725

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

2726

# need to inform gobject that threads will be used.

2727

gobject.threads_init()

2728

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

2729

3045

global main_loop

2730

3046

# From the Avahi example code

2731

3047

DBusGMainLoop(set_as_default=True)

2732

main_loop = gobject.MainLoop()

3048

main_loop = GLib.MainLoop()

2733

3049

bus = dbus.SystemBus()

2734

3050

# End of Avahi example code

2735

3051

if use_dbus:

2748

3064

if zeroconf:

2749

3065

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2750

3066

service = AvahiServiceToSyslog(

2751

name = server_settings["servicename"],

2752

servicetype = "_mandos._tcp",

2753

protocol = protocol,

2754

bus = bus)

3067

name=server_settings["servicename"],

3068

servicetype="_mandos._tcp",

3069

protocol=protocol,

3070

bus=bus)

2755

3071

if server_settings["interface"]:

2756

3072

service.interface = if_nametoindex(

2757

3073

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

2758

3074

2759

3075

global multiprocessing_manager

2760

3076

multiprocessing_manager = multiprocessing.Manager()

2761

3077

2762

3078

client_class = Client

2763

3079

if use_dbus:

2764

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

2765

3080

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

3081

2766

3082

client_settings = Client.config_parser(client_config)

2767

3083

old_client_settings = {}

2768

3084

clients_data = {}

2769

3085

2770

3086

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

2771

3087

global wnull

2772

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

3088

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

2773

3089

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

2774

3090

# mode

2775

3091

if debug or not foreground:

2776

3092

wnull.close()

2777

3093

2778

3094

# Get client data and settings from last running state.

2779

3095

if server_settings["restore"]:

2780

3096

try:

2781

3097

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

2782

clients_data, old_client_settings = pickle.load(

2783

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

2784

3143

os.remove(stored_state_path)

2785

3144

except IOError as e:

2786

3145

if e.errno == errno.ENOENT:

2794

3153

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

2795

3154

"EOFError:",

2796

3155

exc_info=e)

2797

3156

2798

3157

with PGPEngine() as pgp:

2799

3158

for client_name, client in clients_data.items():

2800

3159

# Skip removed clients

2801

3160

if client_name not in client_settings:

2802

3161

continue

2803

3162

2804

3163

# Decide which value to use after restoring saved state.

2805

3164

# We have three different values: Old config file,

2806

3165

# new config file, and saved state.

2817

3176

client[name] = value

2818

3177

except KeyError:

2819

3178

pass

2820

3179

2821

3180

# Clients who has passed its expire date can still be

2822

3181

# enabled if its last checker was successful. A Client

2823

3182

# whose checker succeeded before we stored its state is

2856

3215

client_name))

2857

3216

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

2858

3217

["secret"])

2859

3218

2860

3219

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

2861

3220

for client_name in (set(old_client_settings)

2862

3221

- set(client_settings)):

2864

3223

for client_name in (set(client_settings)

2865

3224

- set(old_client_settings)):

2866

3225

clients_data[client_name] = client_settings[client_name]

2867

3226

2868

3227

# Create all client objects

2869

3228

for client_name, client in clients_data.items():

2870

3229

tcp_server.clients[client_name] = client_class(

2871

name = client_name,

2872

settings = client,

2873

server_settings = server_settings)

2874

3230

name=client_name,

3231

settings=client,

3232

server_settings=server_settings)

3233

2875

3234

if not tcp_server.clients:

2876

3235

logger.warning("No clients defined")

2877

3236

2878

3237

if not foreground:

2879

3238

if pidfile is not None:

2880

3239

pid = os.getpid()

2886

3245

pidfilename, pid)

2887

3246

del pidfile

2888

3247

del pidfilename

2889

2890

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

2891

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

2892

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

2893

3253

if use_dbus:

2894

3254

2895

3255

@alternate_dbus_interfaces(

2896

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

3256

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

2897

3257

class MandosDBusService(DBusObjectWithObjectManager):

2898

3258

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

2899

3259

2900

3260

def __init__(self):

2901

3261

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

2902

3262

2903

3263

_interface = "se.recompile.Mandos"

2904

3264

2905

3265

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

2906

3266

def ClientAdded(self, objpath):

2907

3267

"D-Bus signal"

2908

3268

pass

2909

3269

2910

3270

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

2911

3271

def ClientNotFound(self, fingerprint, address):

2912

3272

"D-Bus signal"

2913

3273

pass

2914

3274

2915

3275

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

2916

3276

"true"})

2917

3277

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

2918

3278

def ClientRemoved(self, objpath, name):

2919

3279

"D-Bus signal"

2920

3280

pass

2921

3281

2922

3282

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

2923

3283

"true"})

2924

3284

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

2925

3285

def GetAllClients(self):

2926

3286

"D-Bus method"

2927

3287

return dbus.Array(c.dbus_object_path for c in

2928

tcp_server.clients.itervalues())

2929

3288

tcp_server.clients.values())

3289

2930

3290

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

2931

3291

"true"})

2932

3292

@dbus.service.method(_interface,

2934

3294

def GetAllClientsWithProperties(self):

2935

3295

"D-Bus method"

2936

3296

return dbus.Dictionary(

2937

{ c.dbus_object_path: c.GetAll(

3297

{c.dbus_object_path: c.GetAll(

2938

3298

"se.recompile.Mandos.Client")

2939

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

3299

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

2940

3300

signature="oa{sv}")

2941

3301

2942

3302

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

2943

3303

def RemoveClient(self, object_path):

2944

3304

"D-Bus method"

2945

for c in tcp_server.clients.itervalues():

3305

for c in tcp_server.clients.values():

2946

3306

if c.dbus_object_path == object_path:

2947

3307

del tcp_server.clients[c.name]

2948

3308

c.remove_from_connection()

2952

3312

self.client_removed_signal(c)

2953

3313

return

2954

3314

raise KeyError(object_path)

2955

3315

2956

3316

del _interface

2957

3317

2958

3318

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

2959

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

3319

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

2960

3320

def GetManagedObjects(self):

2961

3321

"""D-Bus method"""

2962

3322

return dbus.Dictionary(

2963

{ client.dbus_object_path:

2964

dbus.Dictionary(

2965

{ interface: client.GetAll(interface)

2966

for interface in

2967

client._get_all_interface_names()})

2968

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

2969

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

2970

3330

def client_added_signal(self, client):

2971

3331

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

2972

3332

if use_dbus:

2974

3334

self.InterfacesAdded(

2975

3335

client.dbus_object_path,

2976

3336

dbus.Dictionary(

2977

{ interface: client.GetAll(interface)

2978

for interface in

2979

client._get_all_interface_names()}))

3337

{interface: client.GetAll(interface)

3338

for interface in

3339

client._get_all_interface_names()}))

2980

3340

# Old signal

2981

3341

self.ClientAdded(client.dbus_object_path)

2982

3342

2983

3343

def client_removed_signal(self, client):

2984

3344

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

2985

3345

if use_dbus:

2990

3350

# Old signal

2991

3351

self.ClientRemoved(client.dbus_object_path,

2992

3352

client.name)

2993

3353

2994

3354

mandos_dbus_service = MandosDBusService()

2995

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

def cleanup():

2997

3362

"Cleanup function; run on exit"

2998

3363

if zeroconf:

2999

3364

service.cleanup()

3000

3001

multiprocessing.active_children()

3002

wnull.close()

3365

3366

mp.active_children()

3367

wn.close()

3003

3368

if not (tcp_server.clients or client_settings):

3004

3369

return

3005

3370

3006

3371

# Store client before exiting. Secrets are encrypted with key

3007

3372

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

3008

3373

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

3009

3374

clients = {}

3010

3375

with PGPEngine() as pgp:

3011

for client in tcp_server.clients.itervalues():

3376

for client in tcp_server.clients.values():

3012

3377

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

3013

3378

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

3014

3379

key)

3015

3380

client_dict = {}

3016

3381

3017

3382

# A list of attributes that can not be pickled

3018

3383

# + secret.

3019

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

3020

"checker", "server_settings" }

3384

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

3385

"checker", "server_settings"}

3021

3386

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

3022

3387

.Object):

3023

3388

exclude.add(name)

3024

3389

3025

3390

client_dict["encrypted_secret"] = (client

3026

3391

.encrypted_secret)

3027

3392

for attr in client.client_structure:

3028

3393

if attr not in exclude:

3029

3394

client_dict[attr] = getattr(client, attr)

3030

3395

3031

3396

clients[client.name] = client_dict

3032

3397

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

3033

3398

3034

3399

try:

3035

3400

with tempfile.NamedTemporaryFile(

3036

3401

mode='wb',

3038

3403

prefix='clients-',

3039

3404

dir=os.path.dirname(stored_state_path),

3040

3405

delete=False) as stored_state:

3041

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

3406

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

3407

protocol=2)

3042

3408

tempname = stored_state.name

3043

3409

os.rename(tempname, stored_state_path)

3044

3410

except (IOError, OSError) as e:

3054

3420

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

3055

3421

exc_info=e)

3056

3422

raise

3057

3423

3058

3424

# Delete all clients, and settings from config

3059

3425

while tcp_server.clients:

3060

3426

name, client = tcp_server.clients.popitem()

3066

3432

if use_dbus:

3067

3433

mandos_dbus_service.client_removed_signal(client)

3068

3434

client_settings.clear()

3069

3435

3070

3436

atexit.register(cleanup)

3071

3072

for client in tcp_server.clients.itervalues():

3437

3438

for client in tcp_server.clients.values():

3073

3439

if use_dbus:

3074

3440

# Emit D-Bus signal for adding

3075

3441

mandos_dbus_service.client_added_signal(client)

3076

3442

# Need to initiate checking of clients

3077

3443

if client.enabled:

3078

3444

client.init_checker()

3079

3445

3080

3446

tcp_server.enable()

3081

3447

tcp_server.server_activate()

3082

3448

3083

3449

# Find out what port we got

3084

3450

if zeroconf:

3085

3451

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

3090

3456

else: # IPv4

3091

3457

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

3092

3458

*tcp_server.socket.getsockname())

3093

3094

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

3095

3459

3460

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

3461

3096

3462

try:

3097

3463

if zeroconf:

3098

3464

# From the Avahi example code

3103

3469

cleanup()

3104

3470

sys.exit(1)

3105

3471

# End of Avahi example code

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

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

3112

3478

logger.debug("Starting main loop")

3113

3479

main_loop.run()

3114

3480

except AvahiError as error: