/mandos/release : revision 237.7.333

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

2

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

3

#

3

#

4

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

5

#

5

#

6

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

7

# service publisher, downloaded from

8

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

9

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

10

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

11

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

12

#

12

#

13

# Everything else is

14

15

16

#

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

19

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

23

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

24

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

25

# GNU General Public License for more details.

26

#

26

#

27

# 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

#

31

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

32

#

32

#

33

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

try:

38

from future_builtins import *

39

except ImportError:

40

pass

37

from future_builtins import *

41

38

42

39

try:

43

40

import SocketServer as socketserver

47

44

import argparse

48

45

import datetime

49

46

import errno

47

import gnutls.crypto

48

import gnutls.connection

49

import gnutls.errors

50

import gnutls.library.functions

51

import gnutls.library.constants

52

import gnutls.library.types

50

53

try:

51

54

import ConfigParser as configparser

52

55

except ImportError:

79

82

80

83

import dbus

81

84

import dbus.service

82

from gi.repository import GLib

85

try:

86

import gobject

87

except ImportError:

88

from gi.repository import GObject as gobject

89

import avahi

83

90

from dbus.mainloop.glib import DBusGMainLoop

84

91

import ctypes

85

92

import ctypes.util

86

93

import xml.dom.minidom

87

94

import inspect

88

95

89

# Try to find the value of SO_BINDTODEVICE:

90

96

try:

91

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

92

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

93

97

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

94

98

except AttributeError:

95

99

try:

96

# This is where SO_BINDTODEVICE was up to and including Python

97

# 2.6, and also 3.2:

98

100

from IN import SO_BINDTODEVICE

99

101

except ImportError:

100

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

101

# Try running the C preprocessor:

102

try:

103

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

104

"/dev/stdin"],

105

stdin=subprocess.PIPE,

106

stdout=subprocess.PIPE)

107

stdout = cc.communicate(

108

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

109

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

110

except (OSError, ValueError, IndexError):

111

# No value found

112

SO_BINDTODEVICE = None

102

SO_BINDTODEVICE = None

113

103

114

104

if sys.version_info.major == 2:

115

105

str = unicode

116

106

117

version = "1.7.11"

107

version = "1.6.9"

118

108

stored_state_file = "clients.pickle"

119

109

120

110

logger = logging.getLogger()

124

114

if_nametoindex = ctypes.cdll.LoadLibrary(

125

115

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

126

116

except (OSError, AttributeError):

127

117

128

118

def if_nametoindex(interface):

129

119

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

130

120

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

135

125

return interface_index

136

126

137

127

138

def copy_function(func):

139

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

140

if sys.version_info.major == 2:

141

return types.FunctionType(func.func_code,

142

func.func_globals,

143

func.func_name,

144

func.func_defaults,

145

func.func_closure)

146

else:

147

return types.FunctionType(func.__code__,

148

func.__globals__,

149

func.__name__,

150

func.__defaults__,

151

func.__closure__)

152

153

154

128

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

155

129

"""init logger and add loglevel"""

156

130

157

131

global syslogger

158

132

syslogger = (logging.handlers.SysLogHandler(

159

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

160

address="/dev/log"))

133

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

134

address = "/dev/log"))

161

135

syslogger.setFormatter(logging.Formatter

162

136

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

163

137

' %(message)s'))

164

138

logger.addHandler(syslogger)

165

139

166

140

if debug:

167

141

console = logging.StreamHandler()

168

142

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

180

154

181

155

class PGPEngine(object):

182

156

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

183

157

184

158

def __init__(self):

185

159

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

186

self.gpg = "gpg"

187

try:

188

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

189

for line in output.splitlines():

190

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

191

if name == "gpg":

192

self.gpg = path

193

break

194

except OSError as e:

195

if e.errno != errno.ENOENT:

196

raise

197

160

self.gnupgargs = ['--batch',

198

'--homedir', self.tempdir,

161

'--home', self.tempdir,

199

162

'--force-mdc',

200

'--quiet']

201

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

202

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

203

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

204

163

'--quiet',

164

'--no-use-agent']

165

205

166

def __enter__(self):

206

167

return self

207

168

208

169

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

209

170

self._cleanup()

210

171

return False

211

172

212

173

def __del__(self):

213

174

self._cleanup()

214

175

215

176

def _cleanup(self):

216

177

if self.tempdir is not None:

217

178

# Delete contents of tempdir

218

179

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

219

topdown=False):

180

topdown = False):

220

181

for filename in files:

221

182

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

222

183

for dirname in dirs:

224

185

# Remove tempdir

225

186

os.rmdir(self.tempdir)

226

187

self.tempdir = None

227

188

228

189

def password_encode(self, password):

229

190

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

230

191

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

235

196

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

236

197

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

237

198

return encoded

238

199

239

200

def encrypt(self, data, password):

240

201

passphrase = self.password_encode(password)

241

202

with tempfile.NamedTemporaryFile(

242

203

dir=self.tempdir) as passfile:

243

204

passfile.write(passphrase)

244

205

passfile.flush()

245

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

206

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

246

207

'--passphrase-file',

247

208

passfile.name]

248

209

+ self.gnupgargs,

249

stdin=subprocess.PIPE,

250

stdout=subprocess.PIPE,

251

stderr=subprocess.PIPE)

252

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

210

stdin = subprocess.PIPE,

211

stdout = subprocess.PIPE,

212

stderr = subprocess.PIPE)

213

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

253

214

if proc.returncode != 0:

254

215

raise PGPError(err)

255

216

return ciphertext

256

217

257

218

def decrypt(self, data, password):

258

219

passphrase = self.password_encode(password)

259

220

with tempfile.NamedTemporaryFile(

260

dir=self.tempdir) as passfile:

221

dir = self.tempdir) as passfile:

261

222

passfile.write(passphrase)

262

223

passfile.flush()

263

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

224

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

264

225

'--passphrase-file',

265

226

passfile.name]

266

227

+ self.gnupgargs,

267

stdin=subprocess.PIPE,

268

stdout=subprocess.PIPE,

269

stderr=subprocess.PIPE)

270

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

228

stdin = subprocess.PIPE,

229

stdout = subprocess.PIPE,

230

stderr = subprocess.PIPE)

231

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

271

232

if proc.returncode != 0:

272

233

raise PGPError(err)

273

234

return decrypted_plaintext

274

235

275

236

276

# Pretend that we have an Avahi module

277

class Avahi(object):

278

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

279

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

280

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

281

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

282

PROTO_INET = 0 # avahi-common/address.h

283

PROTO_INET6 = 1 # avahi-common/address.h

284

DBUS_NAME = "org.freedesktop.Avahi"

285

DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"

286

DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"

287

DBUS_PATH_SERVER = "/"

288

289

def string_array_to_txt_array(self, t):

290

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

291

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

292

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

293

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

294

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

295

SERVER_INVALID = 0 # avahi-common/defs.h

296

SERVER_REGISTERING = 1 # avahi-common/defs.h

297

SERVER_RUNNING = 2 # avahi-common/defs.h

298

SERVER_COLLISION = 3 # avahi-common/defs.h

299

SERVER_FAILURE = 4 # avahi-common/defs.h

300

avahi = Avahi()

301

302

303

237

class AvahiError(Exception):

304

238

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

305

239

self.value = value

317

251

318

252

class AvahiService(object):

319

253

"""An Avahi (Zeroconf) service.

320

254

321

255

Attributes:

322

256

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

323

257

Used to optionally bind to the specified interface.

335

269

server: D-Bus Server

336

270

bus: dbus.SystemBus()

337

271

"""

338

272

339

273

def __init__(self,

340

interface=avahi.IF_UNSPEC,

341

name=None,

342

servicetype=None,

343

port=None,

344

TXT=None,

345

domain="",

346

host="",

347

max_renames=32768,

348

protocol=avahi.PROTO_UNSPEC,

349

bus=None):

274

interface = avahi.IF_UNSPEC,

275

name = None,

276

servicetype = None,

277

port = None,

278

TXT = None,

279

domain = "",

280

host = "",

281

max_renames = 32768,

282

protocol = avahi.PROTO_UNSPEC,

283

bus = None):

350

284

self.interface = interface

351

285

self.name = name

352

286

self.type = servicetype

361

295

self.server = None

362

296

self.bus = bus

363

297

self.entry_group_state_changed_match = None

364

298

365

299

def rename(self, remove=True):

366

300

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

367

301

if self.rename_count >= self.max_renames:

387

321

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

388

322

self.cleanup()

389

323

os._exit(1)

390

324

391

325

def remove(self):

392

326

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

393

327

if self.entry_group_state_changed_match is not None:

395

329

self.entry_group_state_changed_match = None

396

330

if self.group is not None:

397

331

self.group.Reset()

398

332

399

333

def add(self):

400

334

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

401

335

self.remove()

418

352

dbus.UInt16(self.port),

419

353

avahi.string_array_to_txt_array(self.TXT))

420

354

self.group.Commit()

421

355

422

356

def entry_group_state_changed(self, state, error):

423

357

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

424

358

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

425

359

426

360

if state == avahi.ENTRY_GROUP_ESTABLISHED:

427

361

logger.debug("Zeroconf service established.")

428

362

elif state == avahi.ENTRY_GROUP_COLLISION:

432

366

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

433

367

str(error))

434

368

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

435

369

436

370

def cleanup(self):

437

371

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

438

372

if self.group is not None:

443

377

pass

444

378

self.group = None

445

379

self.remove()

446

380

447

381

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

448

382

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

449

383

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

478

412

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

479

413

else:

480

414

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

481

415

482

416

def activate(self):

483

417

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

484

418

if self.server is None:

501

435

.format(self.name)))

502

436

return ret

503

437

504

505

# Pretend that we have a GnuTLS module

506

class GnuTLS(object):

507

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

508

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

509

510

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

511

if library is None:

512

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

513

_library = ctypes.cdll.LoadLibrary(library)

514

del library

515

_need_version = b"3.3.0"

516

517

def __init__(self):

518

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

519

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

520

# happens.

521

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

522

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

523

.format(self._need_version))

524

525

# Unless otherwise indicated, the constants and types below are

526

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

527

528

# Constants

529

E_SUCCESS = 0

530

E_INTERRUPTED = -52

531

E_AGAIN = -28

532

CRT_OPENPGP = 2

533

CLIENT = 2

534

SHUT_RDWR = 0

535

CRD_CERTIFICATE = 1

536

E_NO_CERTIFICATE_FOUND = -49

537

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

538

539

# Types

540

class session_int(ctypes.Structure):

541

_fields_ = []

542

session_t = ctypes.POINTER(session_int)

543

544

class certificate_credentials_st(ctypes.Structure):

545

_fields_ = []

546

certificate_credentials_t = ctypes.POINTER(

547

certificate_credentials_st)

548

certificate_type_t = ctypes.c_int

549

550

class datum_t(ctypes.Structure):

551

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

552

('size', ctypes.c_uint)]

553

554

class openpgp_crt_int(ctypes.Structure):

555

_fields_ = []

556

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

557

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

558

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

559

credentials_type_t = ctypes.c_int

560

transport_ptr_t = ctypes.c_void_p

561

close_request_t = ctypes.c_int

562

563

# Exceptions

564

class Error(Exception):

565

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

566

# exception might be raised from within GnuTLS.__init__,

567

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

568

# global variable has happened.

569

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

570

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

571

# code is passed, convert it to a string with

572

# gnutls.strerror()

573

self.code = code

574

if message is None and code is not None:

575

message = GnuTLS.strerror(code)

576

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

577

message, *args)

578

579

class CertificateSecurityError(Error):

580

pass

581

582

# Classes

583

class Credentials(object):

584

def __init__(self):

585

self._c_object = gnutls.certificate_credentials_t()

586

gnutls.certificate_allocate_credentials(

587

ctypes.byref(self._c_object))

588

self.type = gnutls.CRD_CERTIFICATE

589

590

def __del__(self):

591

gnutls.certificate_free_credentials(self._c_object)

592

593

class ClientSession(object):

594

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

595

self._c_object = gnutls.session_t()

596

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

597

gnutls.set_default_priority(self._c_object)

598

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

599

gnutls.handshake_set_private_extensions(self._c_object,

600

True)

601

self.socket = socket

602

if credentials is None:

603

credentials = gnutls.Credentials()

604

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

605

ctypes.cast(credentials._c_object,

606

ctypes.c_void_p))

607

self.credentials = credentials

608

609

def __del__(self):

610

gnutls.deinit(self._c_object)

611

612

def handshake(self):

613

return gnutls.handshake(self._c_object)

614

615

def send(self, data):

616

data = bytes(data)

617

data_len = len(data)

618

while data_len > 0:

619

data_len -= gnutls.record_send(self._c_object,

620

data[-data_len:],

621

data_len)

622

623

def bye(self):

624

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

625

626

# Error handling functions

627

def _error_code(result):

628

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

629

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

630

if result >= 0:

631

return result

632

if result == gnutls.E_NO_CERTIFICATE_FOUND:

633

raise gnutls.CertificateSecurityError(code=result)

634

raise gnutls.Error(code=result)

635

636

def _retry_on_error(result, func, arguments):

637

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

638

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

639

while result < 0:

640

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

641

return _error_code(result)

642

result = func(*arguments)

643

return result

644

645

# Unless otherwise indicated, the function declarations below are

646

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

647

648

# Functions

649

priority_set_direct = _library.gnutls_priority_set_direct

650

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

651

ctypes.POINTER(ctypes.c_char_p)]

652

priority_set_direct.restype = _error_code

653

654

init = _library.gnutls_init

655

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

656

init.restype = _error_code

657

658

set_default_priority = _library.gnutls_set_default_priority

659

set_default_priority.argtypes = [session_t]

660

set_default_priority.restype = _error_code

661

662

record_send = _library.gnutls_record_send

663

record_send.argtypes = [session_t, ctypes.c_void_p,

664

ctypes.c_size_t]

665

record_send.restype = ctypes.c_ssize_t

666

record_send.errcheck = _retry_on_error

667

668

certificate_allocate_credentials = (

669

_library.gnutls_certificate_allocate_credentials)

670

certificate_allocate_credentials.argtypes = [

671

ctypes.POINTER(certificate_credentials_t)]

672

certificate_allocate_credentials.restype = _error_code

673

674

certificate_free_credentials = (

675

_library.gnutls_certificate_free_credentials)

676

certificate_free_credentials.argtypes = [

677

certificate_credentials_t]

678

certificate_free_credentials.restype = None

679

680

handshake_set_private_extensions = (

681

_library.gnutls_handshake_set_private_extensions)

682

handshake_set_private_extensions.argtypes = [session_t,

683

ctypes.c_int]

684

handshake_set_private_extensions.restype = None

685

686

credentials_set = _library.gnutls_credentials_set

687

credentials_set.argtypes = [session_t, credentials_type_t,

688

ctypes.c_void_p]

689

credentials_set.restype = _error_code

690

691

strerror = _library.gnutls_strerror

692

strerror.argtypes = [ctypes.c_int]

693

strerror.restype = ctypes.c_char_p

694

695

certificate_type_get = _library.gnutls_certificate_type_get

696

certificate_type_get.argtypes = [session_t]

697

certificate_type_get.restype = _error_code

698

699

certificate_get_peers = _library.gnutls_certificate_get_peers

700

certificate_get_peers.argtypes = [session_t,

701

ctypes.POINTER(ctypes.c_uint)]

702

certificate_get_peers.restype = ctypes.POINTER(datum_t)

703

704

global_set_log_level = _library.gnutls_global_set_log_level

705

global_set_log_level.argtypes = [ctypes.c_int]

706

global_set_log_level.restype = None

707

708

global_set_log_function = _library.gnutls_global_set_log_function

709

global_set_log_function.argtypes = [log_func]

710

global_set_log_function.restype = None

711

712

deinit = _library.gnutls_deinit

713

deinit.argtypes = [session_t]

714

deinit.restype = None

715

716

handshake = _library.gnutls_handshake

717

handshake.argtypes = [session_t]

718

handshake.restype = _error_code

719

handshake.errcheck = _retry_on_error

720

721

transport_set_ptr = _library.gnutls_transport_set_ptr

722

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

723

transport_set_ptr.restype = None

724

725

bye = _library.gnutls_bye

726

bye.argtypes = [session_t, close_request_t]

727

bye.restype = _error_code

728

bye.errcheck = _retry_on_error

729

730

check_version = _library.gnutls_check_version

731

check_version.argtypes = [ctypes.c_char_p]

732

check_version.restype = ctypes.c_char_p

733

734

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

735

736

openpgp_crt_init = _library.gnutls_openpgp_crt_init

737

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

738

openpgp_crt_init.restype = _error_code

739

740

openpgp_crt_import = _library.gnutls_openpgp_crt_import

741

openpgp_crt_import.argtypes = [openpgp_crt_t,

742

ctypes.POINTER(datum_t),

743

openpgp_crt_fmt_t]

744

openpgp_crt_import.restype = _error_code

745

746

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

747

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

748

ctypes.POINTER(ctypes.c_uint)]

749

openpgp_crt_verify_self.restype = _error_code

750

751

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

752

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

753

openpgp_crt_deinit.restype = None

754

755

openpgp_crt_get_fingerprint = (

756

_library.gnutls_openpgp_crt_get_fingerprint)

757

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

758

ctypes.c_void_p,

759

ctypes.POINTER(

760

ctypes.c_size_t)]

761

openpgp_crt_get_fingerprint.restype = _error_code

762

763

# Remove non-public functions

764

del _error_code, _retry_on_error

765

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

766

gnutls = GnuTLS()

767

768

769

438

def call_pipe(connection, # : multiprocessing.Connection

770

439

func, *args, **kwargs):

771

440

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

772

441

773

442

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

774

443

return value on the provided multiprocessing.Connection.

775

444

"""

776

445

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

777

446

connection.close()

778

447

779

780

448

class Client(object):

781

449

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

782

450

783

451

Attributes:

784

452

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

785

453

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

787

455

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

788

456

to see if the client lives.

789

457

'None' if no process is running.

790

checker_callback_tag: a GLib event source tag, or None

458

checker_callback_tag: a gobject event source tag, or None

791

459

checker_command: string; External command which is run to check

792

460

if client lives. %() expansions are done at

793

461

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

794

462

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

795

checker_initiator_tag: a GLib event source tag, or None

463

checker_initiator_tag: a gobject event source tag, or None

796

464

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

797

465

client_structure: Object describing what attributes a client has

798

466

and is used for storing the client at exit

799

467

current_checker_command: string; current running checker_command

800

disable_initiator_tag: a GLib event source tag, or None

468

disable_initiator_tag: a gobject event source tag, or None

801

469

enabled: bool()

802

470

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

803

471

uniquely identify the client

822

490

disabled, or None

823

491

server_settings: The server_settings dict from main()

824

492

"""

825

493

826

494

runtime_expansions = ("approval_delay", "approval_duration",

827

495

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

828

496

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

839

507

"approved_by_default": "True",

840

508

"enabled": "True",

841

509

}

842

510

843

511

@staticmethod

844

512

def config_parser(config):

845

513

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

852

520

for client_name in config.sections():

853

521

section = dict(config.items(client_name))

854

522

client = settings[client_name] = {}

855

523

856

524

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

857

525

# Reformat values from string types to Python types

858

526

client["approved_by_default"] = config.getboolean(

859

527

client_name, "approved_by_default")

860

528

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

861

529

"enabled")

862

530

863

531

# Uppercase and remove spaces from fingerprint for later

864

532

# comparison purposes with return value from the

865

533

# fingerprint() function

866

534

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

867

535

.replace(" ", ""))

868

536

if "secret" in section:

869

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

870

.encode("utf-8"),

871

"base64")

537

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

872

538

elif "secfile" in section:

873

539

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

874

540

(section["secfile"])),

889

555

client["last_approval_request"] = None

890

556

client["last_checked_ok"] = None

891

557

client["last_checker_status"] = -2

892

558

893

559

return settings

894

895

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

560

561

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

896

562

self.name = name

897

563

if server_settings is None:

898

564

server_settings = {}

900

566

# adding all client settings

901

567

for setting, value in settings.items():

902

568

setattr(self, setting, value)

903

569

904

570

if self.enabled:

905

571

if not hasattr(self, "last_enabled"):

906

572

self.last_enabled = datetime.datetime.utcnow()

910

576

else:

911

577

self.last_enabled = None

912

578

self.expires = None

913

579

914

580

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

915

581

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

916

582

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

917

583

datetime.datetime.utcnow())

918

584

919

585

# attributes specific for this server instance

920

586

self.checker = None

921

587

self.checker_initiator_tag = None

927

593

self.changedstate = multiprocessing_manager.Condition(

928

594

multiprocessing_manager.Lock())

929

595

self.client_structure = [attr

930

for attr in self.__dict__.keys()

596

for attr in self.__dict__.iterkeys()

931

597

if not attr.startswith("_")]

932

598

self.client_structure.append("client_structure")

933

599

934

600

for name, t in inspect.getmembers(

935

601

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

936

602

if not name.startswith("_"):

937

603

self.client_structure.append(name)

938

604

939

605

# Send notice to process children that client state has changed

940

606

def send_changedstate(self):

941

607

with self.changedstate:

942

608

self.changedstate.notify_all()

943

609

944

610

def enable(self):

945

611

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

946

612

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

951

617

self.last_enabled = datetime.datetime.utcnow()

952

618

self.init_checker()

953

619

self.send_changedstate()

954

620

955

621

def disable(self, quiet=True):

956

622

"""Disable this client."""

957

623

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

959

625

if not quiet:

960

626

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

961

627

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

962

GLib.source_remove(self.disable_initiator_tag)

628

gobject.source_remove(self.disable_initiator_tag)

963

629

self.disable_initiator_tag = None

964

630

self.expires = None

965

631

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

966

GLib.source_remove(self.checker_initiator_tag)

632

gobject.source_remove(self.checker_initiator_tag)

967

633

self.checker_initiator_tag = None

968

634

self.stop_checker()

969

635

self.enabled = False

970

636

if not quiet:

971

637

self.send_changedstate()

972

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

638

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

973

639

return False

974

640

975

641

def __del__(self):

976

642

self.disable()

977

643

978

644

def init_checker(self):

979

645

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

980

646

# and every interval from then on.

981

647

if self.checker_initiator_tag is not None:

982

GLib.source_remove(self.checker_initiator_tag)

983

self.checker_initiator_tag = GLib.timeout_add(

648

gobject.source_remove(self.checker_initiator_tag)

649

self.checker_initiator_tag = gobject.timeout_add(

984

650

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

985

651

self.start_checker)

986

652

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

987

653

if self.disable_initiator_tag is not None:

988

GLib.source_remove(self.disable_initiator_tag)

989

self.disable_initiator_tag = GLib.timeout_add(

654

gobject.source_remove(self.disable_initiator_tag)

655

self.disable_initiator_tag = gobject.timeout_add(

990

656

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

991

657

# Also start a new checker *right now*.

992

658

self.start_checker()

993

659

994

660

def checker_callback(self, source, condition, connection,

995

661

command):

996

662

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

999

665

# Read return code from connection (see call_pipe)

1000

666

returncode = connection.recv()

1001

667

connection.close()

1002

668

1003

669

if returncode >= 0:

1004

670

self.last_checker_status = returncode

1005

671

self.last_checker_signal = None

1015

681

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

1016

682

vars(self))

1017

683

return False

1018

684

1019

685

def checked_ok(self):

1020

686

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

1021

687

self.last_checked_ok = datetime.datetime.utcnow()

1022

688

self.last_checker_status = 0

1023

689

self.last_checker_signal = None

1024

690

self.bump_timeout()

1025

691

1026

692

def bump_timeout(self, timeout=None):

1027

693

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

1028

694

if timeout is None:

1029

695

timeout = self.timeout

1030

696

if self.disable_initiator_tag is not None:

1031

GLib.source_remove(self.disable_initiator_tag)

697

gobject.source_remove(self.disable_initiator_tag)

1032

698

self.disable_initiator_tag = None

1033

699

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

1034

self.disable_initiator_tag = GLib.timeout_add(

700

self.disable_initiator_tag = gobject.timeout_add(

1035

701

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

1036

702

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

1037

703

1038

704

def need_approval(self):

1039

705

self.last_approval_request = datetime.datetime.utcnow()

1040

706

1041

707

def start_checker(self):

1042

708

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

1043

709

1044

710

If a checker already exists, leave it running and do

1045

711

nothing."""

1046

712

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

1051

717

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

1052

718

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

1053

719

# should be.

1054

720

1055

721

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

1056

722

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

1057

723

self.checker.join()

1061

727

# Escape attributes for the shell

1062

728

escaped_attrs = {

1063

729

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

1064

for attr in self.runtime_expansions}

730

for attr in self.runtime_expansions }

1065

731

try:

1066

732

command = self.checker_command % escaped_attrs

1067

733

except TypeError as error:

1079

745

# The exception is when not debugging but nevertheless

1080

746

# running in the foreground; use the previously

1081

747

# created wnull.

1082

popen_args = {"close_fds": True,

1083

"shell": True,

1084

"cwd": "/"}

748

popen_args = { "close_fds": True,

749

"shell": True,

750

"cwd": "/" }

1085

751

if (not self.server_settings["debug"]

1086

752

and self.server_settings["foreground"]):

1087

753

popen_args.update({"stdout": wnull,

1088

"stderr": wnull})

1089

pipe = multiprocessing.Pipe(duplex=False)

754

"stderr": wnull })

755

pipe = multiprocessing.Pipe(duplex = False)

1090

756

self.checker = multiprocessing.Process(

1091

target=call_pipe,

1092

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

1093

kwargs=popen_args)

757

target = call_pipe,

758

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

759

kwargs = popen_args)

1094

760

self.checker.start()

1095

self.checker_callback_tag = GLib.io_add_watch(

1096

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

761

self.checker_callback_tag = gobject.io_add_watch(

762

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

1097

763

self.checker_callback, pipe[0], command)

1098

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

764

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

1099

765

return True

1100

766

1101

767

def stop_checker(self):

1102

768

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

1103

769

if self.checker_callback_tag:

1104

GLib.source_remove(self.checker_callback_tag)

770

gobject.source_remove(self.checker_callback_tag)

1105

771

self.checker_callback_tag = None

1106

772

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

1107

773

return

1116

782

byte_arrays=False):

1117

783

"""Decorators for marking methods of a DBusObjectWithProperties to

1118

784

become properties on the D-Bus.

1119

785

1120

786

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

1121

787

and with one argument by "Set".

1122

788

1123

789

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

1124

790

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

1125

791

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

1129

795

if byte_arrays and signature != "ay":

1130

796

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

1131

797

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

1132

798

1133

799

def decorator(func):

1134

800

func._dbus_is_property = True

1135

801

func._dbus_interface = dbus_interface

1138

804

func._dbus_name = func.__name__

1139

805

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

1140

806

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

1141

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

807

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1142

808

return func

1143

809

1144

810

return decorator

1145

811

1146

812

1147

813

def dbus_interface_annotations(dbus_interface):

1148

814

"""Decorator for marking functions returning interface annotations

1149

815

1150

816

Usage:

1151

817

1152

818

@dbus_interface_annotations("org.example.Interface")

1153

819

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

1154

820

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

1155

821

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

1156

822

"false"}

1157

823

"""

1158

824

1159

825

def decorator(func):

1160

826

func._dbus_is_interface = True

1161

827

func._dbus_interface = dbus_interface

1162

828

func._dbus_name = dbus_interface

1163

829

return func

1164

830

1165

831

return decorator

1166

832

1167

833

1168

834

def dbus_annotations(annotations):

1169

835

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

1170

836

Usage:

1171

837

1172

838

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

1173

839

"org.freedesktop.DBus.Property."

1174

840

"EmitsChangedSignal": "false"})

1176

842

access="r")

1177

843

def Property_dbus_property(self):

1178

844

return dbus.Boolean(False)

1179

845

1180

846

See also the DBusObjectWithAnnotations class.

1181

847

"""

1182

848

1183

849

def decorator(func):

1184

850

func._dbus_annotations = annotations

1185

851

return func

1186

852

1187

853

return decorator

1188

854

1189

855

1207

873

1208

874

class DBusObjectWithAnnotations(dbus.service.Object):

1209

875

"""A D-Bus object with annotations.

1210

876

1211

877

Classes inheriting from this can use the dbus_annotations

1212

878

decorator to add annotations to methods or signals.

1213

879

"""

1214

880

1215

881

@staticmethod

1216

882

def _is_dbus_thing(thing):

1217

883

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

1218

884

1219

885

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

1220

886

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

1221

887

"""

1222

888

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

1223

889

False)

1224

890

1225

891

def _get_all_dbus_things(self, thing):

1226

892

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

1227

893

"""

1230

896

for cls in self.__class__.__mro__

1231

897

for name, athing in

1232

898

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

1233

899

1234

900

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1235

out_signature="s",

1236

path_keyword='object_path',

1237

connection_keyword='connection')

901

out_signature = "s",

902

path_keyword = 'object_path',

903

connection_keyword = 'connection')

1238

904

def Introspect(self, object_path, connection):

1239

905

"""Overloading of standard D-Bus method.

1240

906

1241

907

Inserts annotation tags on methods and signals.

1242

908

"""

1243

909

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

1244

910

connection)

1245

911

try:

1246

912

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

1247

913

1248

914

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

1249

915

# Add annotation tags

1250

916

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

1277

943

if_tag.appendChild(ann_tag)

1278

944

# Fix argument name for the Introspect method itself

1279

945

if (if_tag.getAttribute("name")

1280

== dbus.INTROSPECTABLE_IFACE):

946

== dbus.INTROSPECTABLE_IFACE):

1281

947

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

1282

948

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

1283

949

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

1296

962

1297

963

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1298

964

"""A D-Bus object with properties.

1299

965

1300

966

Classes inheriting from this can use the dbus_service_property

1301

967

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

1302

968

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

1303

969

"""

1304

970

1305

971

def _get_dbus_property(self, interface_name, property_name):

1306

972

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

1307

973

property with the specified name and interface.

1312

978

if (value._dbus_name == property_name

1313

979

and value._dbus_interface == interface_name):

1314

980

return value.__get__(self)

1315

981

1316

982

# No such property

1317

983

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

1318

984

self.dbus_object_path, interface_name, property_name))

1319

985

1320

986

@classmethod

1321

987

def _get_all_interface_names(cls):

1322

988

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

1325

991

for x in (inspect.getmro(cls))

1326

992

for attr in dir(x))

1327

993

if name is not None)

1328

994

1329

995

@dbus.service.method(dbus.PROPERTIES_IFACE,

1330

996

in_signature="ss",

1331

997

out_signature="v")

1339

1005

if not hasattr(value, "variant_level"):

1340

1006

return value

1341

1007

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

1342

1008

1343

1009

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

1344

1010

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

1345

1011

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

1357

1023

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

1358

1024

for byte in value))

1359

1025

prop(value)

1360

1026

1361

1027

@dbus.service.method(dbus.PROPERTIES_IFACE,

1362

1028

in_signature="s",

1363

1029

out_signature="a{sv}")

1364

1030

def GetAll(self, interface_name):

1365

1031

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

1366

1032

standard.

1367

1033

1368

1034

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

1369

1035

"""

1370

1036

properties = {}

1381

1047

properties[name] = value

1382

1048

continue

1383

1049

properties[name] = type(value)(

1384

value, variant_level=value.variant_level + 1)

1050

value, variant_level = value.variant_level + 1)

1385

1051

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

1386

1052

1387

1053

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

1388

1054

def PropertiesChanged(self, interface_name, changed_properties,

1389

1055

invalidated_properties):

1391

1057

standard.

1392

1058

"""

1393

1059

pass

1394

1060

1395

1061

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1396

1062

out_signature="s",

1397

1063

path_keyword='object_path',

1398

1064

connection_keyword='connection')

1399

1065

def Introspect(self, object_path, connection):

1400

1066

"""Overloading of standard D-Bus method.

1401

1067

1402

1068

Inserts property tags and interface annotation tags.

1403

1069

"""

1404

1070

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1406

1072

connection)

1407

1073

try:

1408

1074

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

1409

1075

1410

1076

def make_tag(document, name, prop):

1411

1077

e = document.createElement("property")

1412

1078

e.setAttribute("name", name)

1413

1079

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

1414

1080

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

1415

1081

return e

1416

1082

1417

1083

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

1418

1084

# Add property tags

1419

1085

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

1466

1132

except AttributeError:

1467

1133

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

1468

1134

1469

1470

1135

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1471

1136

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

1472

1137

1473

1138

Classes inheriting from this exposes the standard

1474

1139

GetManagedObjects call and the InterfacesAdded and

1475

1140

InterfacesRemoved signals on the standard

1476

1141

"org.freedesktop.DBus.ObjectManager" interface.

1477

1142

1478

1143

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

1479

1144

manually.

1480

1145

"""

1481

1146

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1482

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

1147

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

1483

1148

def GetManagedObjects(self):

1484

1149

"""This function must be overridden"""

1485

1150

raise NotImplementedError()

1486

1151

1487

1152

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1488

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

1153

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

1489

1154

def InterfacesAdded(self, object_path, interfaces_and_properties):

1490

1155

pass

1491

1492

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

1156

1157

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1158

signature = "oas")

1493

1159

def InterfacesRemoved(self, object_path, interfaces):

1494

1160

pass

1495

1161

1496

1162

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1497

out_signature="s",

1498

path_keyword='object_path',

1499

connection_keyword='connection')

1163

out_signature = "s",

1164

path_keyword = 'object_path',

1165

connection_keyword = 'connection')

1500

1166

def Introspect(self, object_path, connection):

1501

1167

"""Overloading of standard D-Bus method.

1502

1168

1503

1169

Override return argument name of GetManagedObjects to be

1504

1170

"objpath_interfaces_and_properties"

1505

1171

"""

1506

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1507

object_path,

1508

connection)

1172

xmlstring = DBusObjectWithAnnotations(self, object_path,

1173

connection)

1509

1174

try:

1510

1175

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

1511

1176

1512

1177

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

1513

1178

# Fix argument name for the GetManagedObjects method

1514

1179

if (if_tag.getAttribute("name")

1515

== dbus.OBJECT_MANAGER_IFACE):

1180

== dbus.OBJECT_MANAGER_IFACE):

1516

1181

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

1517

1182

if (cn.getAttribute("name")

1518

1183

== "GetManagedObjects"):

1528

1193

except (AttributeError, xml.dom.DOMException,

1529

1194

xml.parsers.expat.ExpatError) as error:

1530

1195

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

1531

exc_info=error)

1196

exc_info = error)

1532

1197

return xmlstring

1533

1198

1534

1535

1199

def datetime_to_dbus(dt, variant_level=0):

1536

1200

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

1537

1201

if dt is None:

1538

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

1202

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

1539

1203

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

1540

1204

1541

1205

1544

1208

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

1545

1209

interface names according to the "alt_interface_names" mapping.

1546

1210

Usage:

1547

1211

1548

1212

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

1549

1213

"net.example.AlternateInterface"})

1550

1214

class SampleDBusObject(dbus.service.Object):

1551

1215

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

1552

1216

def SampleDBusMethod():

1553

1217

pass

1554

1218

1555

1219

The above "SampleDBusMethod" on "SampleDBusObject" will be

1556

1220

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

1557

1221

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

1558

1222

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

1559

1223

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

1560

1224

1561

1225

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

1562

1226

(from DBusObjectWithProperties) and interfaces (from the

1563

1227

dbus_interface_annotations decorator).

1564

1228

"""

1565

1229

1566

1230

def wrapper(cls):

1567

1231

for orig_interface_name, alt_interface_name in (

1568

1232

alt_interface_names.items()):

1583

1247

interface_names.add(alt_interface)

1584

1248

# Is this a D-Bus signal?

1585

1249

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

1586

# Extract the original non-method undecorated

1587

# function by black magic

1588

1250

if sys.version_info.major == 2:

1251

# Extract the original non-method undecorated

1252

# function by black magic

1589

1253

nonmethod_func = (dict(

1590

1254

zip(attribute.func_code.co_freevars,

1591

1255

attribute.__closure__))

1592

1256

["func"].cell_contents)

1593

1257

else:

1594

nonmethod_func = (dict(

1595

zip(attribute.__code__.co_freevars,

1596

attribute.__closure__))

1597

["func"].cell_contents)

1258

nonmethod_func = attribute

1598

1259

# Create a new, but exactly alike, function

1599

1260

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

1600

1261

# with the alternate D-Bus interface name

1601

new_function = copy_function(nonmethod_func)

1262

if sys.version_info.major == 2:

1263

new_function = types.FunctionType(

1264

nonmethod_func.func_code,

1265

nonmethod_func.func_globals,

1266

nonmethod_func.func_name,

1267

nonmethod_func.func_defaults,

1268

nonmethod_func.func_closure)

1269

else:

1270

new_function = types.FunctionType(

1271

nonmethod_func.__code__,

1272

nonmethod_func.__globals__,

1273

nonmethod_func.__name__,

1274

nonmethod_func.__defaults__,

1275

nonmethod_func.__closure__)

1602

1276

new_function = (dbus.service.signal(

1603

1277

alt_interface,

1604

1278

attribute._dbus_signature)(new_function))

1608

1282

attribute._dbus_annotations)

1609

1283

except AttributeError:

1610

1284

pass

1611

1612

1285

# Define a creator of a function to call both the

1613

1286

# original and alternate functions, so both the

1614

1287

# original and alternate signals gets sent when

1617

1290

"""This function is a scope container to pass

1618

1291

func1 and func2 to the "call_both" function

1619

1292

outside of its arguments"""

1620

1621

@functools.wraps(func2)

1293

1622

1294

def call_both(*args, **kwargs):

1623

1295

"""This function will emit two D-Bus

1624

1296

signals by calling func1 and func2"""

1625

1297

func1(*args, **kwargs)

1626

1298

func2(*args, **kwargs)

1627

# Make wrapper function look like a D-Bus

1628

# signal

1629

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

1630

if name.startswith("_dbus_"):

1631

setattr(call_both, name, attr)

1632

1299

1633

1300

return call_both

1634

1301

# Create the "call_both" function and add it to

1635

1302

# the class

1645

1312

alt_interface,

1646

1313

attribute._dbus_in_signature,

1647

1314

attribute._dbus_out_signature)

1648

(copy_function(attribute)))

1315

(types.FunctionType(attribute.func_code,

1316

attribute.func_globals,

1317

attribute.func_name,

1318

attribute.func_defaults,

1319

attribute.func_closure)))

1649

1320

# Copy annotations, if any

1650

1321

try:

1651

1322

attr[attrname]._dbus_annotations = dict(

1663

1334

attribute._dbus_access,

1664

1335

attribute._dbus_get_args_options

1665

1336

["byte_arrays"])

1666

(copy_function(attribute)))

1337

(types.FunctionType(

1338

attribute.func_code,

1339

attribute.func_globals,

1340

attribute.func_name,

1341

attribute.func_defaults,

1342

attribute.func_closure)))

1667

1343

# Copy annotations, if any

1668

1344

try:

1669

1345

attr[attrname]._dbus_annotations = dict(

1678

1354

# to the class.

1679

1355

attr[attrname] = (

1680

1356

dbus_interface_annotations(alt_interface)

1681

(copy_function(attribute)))

1357

(types.FunctionType(attribute.func_code,

1358

attribute.func_globals,

1359

attribute.func_name,

1360

attribute.func_defaults,

1361

attribute.func_closure)))

1682

1362

if deprecate:

1683

1363

# Deprecate all alternate interfaces

1684

iname = "_AlternateDBusNames_interface_annotation{}"

1364

iname="_AlternateDBusNames_interface_annotation{}"

1685

1365

for interface_name in interface_names:

1686

1366

1687

1367

@dbus_interface_annotations(interface_name)

1688

1368

def func(self):

1689

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

1690

"true"}

1369

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

1370

"true" }

1691

1371

# Find an unused name

1692

1372

for aname in (iname.format(i)

1693

1373

for i in itertools.count()):

1697

1377

if interface_names:

1698

1378

# Replace the class with a new subclass of it with

1699

1379

# methods, signals, etc. as created above.

1700

if sys.version_info.major == 2:

1701

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

1702

(cls, ), attr)

1703

else:

1704

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

1705

(cls, ), attr)

1380

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

1381

(cls, ), attr)

1706

1382

return cls

1707

1383

1708

1384

return wrapper

1709

1385

1710

1386

1712

1388

"se.bsnet.fukt.Mandos"})

1713

1389

class ClientDBus(Client, DBusObjectWithProperties):

1714

1390

"""A Client class using D-Bus

1715

1391

1716

1392

Attributes:

1717

1393

dbus_object_path: dbus.ObjectPath

1718

1394

bus: dbus.SystemBus()

1719

1395

"""

1720

1396

1721

1397

runtime_expansions = (Client.runtime_expansions

1722

1398

+ ("dbus_object_path", ))

1723

1399

1724

1400

_interface = "se.recompile.Mandos.Client"

1725

1401

1726

1402

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

1727

1728

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

1403

1404

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

1729

1405

self.bus = bus

1730

1406

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

1731

1407

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

1737

1413

"/clients/" + client_object_name)

1738

1414

DBusObjectWithProperties.__init__(self, self.bus,

1739

1415

self.dbus_object_path)

1740

1416

1741

1417

def notifychangeproperty(transform_func, dbus_name,

1742

1418

type_func=lambda x: x,

1743

1419

variant_level=1,

1745

1421

_interface=_interface):

1746

1422

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

1747

1423

its changes to DBus.

1748

1424

1749

1425

transform_fun: Function that takes a value and a variant_level

1750

1426

and transforms it to a D-Bus type.

1751

1427

dbus_name: D-Bus name of the variable

1754

1430

variant_level: D-Bus variant level. Default: 1

1755

1431

"""

1756

1432

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

1757

1433

1758

1434

def setter(self, value):

1759

1435

if hasattr(self, "dbus_object_path"):

1760

1436

if (not hasattr(self, attrname) or

1767

1443

else:

1768

1444

dbus_value = transform_func(

1769

1445

type_func(value),

1770

variant_level=variant_level)

1446

variant_level = variant_level)

1771

1447

self.PropertyChanged(dbus.String(dbus_name),

1772

1448

dbus_value)

1773

1449

self.PropertiesChanged(

1774

1450

_interface,

1775

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

1776

dbus_value}),

1451

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

1452

dbus_value }),

1777

1453

dbus.Array())

1778

1454

setattr(self, attrname, value)

1779

1455

1780

1456

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

1781

1457

1782

1458

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1783

1459

approvals_pending = notifychangeproperty(dbus.Boolean,

1784

1460

"ApprovalPending",

1785

type_func=bool)

1461

type_func = bool)

1786

1462

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

1787

1463

last_enabled = notifychangeproperty(datetime_to_dbus,

1788

1464

"LastEnabled")

1789

1465

checker = notifychangeproperty(

1790

1466

dbus.Boolean, "CheckerRunning",

1791

type_func=lambda checker: checker is not None)

1467

type_func = lambda checker: checker is not None)

1792

1468

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1793

1469

"LastCheckedOK")

1794

1470

last_checker_status = notifychangeproperty(dbus.Int16,

1799

1475

"ApprovedByDefault")

1800

1476

approval_delay = notifychangeproperty(

1801

1477

dbus.UInt64, "ApprovalDelay",

1802

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

1478

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

1803

1479

approval_duration = notifychangeproperty(

1804

1480

dbus.UInt64, "ApprovalDuration",

1805

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

1481

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

1806

1482

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

1807

1483

timeout = notifychangeproperty(

1808

1484

dbus.UInt64, "Timeout",

1809

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

1485

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

1810

1486

extended_timeout = notifychangeproperty(

1811

1487

dbus.UInt64, "ExtendedTimeout",

1812

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

1488

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

1813

1489

interval = notifychangeproperty(

1814

1490

dbus.UInt64, "Interval",

1815

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

1491

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

1816

1492

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

1817

1493

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

1818

1494

invalidate_only=True)

1819

1495

1820

1496

del notifychangeproperty

1821

1497

1822

1498

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

1823

1499

try:

1824

1500

self.remove_from_connection()

1827

1503

if hasattr(DBusObjectWithProperties, "__del__"):

1828

1504

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

1829

1505

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

1830

1506

1831

1507

def checker_callback(self, source, condition,

1832

1508

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

1833

1509

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

1849

1525

| self.last_checker_signal),

1850

1526

dbus.String(command))

1851

1527

return ret

1852

1528

1853

1529

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

1854

1530

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

1855

1531

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

1859

1535

# Emit D-Bus signal

1860

1536

self.CheckerStarted(self.current_checker_command)

1861

1537

return r

1862

1538

1863

1539

def _reset_approved(self):

1864

1540

self.approved = None

1865

1541

return False

1866

1542

1867

1543

def approve(self, value=True):

1868

1544

self.approved = value

1869

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

1870

* 1000), self._reset_approved)

1545

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

1546

* 1000), self._reset_approved)

1871

1547

self.send_changedstate()

1872

1873

# D-Bus methods, signals & properties

1874

1875

# Interfaces

1876

1877

# Signals

1878

1548

1549

## D-Bus methods, signals & properties

1550

1551

## Interfaces

1552

1553

## Signals

1554

1879

1555

# CheckerCompleted - signal

1880

1556

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

1881

1557

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

1882

1558

"D-Bus signal"

1883

1559

pass

1884

1560

1885

1561

# CheckerStarted - signal

1886

1562

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

1887

1563

def CheckerStarted(self, command):

1888

1564

"D-Bus signal"

1889

1565

pass

1890

1566

1891

1567

# PropertyChanged - signal

1892

1568

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

1893

1569

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

1894

1570

def PropertyChanged(self, property, value):

1895

1571

"D-Bus signal"

1896

1572

pass

1897

1573

1898

1574

# GotSecret - signal

1899

1575

@dbus.service.signal(_interface)

1900

1576

def GotSecret(self):

1903

1579

server to mandos-client

1904

1580

"""

1905

1581

pass

1906

1582

1907

1583

# Rejected - signal

1908

1584

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

1909

1585

def Rejected(self, reason):

1910

1586

"D-Bus signal"

1911

1587

pass

1912

1588

1913

1589

# NeedApproval - signal

1914

1590

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

1915

1591

def NeedApproval(self, timeout, default):

1916

1592

"D-Bus signal"

1917

1593

return self.need_approval()

1918

1919

# Methods

1920

1594

1595

## Methods

1596

1921

1597

# Approve - method

1922

1598

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

1923

1599

def Approve(self, value):

1924

1600

self.approve(value)

1925

1601

1926

1602

# CheckedOK - method

1927

1603

@dbus.service.method(_interface)

1928

1604

def CheckedOK(self):

1929

1605

self.checked_ok()

1930

1606

1931

1607

# Enable - method

1932

1608

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

1933

1609

@dbus.service.method(_interface)

1934

1610

def Enable(self):

1935

1611

"D-Bus method"

1936

1612

self.enable()

1937

1613

1938

1614

# StartChecker - method

1939

1615

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

1940

1616

@dbus.service.method(_interface)

1941

1617

def StartChecker(self):

1942

1618

"D-Bus method"

1943

1619

self.start_checker()

1944

1620

1945

1621

# Disable - method

1946

1622

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

1947

1623

@dbus.service.method(_interface)

1948

1624

def Disable(self):

1949

1625

"D-Bus method"

1950

1626

self.disable()

1951

1627

1952

1628

# StopChecker - method

1953

1629

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

1954

1630

@dbus.service.method(_interface)

1955

1631

def StopChecker(self):

1956

1632

self.stop_checker()

1957

1958

# Properties

1959

1633

1634

## Properties

1635

1960

1636

# ApprovalPending - property

1961

1637

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

1962

1638

def ApprovalPending_dbus_property(self):

1963

1639

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

1964

1640

1965

1641

# ApprovedByDefault - property

1966

1642

@dbus_service_property(_interface,

1967

1643

signature="b",

1970

1646

if value is None: # get

1971

1647

return dbus.Boolean(self.approved_by_default)

1972

1648

self.approved_by_default = bool(value)

1973

1649

1974

1650

# ApprovalDelay - property

1975

1651

@dbus_service_property(_interface,

1976

1652

signature="t",

1980

1656

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

1981

1657

* 1000)

1982

1658

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

1983

1659

1984

1660

# ApprovalDuration - property

1985

1661

@dbus_service_property(_interface,

1986

1662

signature="t",

1990

1666

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

1991

1667

* 1000)

1992

1668

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

1993

1669

1994

1670

# Name - property

1995

1671

@dbus_annotations(

1996

1672

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

1997

1673

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

1998

1674

def Name_dbus_property(self):

1999

1675

return dbus.String(self.name)

2000

1676

2001

1677

# Fingerprint - property

2002

1678

@dbus_annotations(

2003

1679

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

2004

1680

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

2005

1681

def Fingerprint_dbus_property(self):

2006

1682

return dbus.String(self.fingerprint)

2007

1683

2008

1684

# Host - property

2009

1685

@dbus_service_property(_interface,

2010

1686

signature="s",

2013

1689

if value is None: # get

2014

1690

return dbus.String(self.host)

2015

1691

self.host = str(value)

2016

1692

2017

1693

# Created - property

2018

1694

@dbus_annotations(

2019

1695

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

2020

1696

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

2021

1697

def Created_dbus_property(self):

2022

1698

return datetime_to_dbus(self.created)

2023

1699

2024

1700

# LastEnabled - property

2025

1701

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

2026

1702

def LastEnabled_dbus_property(self):

2027

1703

return datetime_to_dbus(self.last_enabled)

2028

1704

2029

1705

# Enabled - property

2030

1706

@dbus_service_property(_interface,

2031

1707

signature="b",

2037

1713

self.enable()

2038

1714

else:

2039

1715

self.disable()

2040

1716

2041

1717

# LastCheckedOK - property

2042

1718

@dbus_service_property(_interface,

2043

1719

signature="s",

2047

1723

self.checked_ok()

2048

1724

return

2049

1725

return datetime_to_dbus(self.last_checked_ok)

2050

1726

2051

1727

# LastCheckerStatus - property

2052

1728

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

2053

1729

def LastCheckerStatus_dbus_property(self):

2054

1730

return dbus.Int16(self.last_checker_status)

2055

1731

2056

1732

# Expires - property

2057

1733

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

2058

1734

def Expires_dbus_property(self):

2059

1735

return datetime_to_dbus(self.expires)

2060

1736

2061

1737

# LastApprovalRequest - property

2062

1738

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

2063

1739

def LastApprovalRequest_dbus_property(self):

2064

1740

return datetime_to_dbus(self.last_approval_request)

2065

1741

2066

1742

# Timeout - property

2067

1743

@dbus_service_property(_interface,

2068

1744

signature="t",

2083

1759

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

2084

1760

is None):

2085

1761

return

2086

GLib.source_remove(self.disable_initiator_tag)

2087

self.disable_initiator_tag = GLib.timeout_add(

1762

gobject.source_remove(self.disable_initiator_tag)

1763

self.disable_initiator_tag = gobject.timeout_add(

2088

1764

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

2089

1765

self.disable)

2090

1766

2091

1767

# ExtendedTimeout - property

2092

1768

@dbus_service_property(_interface,

2093

1769

signature="t",

2097

1773

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

2098

1774

* 1000)

2099

1775

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

2100

1776

2101

1777

# Interval - property

2102

1778

@dbus_service_property(_interface,

2103

1779

signature="t",

2110

1786

return

2111

1787

if self.enabled:

2112

1788

# Reschedule checker run

2113

GLib.source_remove(self.checker_initiator_tag)

2114

self.checker_initiator_tag = GLib.timeout_add(

1789

gobject.source_remove(self.checker_initiator_tag)

1790

self.checker_initiator_tag = gobject.timeout_add(

2115

1791

value, self.start_checker)

2116

self.start_checker() # Start one now, too

2117

1792

self.start_checker() # Start one now, too

1793

2118

1794

# Checker - property

2119

1795

@dbus_service_property(_interface,

2120

1796

signature="s",

2123

1799

if value is None: # get

2124

1800

return dbus.String(self.checker_command)

2125

1801

self.checker_command = str(value)

2126

1802

2127

1803

# CheckerRunning - property

2128

1804

@dbus_service_property(_interface,

2129

1805

signature="b",

2135

1811

self.start_checker()

2136

1812

else:

2137

1813

self.stop_checker()

2138

1814

2139

1815

# ObjectPath - property

2140

1816

@dbus_annotations(

2141

1817

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

2142

1818

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

2143

1819

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

2144

1820

def ObjectPath_dbus_property(self):

2145

return self.dbus_object_path # is already a dbus.ObjectPath

2146

1821

return self.dbus_object_path # is already a dbus.ObjectPath

1822

2147

1823

# Secret = property

2148

1824

@dbus_annotations(

2149

1825

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

2154

1830

byte_arrays=True)

2155

1831

def Secret_dbus_property(self, value):

2156

1832

self.secret = bytes(value)

2157

1833

2158

1834

del _interface

2159

1835

2160

1836

2164

1840

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

2165

1841

if not self._pipe.recv():

2166

1842

raise KeyError(fpr)

2167

1843

2168

1844

def __getattribute__(self, name):

2169

1845

if name == '_pipe':

2170

1846

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

2173

1849

if data[0] == 'data':

2174

1850

return data[1]

2175

1851

if data[0] == 'function':

2176

1852

2177

1853

def func(*args, **kwargs):

2178

1854

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

2179

1855

return self._pipe.recv()[1]

2180

1856

2181

1857

return func

2182

1858

2183

1859

def __setattr__(self, name, value):

2184

1860

if name == '_pipe':

2185

1861

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

2188

1864

2189

1865

class ClientHandler(socketserver.BaseRequestHandler, object):

2190

1866

"""A class to handle client connections.

2191

1867

2192

1868

Instantiated once for each connection to handle it.

2193

1869

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

2194

1870

2195

1871

def handle(self):

2196

1872

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

2197

1873

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

2198

1874

str(self.client_address))

2199

1875

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

2200

1876

self.server.child_pipe.fileno())

2201

2202

session = gnutls.ClientSession(self.request)

2203

2204

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

2205

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

2206

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

2207

# "+DHE-DSS"))

1877

1878

session = gnutls.connection.ClientSession(

1879

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

1880

1881

# Note: gnutls.connection.X509Credentials is really a

1882

# generic GnuTLS certificate credentials object so long as

1883

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

1884

# here despite using OpenPGP certificates.

1885

1886

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

1887

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

1888

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

1889

# "+DHE-DSS"))

2208

1890

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

2209

1891

priority = self.server.gnutls_priority

2210

1892

if priority is None:

2211

1893

priority = "NORMAL"

2212

gnutls.priority_set_direct(session._c_object,

2213

priority.encode("utf-8"),

2214

None)

2215

1894

gnutls.library.functions.gnutls_priority_set_direct(

1895

session._c_object, priority, None)

1896

2216

1897

# Start communication using the Mandos protocol

2217

1898

# Get protocol number

2218

1899

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

2223

1904

except (ValueError, IndexError, RuntimeError) as error:

2224

1905

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

2225

1906

return

2226

1907

2227

1908

# Start GnuTLS connection

2228

1909

try:

2229

1910

session.handshake()

2230

except gnutls.Error as error:

1911

except gnutls.errors.GNUTLSError as error:

2231

1912

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

2232

1913

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

2233

1914

# established. Just abandon the request.

2234

1915

return

2235

1916

logger.debug("Handshake succeeded")

2236

1917

2237

1918

approval_required = False

2238

1919

try:

2239

1920

try:

2240

1921

fpr = self.fingerprint(

2241

1922

self.peer_certificate(session))

2242

except (TypeError, gnutls.Error) as error:

1923

except (TypeError,

1924

gnutls.errors.GNUTLSError) as error:

2243

1925

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

2244

1926

return

2245

1927

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

2246

1928

2247

1929

try:

2248

1930

client = ProxyClient(child_pipe, fpr,

2249

1931

self.client_address)

2250

1932

except KeyError:

2251

1933

return

2252

1934

2253

1935

if client.approval_delay:

2254

1936

delay = client.approval_delay

2255

1937

client.approvals_pending += 1

2256

1938

approval_required = True

2257

1939

2258

1940

while True:

2259

1941

if not client.enabled:

2260

1942

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

2263

1945

# Emit D-Bus signal

2264

1946

client.Rejected("Disabled")

2265

1947

return

2266

1948

2267

1949

if client.approved or not client.approval_delay:

2268

# We are approved or approval is disabled

1950

#We are approved or approval is disabled

2269

1951

break

2270

1952

elif client.approved is None:

2271

1953

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

2282

1964

# Emit D-Bus signal

2283

1965

client.Rejected("Denied")

2284

1966

return

2285

2286

# wait until timeout or approved

1967

1968

#wait until timeout or approved

2287

1969

time = datetime.datetime.now()

2288

1970

client.changedstate.acquire()

2289

1971

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

2302

1984

break

2303

1985

else:

2304

1986

delay -= time2 - time

2305

2306

try:

2307

session.send(client.secret)

2308

except gnutls.Error as error:

2309

logger.warning("gnutls send failed",

2310

exc_info=error)

2311

return

2312

1987

1988

sent_size = 0

1989

while sent_size < len(client.secret):

1990

try:

1991

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

1992

except gnutls.errors.GNUTLSError as error:

1993

logger.warning("gnutls send failed",

1994

exc_info=error)

1995

return

1996

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

1997

len(client.secret) - (sent_size

1998

+ sent))

1999

sent_size += sent

2000

2313

2001

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

2314

2002

# bump the timeout using extended_timeout

2315

2003

client.bump_timeout(client.extended_timeout)

2316

2004

if self.server.use_dbus:

2317

2005

# Emit D-Bus signal

2318

2006

client.GotSecret()

2319

2007

2320

2008

finally:

2321

2009

if approval_required:

2322

2010

client.approvals_pending -= 1

2323

2011

try:

2324

2012

session.bye()

2325

except gnutls.Error as error:

2013

except gnutls.errors.GNUTLSError as error:

2326

2014

logger.warning("GnuTLS bye failed",

2327

2015

exc_info=error)

2328

2016

2329

2017

@staticmethod

2330

2018

def peer_certificate(session):

2331

2019

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

2332

2020

# If not an OpenPGP certificate...

2333

if (gnutls.certificate_type_get(session._c_object)

2334

!= gnutls.CRT_OPENPGP):

2335

# ...return invalid data

2336

return b""

2021

if (gnutls.library.functions.gnutls_certificate_type_get(

2022

session._c_object)

2023

!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):

2024

# ...do the normal thing

2025

return session.peer_certificate

2337

2026

list_size = ctypes.c_uint(1)

2338

cert_list = (gnutls.certificate_get_peers

2027

cert_list = (gnutls.library.functions

2028

.gnutls_certificate_get_peers

2339

2029

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

2340

2030

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

2341

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

2031

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

2032

" certificate")

2342

2033

if list_size.value == 0:

2343

2034

return None

2344

2035

cert = cert_list[0]

2345

2036

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

2346

2037

2347

2038

@staticmethod

2348

2039

def fingerprint(openpgp):

2349

2040

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2350

2041

# New GnuTLS "datum" with the OpenPGP public key

2351

datum = gnutls.datum_t(

2042

datum = gnutls.library.types.gnutls_datum_t(

2352

2043

ctypes.cast(ctypes.c_char_p(openpgp),

2353

2044

ctypes.POINTER(ctypes.c_ubyte)),

2354

2045

ctypes.c_uint(len(openpgp)))

2355

2046

# New empty GnuTLS certificate

2356

crt = gnutls.openpgp_crt_t()

2357

gnutls.openpgp_crt_init(ctypes.byref(crt))

2047

crt = gnutls.library.types.gnutls_openpgp_crt_t()

2048

gnutls.library.functions.gnutls_openpgp_crt_init(

2049

ctypes.byref(crt))

2358

2050

# Import the OpenPGP public key into the certificate

2359

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

2360

gnutls.OPENPGP_FMT_RAW)

2051

gnutls.library.functions.gnutls_openpgp_crt_import(

2052

crt, ctypes.byref(datum),

2053

gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

2361

2054

# Verify the self signature in the key

2362

2055

crtverify = ctypes.c_uint()

2363

gnutls.openpgp_crt_verify_self(crt, 0,

2364

ctypes.byref(crtverify))

2056

gnutls.library.functions.gnutls_openpgp_crt_verify_self(

2057

crt, 0, ctypes.byref(crtverify))

2365

2058

if crtverify.value != 0:

2366

gnutls.openpgp_crt_deinit(crt)

2367

raise gnutls.CertificateSecurityError("Verify failed")

2059

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2060

raise gnutls.errors.CertificateSecurityError(

2061

"Verify failed")

2368

2062

# New buffer for the fingerprint

2369

2063

buf = ctypes.create_string_buffer(20)

2370

2064

buf_len = ctypes.c_size_t()

2371

2065

# Get the fingerprint from the certificate into the buffer

2372

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

2373

ctypes.byref(buf_len))

2066

gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint(

2067

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

2374

2068

# Deinit the certificate

2375

gnutls.openpgp_crt_deinit(crt)

2069

gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

2376

2070

# Convert the buffer to a Python bytestring

2377

2071

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

2378

2072

# Convert the bytestring to hexadecimal notation

2382

2076

2383

2077

class MultiprocessingMixIn(object):

2384

2078

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

2385

2079

2386

2080

def sub_process_main(self, request, address):

2387

2081

try:

2388

2082

self.finish_request(request, address)

2389

2083

except Exception:

2390

2084

self.handle_error(request, address)

2391

2085

self.close_request(request)

2392

2086

2393

2087

def process_request(self, request, address):

2394

2088

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

2395

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

2396

args=(request, address))

2089

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

2090

args = (request, address))

2397

2091

proc.start()

2398

2092

return proc

2399

2093

2400

2094

2401

2095

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2402

2096

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

2403

2097

2404

2098

def process_request(self, request, client_address):

2405

2099

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

2406

2100

2407

2101

This function creates a new pipe in self.pipe

2408

2102

"""

2409

2103

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2410

2104

2411

2105

proc = MultiprocessingMixIn.process_request(self, request,

2412

2106

client_address)

2413

2107

self.child_pipe.close()

2414

2108

self.add_pipe(parent_pipe, proc)

2415

2109

2416

2110

def add_pipe(self, parent_pipe, proc):

2417

2111

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

2418

2112

raise NotImplementedError()

2421

2115

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2422

2116

socketserver.TCPServer, object):

2423

2117

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

2424

2118

2425

2119

Attributes:

2426

2120

enabled: Boolean; whether this server is activated yet

2427

2121

interface: None or a network interface name (string)

2428

2122

use_ipv6: Boolean; to use IPv6 or not

2429

2123

"""

2430

2124

2431

2125

def __init__(self, server_address, RequestHandlerClass,

2432

2126

interface=None,

2433

2127

use_ipv6=True,

2443

2137

self.socketfd = socketfd

2444

2138

# Save the original socket.socket() function

2445

2139

self.socket_socket = socket.socket

2446

2447

2140

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

2448

#

2141

#

2449

2142

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

2450

2143

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

2451

2144

# patching socket.socket.)

2452

#

2145

#

2453

2146

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

2454

2147

@functools.wraps(socket.socket)

2455

2148

def socket_wrapper(*args, **kwargs):

2467

2160

# socket_wrapper(), if socketfd was set.

2468

2161

socketserver.TCPServer.__init__(self, server_address,

2469

2162

RequestHandlerClass)

2470

2163

2471

2164

def server_bind(self):

2472

2165

"""This overrides the normal server_bind() function

2473

2166

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

2474

2167

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

2475

global SO_BINDTODEVICE

2476

2168

if self.interface is not None:

2477

2169

if SO_BINDTODEVICE is None:

2478

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

2479

# common enough.

2480

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

2481

SO_BINDTODEVICE = 25

2482

try:

2483

self.socket.setsockopt(

2484

socket.SOL_SOCKET, SO_BINDTODEVICE,

2485

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

2486

except socket.error as error:

2487

if error.errno == errno.EPERM:

2488

logger.error("No permission to bind to"

2489

" interface %s", self.interface)

2490

elif error.errno == errno.ENOPROTOOPT:

2491

logger.error("SO_BINDTODEVICE not available;"

2492

" cannot bind to interface %s",

2493

self.interface)

2494

elif error.errno == errno.ENODEV:

2495

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

2496

" cannot bind", self.interface)

2497

else:

2498

raise

2170

logger.error("SO_BINDTODEVICE does not exist;"

2171

" cannot bind to interface %s",

2172

self.interface)

2173

else:

2174

try:

2175

self.socket.setsockopt(

2176

socket.SOL_SOCKET, SO_BINDTODEVICE,

2177

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

2178

except socket.error as error:

2179

if error.errno == errno.EPERM:

2180

logger.error("No permission to bind to"

2181

" interface %s", self.interface)

2182

elif error.errno == errno.ENOPROTOOPT:

2183

logger.error("SO_BINDTODEVICE not available;"

2184

" cannot bind to interface %s",

2185

self.interface)

2186

elif error.errno == errno.ENODEV:

2187

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

2188

" cannot bind", self.interface)

2189

else:

2190

raise

2499

2191

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

2500

2192

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

2501

2193

if not self.server_address[0]:

2502

2194

if self.address_family == socket.AF_INET6:

2503

any_address = "::" # in6addr_any

2195

any_address = "::" # in6addr_any

2504

2196

else:

2505

any_address = "0.0.0.0" # INADDR_ANY

2197

any_address = "0.0.0.0" # INADDR_ANY

2506

2198

self.server_address = (any_address,

2507

2199

self.server_address[1])

2508

2200

elif not self.server_address[1]:

2518

2210

2519

2211

class MandosServer(IPv6_TCPServer):

2520

2212

"""Mandos server.

2521

2213

2522

2214

Attributes:

2523

2215

clients: set of Client objects

2524

2216

gnutls_priority GnuTLS priority string

2525

2217

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

2526

2527

Assumes a GLib.MainLoop event loop.

2218

2219

Assumes a gobject.MainLoop event loop.

2528

2220

"""

2529

2221

2530

2222

def __init__(self, server_address, RequestHandlerClass,

2531

2223

interface=None,

2532

2224

use_ipv6=True,

2542

2234

self.gnutls_priority = gnutls_priority

2543

2235

IPv6_TCPServer.__init__(self, server_address,

2544

2236

RequestHandlerClass,

2545

interface=interface,

2546

use_ipv6=use_ipv6,

2547

socketfd=socketfd)

2548

2237

interface = interface,

2238

use_ipv6 = use_ipv6,

2239

socketfd = socketfd)

2240

2549

2241

def server_activate(self):

2550

2242

if self.enabled:

2551

2243

return socketserver.TCPServer.server_activate(self)

2552

2244

2553

2245

def enable(self):

2554

2246

self.enabled = True

2555

2247

2556

2248

def add_pipe(self, parent_pipe, proc):

2557

2249

# Call "handle_ipc" for both data and EOF events

2558

GLib.io_add_watch(

2250

gobject.io_add_watch(

2559

2251

parent_pipe.fileno(),

2560

GLib.IO_IN | GLib.IO_HUP,

2252

gobject.IO_IN | gobject.IO_HUP,

2561

2253

functools.partial(self.handle_ipc,

2562

parent_pipe=parent_pipe,

2563

proc=proc))

2564

2254

parent_pipe = parent_pipe,

2255

proc = proc))

2256

2565

2257

def handle_ipc(self, source, condition,

2566

2258

parent_pipe=None,

2567

proc=None,

2259

proc = None,

2568

2260

client_object=None):

2569

2261

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

2570

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

2262

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

2571

2263

# Wait for other process to exit

2572

2264

proc.join()

2573

2265

return False

2574

2266

2575

2267

# Read a request from the child

2576

2268

request = parent_pipe.recv()

2577

2269

command = request[0]

2578

2270

2579

2271

if command == 'init':

2580

2272

fpr = request[1]

2581

2273

address = request[2]

2582

2583

for c in self.clients.values():

2274

2275

for c in self.clients.itervalues():

2584

2276

if c.fingerprint == fpr:

2585

2277

client = c

2586

2278

break

2593

2285

address[0])

2594

2286

parent_pipe.send(False)

2595

2287

return False

2596

2597

GLib.io_add_watch(

2288

2289

gobject.io_add_watch(

2598

2290

parent_pipe.fileno(),

2599

GLib.IO_IN | GLib.IO_HUP,

2291

gobject.IO_IN | gobject.IO_HUP,

2600

2292

functools.partial(self.handle_ipc,

2601

parent_pipe=parent_pipe,

2602

proc=proc,

2603

client_object=client))

2293

parent_pipe = parent_pipe,

2294

proc = proc,

2295

client_object = client))

2604

2296

parent_pipe.send(True)

2605

2297

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

2606

2298

# same fileno

2609

2301

funcname = request[1]

2610

2302

args = request[2]

2611

2303

kwargs = request[3]

2612

2304

2613

2305

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

2614

2306

funcname)(*args,

2615

2307

**kwargs)))

2616

2308

2617

2309

if command == 'getattr':

2618

2310

attrname = request[1]

2619

2311

if isinstance(client_object.__getattribute__(attrname),

2622

2314

else:

2623

2315

parent_pipe.send((

2624

2316

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

2625

2317

2626

2318

if command == 'setattr':

2627

2319

attrname = request[1]

2628

2320

value = request[2]

2629

2321

setattr(client_object, attrname, value)

2630

2322

2631

2323

return True

2632

2324

2633

2325

2634

2326

def rfc3339_duration_to_delta(duration):

2635

2327

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

2636

2328

2637

2329

>>> rfc3339_duration_to_delta("P7D")

2638

2330

datetime.timedelta(7)

2639

2331

>>> rfc3339_duration_to_delta("PT60S")

2649

2341

>>> rfc3339_duration_to_delta("P1DT3M20S")

2650

2342

datetime.timedelta(1, 200)

2651

2343

"""

2652

2344

2653

2345

# Parsing an RFC 3339 duration with regular expressions is not

2654

2346

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

2655

2347

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

2656

2348

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

2657

2349

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

2658

2350

# avoid excessive use of external libraries.

2659

2351

2660

2352

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

2661

2353

Token = collections.namedtuple("Token", (

2662

2354

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

2695

2387

frozenset((token_year, token_month,

2696

2388

token_day, token_time,

2697

2389

token_week)))

2698

# Define starting values:

2699

# Value so far

2700

value = datetime.timedelta()

2390

# Define starting values

2391

value = datetime.timedelta() # Value so far

2701

2392

found_token = None

2702

# Following valid tokens

2703

followers = frozenset((token_duration, ))

2704

# String left to parse

2705

s = duration

2393

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

2394

s = duration # String left to parse

2706

2395

# Loop until end token is found

2707

2396

while found_token is not token_end:

2708

2397

# Search for any currently valid tokens

2732

2421

2733

2422

def string_to_delta(interval):

2734

2423

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

2735

2424

2736

2425

>>> string_to_delta('7d')

2737

2426

datetime.timedelta(7)

2738

2427

>>> string_to_delta('60s')

2746

2435

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

2747

2436

datetime.timedelta(0, 330)

2748

2437

"""

2749

2438

2750

2439

try:

2751

2440

return rfc3339_duration_to_delta(interval)

2752

2441

except ValueError:

2753

2442

pass

2754

2443

2755

2444

timevalue = datetime.timedelta(0)

2756

2445

for s in interval.split():

2757

2446

try:

2775

2464

return timevalue

2776

2465

2777

2466

2778

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

2467

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

2779

2468

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

2780

2469

2781

2470

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

2782

2471

if os.fork():

2783

2472

sys.exit()

2801

2490

2802

2491

2803

2492

def main():

2804

2493

2805

2494

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

2806

2495

# Parsing of options, both command line and config file

2807

2496

2808

2497

parser = argparse.ArgumentParser()

2809

2498

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

2810

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

2499

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

2811

2500

help="show version number and exit")

2812

2501

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

2813

2502

help="Bind to interface IF")

2849

2538

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

2850

2539

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

2851

2540

default=None)

2852

2541

2853

2542

options = parser.parse_args()

2854

2543

2855

2544

if options.check:

2856

2545

import doctest

2857

2546

fail_count, test_count = doctest.testmod()

2858

2547

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

2859

2548

2860

2549

# Default values for config file for server-global settings

2861

server_defaults = {"interface": "",

2862

"address": "",

2863

"port": "",

2864

"debug": "False",

2865

"priority":

2866

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

2867

":+SIGN-DSA-SHA256",

2868

"servicename": "Mandos",

2869

"use_dbus": "True",

2870

"use_ipv6": "True",

2871

"debuglevel": "",

2872

"restore": "True",

2873

"socket": "",

2874

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

2875

"foreground": "False",

2876

"zeroconf": "True",

2877

}

2878

2550

server_defaults = { "interface": "",

2551

"address": "",

2552

"port": "",

2553

"debug": "False",

2554

"priority":

2555

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

2556

":+SIGN-DSA-SHA256",

2557

"servicename": "Mandos",

2558

"use_dbus": "True",

2559

"use_ipv6": "True",

2560

"debuglevel": "",

2561

"restore": "True",

2562

"socket": "",

2563

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

2564

"foreground": "False",

2565

"zeroconf": "True",

2566

}

2567

2879

2568

# Parse config file for server-global settings

2880

2569

server_config = configparser.SafeConfigParser(server_defaults)

2881

2570

del server_defaults

2899

2588

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

2900

2589

["socket"])

2901

2590

del server_config

2902

2591

2903

2592

# Override the settings from the config file with command line

2904

2593

# options, if set.

2905

2594

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

2923

2612

if server_settings["debug"]:

2924

2613

server_settings["foreground"] = True

2925

2614

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

2926

2615

2927

2616

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

2928

2617

2929

2618

if (not server_settings["zeroconf"]

2930

2619

and not (server_settings["port"]

2931

2620

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

2932

2621

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

2933

2622

2934

2623

# For convenience

2935

2624

debug = server_settings["debug"]

2936

2625

debuglevel = server_settings["debuglevel"]

2940

2629

stored_state_file)

2941

2630

foreground = server_settings["foreground"]

2942

2631

zeroconf = server_settings["zeroconf"]

2943

2632

2944

2633

if debug:

2945

2634

initlogger(debug, logging.DEBUG)

2946

2635

else:

2949

2638

else:

2950

2639

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

2951

2640

initlogger(debug, level)

2952

2641

2953

2642

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

2954

2643

syslogger.setFormatter(

2955

2644

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

2956

2645

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

2957

2646

server_settings["servicename"])))

2958

2647

2959

2648

# Parse config file with clients

2960

2649

client_config = configparser.SafeConfigParser(Client

2961

2650

.client_defaults)

2962

2651

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

2963

2652

"clients.conf"))

2964

2653

2965

2654

global mandos_dbus_service

2966

2655

mandos_dbus_service = None

2967

2656

2968

2657

socketfd = None

2969

2658

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

2970

2659

socketfd = server_settings["socket"]

2986

2675

except IOError as e:

2987

2676

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

2988

2677

exc_info=e)

2989

2990

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

2991

("mandos", "mandos"),

2992

("nobody", "nogroup")):

2678

2679

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

2993

2680

try:

2994

2681

uid = pwd.getpwnam(name).pw_uid

2995

gid = pwd.getpwnam(group).pw_gid

2682

gid = pwd.getpwnam(name).pw_gid

2996

2683

break

2997

2684

except KeyError:

2998

2685

continue

3002

2689

try:

3003

2690

os.setgid(gid)

3004

2691

os.setuid(uid)

3005

if debug:

3006

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

3007

gid))

3008

2692

except OSError as error:

3009

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

3010

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

3011

2693

if error.errno != errno.EPERM:

3012

2694

raise

3013

2695

3014

2696

if debug:

3015

2697

# Enable all possible GnuTLS debugging

3016

2698

3017

2699

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

3018

2700

# - GnuTLS manual

3019

gnutls.global_set_log_level(11)

3020

3021

@gnutls.log_func

2701

gnutls.library.functions.gnutls_global_set_log_level(11)

2702

2703

@gnutls.library.types.gnutls_log_func

3022

2704

def debug_gnutls(level, string):

3023

2705

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

3024

3025

gnutls.global_set_log_function(debug_gnutls)

3026

2706

2707

gnutls.library.functions.gnutls_global_set_log_function(

2708

debug_gnutls)

2709

3027

2710

# Redirect stdin so all checkers get /dev/null

3028

2711

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

3029

2712

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

3030

2713

if null > 2:

3031

2714

os.close(null)

3032

2715

3033

2716

# Need to fork before connecting to D-Bus

3034

2717

if not foreground:

3035

2718

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

3036

2719

daemon()

3037

3038

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

3039

# to inform GLib that threads will be used.

3040

GLib.threads_init()

3041

2720

2721

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

2722

# need to inform gobject that threads will be used.

2723

gobject.threads_init()

2724

3042

2725

global main_loop

3043

2726

# From the Avahi example code

3044

2727

DBusGMainLoop(set_as_default=True)

3045

main_loop = GLib.MainLoop()

2728

main_loop = gobject.MainLoop()

3046

2729

bus = dbus.SystemBus()

3047

2730

# End of Avahi example code

3048

2731

if use_dbus:

3061

2744

if zeroconf:

3062

2745

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

3063

2746

service = AvahiServiceToSyslog(

3064

name=server_settings["servicename"],

3065

servicetype="_mandos._tcp",

3066

protocol=protocol,

3067

bus=bus)

2747

name = server_settings["servicename"],

2748

servicetype = "_mandos._tcp",

2749

protocol = protocol,

2750

bus = bus)

3068

2751

if server_settings["interface"]:

3069

2752

service.interface = if_nametoindex(

3070

2753

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

3071

2754

3072

2755

global multiprocessing_manager

3073

2756

multiprocessing_manager = multiprocessing.Manager()

3074

2757

3075

2758

client_class = Client

3076

2759

if use_dbus:

3077

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

3078

2760

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

2761

3079

2762

client_settings = Client.config_parser(client_config)

3080

2763

old_client_settings = {}

3081

2764

clients_data = {}

3082

2765

3083

2766

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

3084

2767

global wnull

3085

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

2768

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

3086

2769

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

3087

2770

# mode

3088

2771

if debug or not foreground:

3089

2772

wnull.close()

3090

2773

3091

2774

# Get client data and settings from last running state.

3092

2775

if server_settings["restore"]:

3093

2776

try:

3094

2777

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

3095

if sys.version_info.major == 2:

3096

clients_data, old_client_settings = pickle.load(

3097

stored_state)

3098

else:

3099

bytes_clients_data, bytes_old_client_settings = (

3100

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

3101

# Fix bytes to strings

3102

# clients_data

3103

# .keys()

3104

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

3105

if isinstance(key, bytes)

3106

else key): value

3107

for key, value in

3108

bytes_clients_data.items()}

3109

del bytes_clients_data

3110

for key in clients_data:

3111

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

3112

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

3113

for k, v in

3114

clients_data[key].items()}

3115

clients_data[key] = value

3116

# .client_structure

3117

value["client_structure"] = [

3118

(s.decode("utf-8")

3119

if isinstance(s, bytes)

3120

else s) for s in

3121

value["client_structure"]]

3122

# .name & .host

3123

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

3124

if isinstance(value[k], bytes):

3125

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

3126

# old_client_settings

3127

# .keys()

3128

old_client_settings = {

3129

(key.decode("utf-8")

3130

if isinstance(key, bytes)

3131

else key): value

3132

for key, value in

3133

bytes_old_client_settings.items()}

3134

del bytes_old_client_settings

3135

# .host

3136

for value in old_client_settings.values():

3137

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

3138

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

3139

.decode("utf-8"))

2778

clients_data, old_client_settings = pickle.load(

2779

stored_state)

3140

2780

os.remove(stored_state_path)

3141

2781

except IOError as e:

3142

2782

if e.errno == errno.ENOENT:

3150

2790

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

3151

2791

"EOFError:",

3152

2792

exc_info=e)

3153

2793

3154

2794

with PGPEngine() as pgp:

3155

2795

for client_name, client in clients_data.items():

3156

2796

# Skip removed clients

3157

2797

if client_name not in client_settings:

3158

2798

continue

3159

2799

3160

2800

# Decide which value to use after restoring saved state.

3161

2801

# We have three different values: Old config file,

3162

2802

# new config file, and saved state.

3173

2813

client[name] = value

3174

2814

except KeyError:

3175

2815

pass

3176

2816

3177

2817

# Clients who has passed its expire date can still be

3178

2818

# enabled if its last checker was successful. A Client

3179

2819

# whose checker succeeded before we stored its state is

3212

2852

client_name))

3213

2853

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

3214

2854

["secret"])

3215

2855

3216

2856

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

3217

2857

for client_name in (set(old_client_settings)

3218

2858

- set(client_settings)):

3220

2860

for client_name in (set(client_settings)

3221

2861

- set(old_client_settings)):

3222

2862

clients_data[client_name] = client_settings[client_name]

3223

2863

3224

2864

# Create all client objects

3225

2865

for client_name, client in clients_data.items():

3226

2866

tcp_server.clients[client_name] = client_class(

3227

name=client_name,

3228

settings=client,

3229

server_settings=server_settings)

3230

2867

name = client_name,

2868

settings = client,

2869

server_settings = server_settings)

2870

3231

2871

if not tcp_server.clients:

3232

2872

logger.warning("No clients defined")

3233

2873

3234

2874

if not foreground:

3235

2875

if pidfile is not None:

3236

2876

pid = os.getpid()

3242

2882

pidfilename, pid)

3243

2883

del pidfile

3244

2884

del pidfilename

3245

3246

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

3247

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3248

lambda: main_loop.quit() and False)

3249

2885

2886

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

2887

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

2888

3250

2889

if use_dbus:

3251

2890

3252

2891

@alternate_dbus_interfaces(

3253

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

2892

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

3254

2893

class MandosDBusService(DBusObjectWithObjectManager):

3255

2894

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

3256

2895

3257

2896

def __init__(self):

3258

2897

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

3259

2898

3260

2899

_interface = "se.recompile.Mandos"

3261

2900

3262

2901

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

3263

2902

def ClientAdded(self, objpath):

3264

2903

"D-Bus signal"

3265

2904

pass

3266

2905

3267

2906

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

3268

2907

def ClientNotFound(self, fingerprint, address):

3269

2908

"D-Bus signal"

3270

2909

pass

3271

2910

3272

2911

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

3273

2912

"true"})

3274

2913

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

3275

2914

def ClientRemoved(self, objpath, name):

3276

2915

"D-Bus signal"

3277

2916

pass

3278

2917

3279

2918

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

3280

2919

"true"})

3281

2920

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

3282

2921

def GetAllClients(self):

3283

2922

"D-Bus method"

3284

2923

return dbus.Array(c.dbus_object_path for c in

3285

tcp_server.clients.values())

3286

2924

tcp_server.clients.itervalues())

2925

3287

2926

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

3288

2927

"true"})

3289

2928

@dbus.service.method(_interface,

3291

2930

def GetAllClientsWithProperties(self):

3292

2931

"D-Bus method"

3293

2932

return dbus.Dictionary(

3294

{c.dbus_object_path: c.GetAll(

2933

{ c.dbus_object_path: c.GetAll(

3295

2934

"se.recompile.Mandos.Client")

3296

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

2935

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

3297

2936

signature="oa{sv}")

3298

2937

3299

2938

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

3300

2939

def RemoveClient(self, object_path):

3301

2940

"D-Bus method"

3302

for c in tcp_server.clients.values():

2941

for c in tcp_server.clients.itervalues():

3303

2942

if c.dbus_object_path == object_path:

3304

2943

del tcp_server.clients[c.name]

3305

2944

c.remove_from_connection()

3309

2948

self.client_removed_signal(c)

3310

2949

return

3311

2950

raise KeyError(object_path)

3312

2951

3313

2952

del _interface

3314

2953

3315

2954

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3316

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

2955

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

3317

2956

def GetManagedObjects(self):

3318

2957

"""D-Bus method"""

3319

2958

return dbus.Dictionary(

3320

{client.dbus_object_path:

3321

dbus.Dictionary(

3322

{interface: client.GetAll(interface)

3323

for interface in

3324

client._get_all_interface_names()})

3325

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

3326

2959

{ client.dbus_object_path:

2960

dbus.Dictionary(

2961

{ interface: client.GetAll(interface)

2962

for interface in

2963

client._get_all_interface_names()})

2964

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

2965

3327

2966

def client_added_signal(self, client):

3328

2967

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

3329

2968

if use_dbus:

3331

2970

self.InterfacesAdded(

3332

2971

client.dbus_object_path,

3333

2972

dbus.Dictionary(

3334

{interface: client.GetAll(interface)

3335

for interface in

3336

client._get_all_interface_names()}))

2973

{ interface: client.GetAll(interface)

2974

for interface in

2975

client._get_all_interface_names()}))

3337

2976

# Old signal

3338

2977

self.ClientAdded(client.dbus_object_path)

3339

2978

3340

2979

def client_removed_signal(self, client):

3341

2980

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

3342

2981

if use_dbus:

3347

2986

# Old signal

3348

2987

self.ClientRemoved(client.dbus_object_path,

3349

2988

client.name)

3350

2989

3351

2990

mandos_dbus_service = MandosDBusService()

3352

3353

# Save modules to variables to exempt the modules from being

3354

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

3355

mp = multiprocessing

3356

wn = wnull

3357

2991

3358

2992

def cleanup():

3359

2993

"Cleanup function; run on exit"

3360

2994

if zeroconf:

3361

2995

service.cleanup()

3362

3363

mp.active_children()

3364

wn.close()

2996

2997

multiprocessing.active_children()

2998

wnull.close()

3365

2999

if not (tcp_server.clients or client_settings):

3366

3000

return

3367

3001

3368

3002

# Store client before exiting. Secrets are encrypted with key

3369

3003

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

3370

3004

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

3371

3005

clients = {}

3372

3006

with PGPEngine() as pgp:

3373

for client in tcp_server.clients.values():

3007

for client in tcp_server.clients.itervalues():

3374

3008

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

3375

3009

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

3376

3010

key)

3377

3011

client_dict = {}

3378

3012

3379

3013

# A list of attributes that can not be pickled

3380

3014

# + secret.

3381

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

3382

"checker", "server_settings"}

3015

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

3016

"checker", "server_settings" }

3383

3017

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

3384

3018

.Object):

3385

3019

exclude.add(name)

3386

3020

3387

3021

client_dict["encrypted_secret"] = (client

3388

3022

.encrypted_secret)

3389

3023

for attr in client.client_structure:

3390

3024

if attr not in exclude:

3391

3025

client_dict[attr] = getattr(client, attr)

3392

3026

3393

3027

clients[client.name] = client_dict

3394

3028

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

3395

3029

3396

3030

try:

3397

3031

with tempfile.NamedTemporaryFile(

3398

3032

mode='wb',

3400

3034

prefix='clients-',

3401

3035

dir=os.path.dirname(stored_state_path),

3402

3036

delete=False) as stored_state:

3403

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

3404

protocol=2)

3037

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

3405

3038

tempname = stored_state.name

3406

3039

os.rename(tempname, stored_state_path)

3407

3040

except (IOError, OSError) as e:

3417

3050

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

3418

3051

exc_info=e)

3419

3052

raise

3420

3053

3421

3054

# Delete all clients, and settings from config

3422

3055

while tcp_server.clients:

3423

3056

name, client = tcp_server.clients.popitem()

3426

3059

# Don't signal the disabling

3427

3060

client.disable(quiet=True)

3428

3061

# Emit D-Bus signal for removal

3429

if use_dbus:

3430

mandos_dbus_service.client_removed_signal(client)

3062

mandos_dbus_service.client_removed_signal(client)

3431

3063

client_settings.clear()

3432

3064

3433

3065

atexit.register(cleanup)

3434

3435

for client in tcp_server.clients.values():

3066

3067

for client in tcp_server.clients.itervalues():

3436

3068

if use_dbus:

3437

3069

# Emit D-Bus signal for adding

3438

3070

mandos_dbus_service.client_added_signal(client)

3439

3071

# Need to initiate checking of clients

3440

3072

if client.enabled:

3441

3073

client.init_checker()

3442

3074

3443

3075

tcp_server.enable()

3444

3076

tcp_server.server_activate()

3445

3077

3446

3078

# Find out what port we got

3447

3079

if zeroconf:

3448

3080

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

3453

3085

else: # IPv4

3454

3086

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

3455

3087

*tcp_server.socket.getsockname())

3456

3457

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

3458

3088

3089

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

3090

3459

3091

try:

3460

3092

if zeroconf:

3461

3093

# From the Avahi example code

3466

3098

cleanup()

3467

3099

sys.exit(1)

3468

3100

# End of Avahi example code

3469

3470

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

3471

lambda *args, **kwargs:

3472

(tcp_server.handle_request

3473

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

3474

3101

3102

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

3103

lambda *args, **kwargs:

3104

(tcp_server.handle_request

3105

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

3106

3475

3107

logger.debug("Starting main loop")

3476

3108

main_loop.run()

3477

3109

except AvahiError as error: