/mandos/trunk : revision 237.4.92

1

#!/usr/bin/python2.7

1

#!/usr/bin/python

2

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

3

#

3

#

4

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

5

#

5

#

6

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

7

# service publisher, downloaded from

8

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

9

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

10

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

11

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

12

#

12

#

13

# Everything else is

14

15

16

#

17

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

18

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

14

15

16

#

17

# This file is part of Mandos.

18

#

19

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

20

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

19

21

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

20

22

# (at your option) any later version.

21

23

#

22

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

23

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

24

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

25

# WITHOUT ANY WARRANTY; without even the implied warranty of

24

26

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

25

27

# GNU General Public License for more details.

26

#

28

#

27

29

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

28

# along with this program. If not, see

29

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

30

#

30

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

31

#

31

32

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

32

#

33

#

33

34

35

from __future__ import (division, absolute_import, print_function,

35

36

unicode_literals)

36

37

from future_builtins import *

38

try:

39

from future_builtins import *

40

except ImportError:

41

pass

38

42

39

43

try:

40

44

import SocketServer as socketserver

76

80

77

81

import dbus

78

82

import dbus.service

79

try:

80

import gobject

81

except ImportError:

82

from gi.repository import GObject as gobject

83

import avahi

83

from gi.repository import GLib

84

from dbus.mainloop.glib import DBusGMainLoop

85

import ctypes

86

import ctypes.util

87

import xml.dom.minidom

88

import inspect

89

90

# Try to find the value of SO_BINDTODEVICE:

90

91

try:

92

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

93

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

91

94

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

92

95

except AttributeError:

93

96

try:

97

# This is where SO_BINDTODEVICE was up to and including Python

98

# 2.6, and also 3.2:

94

99

from IN import SO_BINDTODEVICE

95

100

except ImportError:

96

SO_BINDTODEVICE = None

101

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

102

# Try running the C preprocessor:

103

try:

104

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

105

"/dev/stdin"],

106

stdin=subprocess.PIPE,

107

stdout=subprocess.PIPE)

108

stdout = cc.communicate(

109

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

110

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

111

except (OSError, ValueError, IndexError):

112

# No value found

113

SO_BINDTODEVICE = None

97

114

98

115

if sys.version_info.major == 2:

99

116

str = unicode

100

117

101

version = "1.7.1"

118

version = "1.7.16"

102

119

stored_state_file = "clients.pickle"

103

120

104

121

logger = logging.getLogger()

108

125

if_nametoindex = ctypes.cdll.LoadLibrary(

109

126

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

110

127

except (OSError, AttributeError):

111

128

112

129

def if_nametoindex(interface):

113

130

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

114

131

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

119

136

return interface_index

120

137

121

138

139

def copy_function(func):

140

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

141

if sys.version_info.major == 2:

142

return types.FunctionType(func.func_code,

143

func.func_globals,

144

func.func_name,

145

func.func_defaults,

146

func.func_closure)

147

else:

148

return types.FunctionType(func.__code__,

149

func.__globals__,

150

func.__name__,

151

func.__defaults__,

152

func.__closure__)

153

154

122

155

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

123

156

"""init logger and add loglevel"""

124

157

125

158

global syslogger

126

159

syslogger = (logging.handlers.SysLogHandler(

127

facility = logging.handlers.SysLogHandler.LOG_DAEMON,

128

address = "/dev/log"))

160

facility=logging.handlers.SysLogHandler.LOG_DAEMON,

161

address="/dev/log"))

129

162

syslogger.setFormatter(logging.Formatter

130

163

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

131

164

' %(message)s'))

132

165

logger.addHandler(syslogger)

133

166

134

167

if debug:

135

168

console = logging.StreamHandler()

136

169

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

148

181

149

182

class PGPEngine(object):

150

183

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

151

184

152

185

def __init__(self):

153

186

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

187

self.gpg = "gpg"

188

try:

189

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

190

for line in output.splitlines():

191

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

192

if name == "gpg":

193

self.gpg = path

194

break

195

except OSError as e:

196

if e.errno != errno.ENOENT:

197

raise

154

198

self.gnupgargs = ['--batch',

155

'--home', self.tempdir,

199

'--homedir', self.tempdir,

156

200

'--force-mdc',

157

'--quiet',

158

'--no-use-agent']

159

201

'--quiet']

202

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

203

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

204

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

205

160

206

def __enter__(self):

161

207

return self

162

208

163

209

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

164

210

self._cleanup()

165

211

return False

166

212

167

213

def __del__(self):

168

214

self._cleanup()

169

215

170

216

def _cleanup(self):

171

217

if self.tempdir is not None:

172

218

# Delete contents of tempdir

173

219

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

174

topdown = False):

220

topdown=False):

175

221

for filename in files:

176

222

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

177

223

for dirname in dirs:

179

225

# Remove tempdir

180

226

os.rmdir(self.tempdir)

181

227

self.tempdir = None

182

228

183

229

def password_encode(self, password):

184

230

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

185

231

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

190

236

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

191

237

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

192

238

return encoded

193

239

194

240

def encrypt(self, data, password):

195

241

passphrase = self.password_encode(password)

196

242

with tempfile.NamedTemporaryFile(

197

243

dir=self.tempdir) as passfile:

198

244

passfile.write(passphrase)

199

245

passfile.flush()

200

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

246

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

201

247

'--passphrase-file',

202

248

passfile.name]

203

249

+ self.gnupgargs,

204

stdin = subprocess.PIPE,

205

stdout = subprocess.PIPE,

206

stderr = subprocess.PIPE)

207

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

250

stdin=subprocess.PIPE,

251

stdout=subprocess.PIPE,

252

stderr=subprocess.PIPE)

253

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

208

254

if proc.returncode != 0:

209

255

raise PGPError(err)

210

256

return ciphertext

211

257

212

258

def decrypt(self, data, password):

213

259

passphrase = self.password_encode(password)

214

260

with tempfile.NamedTemporaryFile(

215

dir = self.tempdir) as passfile:

261

dir=self.tempdir) as passfile:

216

262

passfile.write(passphrase)

217

263

passfile.flush()

218

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

264

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

219

265

'--passphrase-file',

220

266

passfile.name]

221

267

+ self.gnupgargs,

222

stdin = subprocess.PIPE,

223

stdout = subprocess.PIPE,

224

stderr = subprocess.PIPE)

225

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

268

stdin=subprocess.PIPE,

269

stdout=subprocess.PIPE,

270

stderr=subprocess.PIPE)

271

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

226

272

if proc.returncode != 0:

227

273

raise PGPError(err)

228

274

return decrypted_plaintext

229

275

230

276

277

# Pretend that we have an Avahi module

278

class Avahi(object):

279

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

280

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

281

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

282

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

283

PROTO_INET = 0 # avahi-common/address.h

284

PROTO_INET6 = 1 # avahi-common/address.h

285

DBUS_NAME = "org.freedesktop.Avahi"

286

DBUS_INTERFACE_ENTRY_GROUP = DBUS_NAME + ".EntryGroup"

287

DBUS_INTERFACE_SERVER = DBUS_NAME + ".Server"

288

DBUS_PATH_SERVER = "/"

289

290

def string_array_to_txt_array(self, t):

291

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

292

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

293

ENTRY_GROUP_ESTABLISHED = 2 # avahi-common/defs.h

294

ENTRY_GROUP_COLLISION = 3 # avahi-common/defs.h

295

ENTRY_GROUP_FAILURE = 4 # avahi-common/defs.h

296

SERVER_INVALID = 0 # avahi-common/defs.h

297

SERVER_REGISTERING = 1 # avahi-common/defs.h

298

SERVER_RUNNING = 2 # avahi-common/defs.h

299

SERVER_COLLISION = 3 # avahi-common/defs.h

300

SERVER_FAILURE = 4 # avahi-common/defs.h

301

avahi = Avahi()

302

303

231

304

class AvahiError(Exception):

232

305

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

233

306

self.value = value

245

318

246

319

class AvahiService(object):

247

320

"""An Avahi (Zeroconf) service.

248

321

249

322

Attributes:

250

323

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

251

324

Used to optionally bind to the specified interface.

263

336

server: D-Bus Server

264

337

bus: dbus.SystemBus()

265

338

"""

266

339

267

340

def __init__(self,

268

interface = avahi.IF_UNSPEC,

269

name = None,

270

servicetype = None,

271

port = None,

272

TXT = None,

273

domain = "",

274

host = "",

275

max_renames = 32768,

276

protocol = avahi.PROTO_UNSPEC,

277

bus = None):

341

interface=avahi.IF_UNSPEC,

342

name=None,

343

servicetype=None,

344

port=None,

345

TXT=None,

346

domain="",

347

host="",

348

max_renames=32768,

349

protocol=avahi.PROTO_UNSPEC,

350

bus=None):

278

351

self.interface = interface

279

352

self.name = name

280

353

self.type = servicetype

289

362

self.server = None

290

363

self.bus = bus

291

364

self.entry_group_state_changed_match = None

292

365

293

366

def rename(self, remove=True):

294

367

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

295

368

if self.rename_count >= self.max_renames:

315

388

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

316

389

self.cleanup()

317

390

os._exit(1)

318

391

319

392

def remove(self):

320

393

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

321

394

if self.entry_group_state_changed_match is not None:

323

396

self.entry_group_state_changed_match = None

324

397

if self.group is not None:

325

398

self.group.Reset()

326

399

327

400

def add(self):

328

401

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

329

402

self.remove()

346

419

dbus.UInt16(self.port),

347

420

avahi.string_array_to_txt_array(self.TXT))

348

421

self.group.Commit()

349

422

350

423

def entry_group_state_changed(self, state, error):

351

424

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

352

425

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

353

426

354

427

if state == avahi.ENTRY_GROUP_ESTABLISHED:

355

428

logger.debug("Zeroconf service established.")

356

429

elif state == avahi.ENTRY_GROUP_COLLISION:

360

433

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

361

434

str(error))

362

435

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

363

436

364

437

def cleanup(self):

365

438

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

366

439

if self.group is not None:

371

444

pass

372

445

self.group = None

373

446

self.remove()

374

447

375

448

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

376

449

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

377

450

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

406

479

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

407

480

else:

408

481

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

409

482

410

483

def activate(self):

411

484

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

412

485

if self.server is None:

429

502

.format(self.name)))

430

503

return ret

431

504

505

432

506

# Pretend that we have a GnuTLS module

433

507

class GnuTLS(object):

434

508

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

435

509

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

436

437

_library = ctypes.cdll.LoadLibrary(

438

ctypes.util.find_library("gnutls"))

439

_need_version = "3.3.0"

510

511

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

512

if library is None:

513

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

514

_library = ctypes.cdll.LoadLibrary(library)

515

del library

516

_need_version = b"3.3.0"

517

440

518

def __init__(self):

441

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

442

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

443

# happens.

444

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

445

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

446

.format(self._need_version))

447

519

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

520

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

521

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

522

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

523

.format(self._need_version))

524

448

525

# Unless otherwise indicated, the constants and types below are

449

526

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

450

527

451

528

# Constants

452

529

E_SUCCESS = 0

530

E_INTERRUPTED = -52

531

E_AGAIN = -28

453

532

CRT_OPENPGP = 2

454

533

CLIENT = 2

455

534

SHUT_RDWR = 0

456

535

CRD_CERTIFICATE = 1

457

536

E_NO_CERTIFICATE_FOUND = -49

458

537

OPENPGP_FMT_RAW = 0 # gnutls/openpgp.h

459

538

460

539

# Types

461

540

class session_int(ctypes.Structure):

462

541

_fields_ = []

463

542

session_t = ctypes.POINTER(session_int)

543

464

544

class certificate_credentials_st(ctypes.Structure):

465

545

_fields_ = []

466

546

certificate_credentials_t = ctypes.POINTER(

467

547

certificate_credentials_st)

468

548

certificate_type_t = ctypes.c_int

549

469

550

class datum_t(ctypes.Structure):

470

551

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

471

552

('size', ctypes.c_uint)]

553

472

554

class openpgp_crt_int(ctypes.Structure):

473

555

_fields_ = []

474

556

openpgp_crt_t = ctypes.POINTER(openpgp_crt_int)

475

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

557

openpgp_crt_fmt_t = ctypes.c_int # gnutls/openpgp.h

476

558

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

477

credentials_type_t = ctypes.c_int #

559

credentials_type_t = ctypes.c_int

478

560

transport_ptr_t = ctypes.c_void_p

479

561

close_request_t = ctypes.c_int

480

562

481

563

# Exceptions

482

564

class Error(Exception):

483

565

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

484

566

# exception might be raised from within GnuTLS.__init__,

485

567

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

486

# global variable happens.

487

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

568

# global variable has happened.

569

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

488

570

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

489

571

# code is passed, convert it to a string with

490

572

# gnutls.strerror()

573

self.code = code

491

574

if message is None and code is not None:

492

575

message = GnuTLS.strerror(code)

493

576

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

494

577

message, *args)

495

578

496

579

class CertificateSecurityError(Error):

497

580

pass

498

581

499

582

# Classes

500

583

class Credentials(object):

501

584

def __init__(self):

503

586

gnutls.certificate_allocate_credentials(

504

587

ctypes.byref(self._c_object))

505

588

self.type = gnutls.CRD_CERTIFICATE

506

589

507

590

def __del__(self):

508

591

gnutls.certificate_free_credentials(self._c_object)

509

592

510

593

class ClientSession(object):

511

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

594

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

512

595

self._c_object = gnutls.session_t()

513

596

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

514

597

gnutls.set_default_priority(self._c_object)

522

605

ctypes.cast(credentials._c_object,

523

606

ctypes.c_void_p))

524

607

self.credentials = credentials

525

608

526

609

def __del__(self):

527

610

gnutls.deinit(self._c_object)

528

611

529

612

def handshake(self):

530

613

return gnutls.handshake(self._c_object)

531

614

532

615

def send(self, data):

533

616

data = bytes(data)

534

if not data:

535

return 0

536

return gnutls.record_send(self._c_object, data, len(data))

537

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

538

623

def bye(self):

539

624

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

540

541

# Error handling function

625

626

# Error handling functions

542

627

def _error_code(result):

543

628

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

544

629

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

545

630

if result >= 0:

546

631

return result

547

632

if result == gnutls.E_NO_CERTIFICATE_FOUND:

548

raise gnutls.CertificateSecurityError(code = result)

549

raise gnutls.Error(code = result)

550

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

551

645

# Unless otherwise indicated, the function declarations below are

552

646

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

553

647

554

648

# Functions

555

649

priority_set_direct = _library.gnutls_priority_set_direct

556

650

priority_set_direct.argtypes = [session_t, ctypes.c_char_p,

557

651

ctypes.POINTER(ctypes.c_char_p)]

558

652

priority_set_direct.restype = _error_code

559

653

560

654

init = _library.gnutls_init

561

655

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

562

656

init.restype = _error_code

563

657

564

658

set_default_priority = _library.gnutls_set_default_priority

565

659

set_default_priority.argtypes = [session_t]

566

660

set_default_priority.restype = _error_code

567

661

568

662

record_send = _library.gnutls_record_send

569

663

record_send.argtypes = [session_t, ctypes.c_void_p,

570

664

ctypes.c_size_t]

571

665

record_send.restype = ctypes.c_ssize_t

572

666

record_send.errcheck = _retry_on_error

667

573

668

certificate_allocate_credentials = (

574

669

_library.gnutls_certificate_allocate_credentials)

575

670

certificate_allocate_credentials.argtypes = [

576

671

ctypes.POINTER(certificate_credentials_t)]

577

672

certificate_allocate_credentials.restype = _error_code

578

673

579

674

certificate_free_credentials = (

580

675

_library.gnutls_certificate_free_credentials)

581

certificate_free_credentials.argtypes = [certificate_credentials_t]

676

certificate_free_credentials.argtypes = [

677

certificate_credentials_t]

582

678

certificate_free_credentials.restype = None

583

679

584

680

handshake_set_private_extensions = (

585

681

_library.gnutls_handshake_set_private_extensions)

586

682

handshake_set_private_extensions.argtypes = [session_t,

587

683

ctypes.c_int]

588

684

handshake_set_private_extensions.restype = None

589

685

590

686

credentials_set = _library.gnutls_credentials_set

591

687

credentials_set.argtypes = [session_t, credentials_type_t,

592

688

ctypes.c_void_p]

593

689

credentials_set.restype = _error_code

594

690

595

691

strerror = _library.gnutls_strerror

596

692

strerror.argtypes = [ctypes.c_int]

597

693

strerror.restype = ctypes.c_char_p

598

694

599

695

certificate_type_get = _library.gnutls_certificate_type_get

600

696

certificate_type_get.argtypes = [session_t]

601

697

certificate_type_get.restype = _error_code

602

698

603

699

certificate_get_peers = _library.gnutls_certificate_get_peers

604

700

certificate_get_peers.argtypes = [session_t,

605

701

ctypes.POINTER(ctypes.c_uint)]

606

702

certificate_get_peers.restype = ctypes.POINTER(datum_t)

607

703

608

704

global_set_log_level = _library.gnutls_global_set_log_level

609

705

global_set_log_level.argtypes = [ctypes.c_int]

610

706

global_set_log_level.restype = None

611

707

612

708

global_set_log_function = _library.gnutls_global_set_log_function

613

709

global_set_log_function.argtypes = [log_func]

614

710

global_set_log_function.restype = None

615

711

616

712

deinit = _library.gnutls_deinit

617

713

deinit.argtypes = [session_t]

618

714

deinit.restype = None

619

715

620

716

handshake = _library.gnutls_handshake

621

717

handshake.argtypes = [session_t]

622

718

handshake.restype = _error_code

623

719

handshake.errcheck = _retry_on_error

720

624

721

transport_set_ptr = _library.gnutls_transport_set_ptr

625

722

transport_set_ptr.argtypes = [session_t, transport_ptr_t]

626

723

transport_set_ptr.restype = None

627

724

628

725

bye = _library.gnutls_bye

629

726

bye.argtypes = [session_t, close_request_t]

630

727

bye.restype = _error_code

631

728

bye.errcheck = _retry_on_error

729

632

730

check_version = _library.gnutls_check_version

633

731

check_version.argtypes = [ctypes.c_char_p]

634

732

check_version.restype = ctypes.c_char_p

635

733

636

734

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

637

735

638

736

openpgp_crt_init = _library.gnutls_openpgp_crt_init

639

737

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

640

738

openpgp_crt_init.restype = _error_code

641

739

642

740

openpgp_crt_import = _library.gnutls_openpgp_crt_import

643

741

openpgp_crt_import.argtypes = [openpgp_crt_t,

644

742

ctypes.POINTER(datum_t),

645

743

openpgp_crt_fmt_t]

646

744

openpgp_crt_import.restype = _error_code

647

745

648

746

openpgp_crt_verify_self = _library.gnutls_openpgp_crt_verify_self

649

747

openpgp_crt_verify_self.argtypes = [openpgp_crt_t, ctypes.c_uint,

650

748

ctypes.POINTER(ctypes.c_uint)]

651

749

openpgp_crt_verify_self.restype = _error_code

652

750

653

751

openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

654

752

openpgp_crt_deinit.argtypes = [openpgp_crt_t]

655

753

openpgp_crt_deinit.restype = None

656

754

657

755

openpgp_crt_get_fingerprint = (

658

756

_library.gnutls_openpgp_crt_get_fingerprint)

659

757

openpgp_crt_get_fingerprint.argtypes = [openpgp_crt_t,

661

759

ctypes.POINTER(

662

760

ctypes.c_size_t)]

663

761

openpgp_crt_get_fingerprint.restype = _error_code

664

665

# Remove non-public function

666

del _error_code

762

763

# Remove non-public functions

764

del _error_code, _retry_on_error

667

765

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

668

766

gnutls = GnuTLS()

669

767

768

670

769

def call_pipe(connection, # : multiprocessing.Connection

671

770

func, *args, **kwargs):

672

771

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

673

772

674

773

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

675

774

return value on the provided multiprocessing.Connection.

676

775

"""

677

776

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

678

777

connection.close()

679

778

779

680

780

class Client(object):

681

781

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

682

782

683

783

Attributes:

684

784

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

685

785

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

687

787

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

688

788

to see if the client lives.

689

789

'None' if no process is running.

690

checker_callback_tag: a gobject event source tag, or None

790

checker_callback_tag: a GLib event source tag, or None

691

791

checker_command: string; External command which is run to check

692

792

if client lives. %() expansions are done at

693

793

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

694

794

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

695

checker_initiator_tag: a gobject event source tag, or None

795

checker_initiator_tag: a GLib event source tag, or None

696

796

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

697

797

client_structure: Object describing what attributes a client has

698

798

and is used for storing the client at exit

699

799

current_checker_command: string; current running checker_command

700

disable_initiator_tag: a gobject event source tag, or None

800

disable_initiator_tag: a GLib event source tag, or None

701

801

enabled: bool()

702

802

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

703

803

uniquely identify the client

722

822

disabled, or None

723

823

server_settings: The server_settings dict from main()

724

824

"""

725

825

726

826

runtime_expansions = ("approval_delay", "approval_duration",

727

827

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

728

828

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

739

839

"approved_by_default": "True",

740

840

"enabled": "True",

741

841

}

742

842

743

843

@staticmethod

744

844

def config_parser(config):

745

845

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

752

852

for client_name in config.sections():

753

853

section = dict(config.items(client_name))

754

854

client = settings[client_name] = {}

755

855

756

856

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

757

857

# Reformat values from string types to Python types

758

858

client["approved_by_default"] = config.getboolean(

759

859

client_name, "approved_by_default")

760

860

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

761

861

"enabled")

762

862

763

863

# Uppercase and remove spaces from fingerprint for later

764

864

# comparison purposes with return value from the

765

865

# fingerprint() function

766

866

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

767

867

.replace(" ", ""))

768

868

if "secret" in section:

769

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

869

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

870

.encode("utf-8"),

871

"base64")

770

872

elif "secfile" in section:

771

873

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

772

874

(section["secfile"])),

787

889

client["last_approval_request"] = None

788

890

client["last_checked_ok"] = None

789

891

client["last_checker_status"] = -2

790

892

791

893

return settings

792

793

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

894

895

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

794

896

self.name = name

795

897

if server_settings is None:

796

898

server_settings = {}

798

900

# adding all client settings

799

901

for setting, value in settings.items():

800

902

setattr(self, setting, value)

801

903

802

904

if self.enabled:

803

905

if not hasattr(self, "last_enabled"):

804

906

self.last_enabled = datetime.datetime.utcnow()

808

910

else:

809

911

self.last_enabled = None

810

912

self.expires = None

811

913

812

914

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

813

915

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

814

916

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

815

917

datetime.datetime.utcnow())

816

918

817

919

# attributes specific for this server instance

818

920

self.checker = None

819

921

self.checker_initiator_tag = None

825

927

self.changedstate = multiprocessing_manager.Condition(

826

928

multiprocessing_manager.Lock())

827

929

self.client_structure = [attr

828

for attr in self.__dict__.iterkeys()

930

for attr in self.__dict__.keys()

829

931

if not attr.startswith("_")]

830

932

self.client_structure.append("client_structure")

831

933

832

934

for name, t in inspect.getmembers(

833

935

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

834

936

if not name.startswith("_"):

835

937

self.client_structure.append(name)

836

938

837

939

# Send notice to process children that client state has changed

838

940

def send_changedstate(self):

839

941

with self.changedstate:

840

942

self.changedstate.notify_all()

841

943

842

944

def enable(self):

843

945

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

844

946

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

849

951

self.last_enabled = datetime.datetime.utcnow()

850

952

self.init_checker()

851

953

self.send_changedstate()

852

954

853

955

def disable(self, quiet=True):

854

956

"""Disable this client."""

855

957

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

857

959

if not quiet:

858

960

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

859

961

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

860

gobject.source_remove(self.disable_initiator_tag)

962

GLib.source_remove(self.disable_initiator_tag)

861

963

self.disable_initiator_tag = None

862

964

self.expires = None

863

965

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

864

gobject.source_remove(self.checker_initiator_tag)

966

GLib.source_remove(self.checker_initiator_tag)

865

967

self.checker_initiator_tag = None

866

968

self.stop_checker()

867

969

self.enabled = False

868

970

if not quiet:

869

971

self.send_changedstate()

870

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

972

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

871

973

return False

872

974

873

975

def __del__(self):

874

976

self.disable()

875

977

876

978

def init_checker(self):

877

979

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

878

980

# and every interval from then on.

879

981

if self.checker_initiator_tag is not None:

880

gobject.source_remove(self.checker_initiator_tag)

881

self.checker_initiator_tag = gobject.timeout_add(

982

GLib.source_remove(self.checker_initiator_tag)

983

self.checker_initiator_tag = GLib.timeout_add(

882

984

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

883

985

self.start_checker)

884

986

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

885

987

if self.disable_initiator_tag is not None:

886

gobject.source_remove(self.disable_initiator_tag)

887

self.disable_initiator_tag = gobject.timeout_add(

988

GLib.source_remove(self.disable_initiator_tag)

989

self.disable_initiator_tag = GLib.timeout_add(

888

990

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

889

991

# Also start a new checker *right now*.

890

992

self.start_checker()

891

993

892

994

def checker_callback(self, source, condition, connection,

893

995

command):

894

996

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

897

999

# Read return code from connection (see call_pipe)

898

1000

returncode = connection.recv()

899

1001

connection.close()

900

1002

901

1003

if returncode >= 0:

902

1004

self.last_checker_status = returncode

903

1005

self.last_checker_signal = None

913

1015

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

914

1016

vars(self))

915

1017

return False

916

1018

917

1019

def checked_ok(self):

918

1020

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

919

1021

self.last_checked_ok = datetime.datetime.utcnow()

920

1022

self.last_checker_status = 0

921

1023

self.last_checker_signal = None

922

1024

self.bump_timeout()

923

1025

924

1026

def bump_timeout(self, timeout=None):

925

1027

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

926

1028

if timeout is None:

927

1029

timeout = self.timeout

928

1030

if self.disable_initiator_tag is not None:

929

gobject.source_remove(self.disable_initiator_tag)

1031

GLib.source_remove(self.disable_initiator_tag)

930

1032

self.disable_initiator_tag = None

931

1033

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

932

self.disable_initiator_tag = gobject.timeout_add(

1034

self.disable_initiator_tag = GLib.timeout_add(

933

1035

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

934

1036

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

935

1037

936

1038

def need_approval(self):

937

1039

self.last_approval_request = datetime.datetime.utcnow()

938

1040

939

1041

def start_checker(self):

940

1042

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

941

1043

942

1044

If a checker already exists, leave it running and do

943

1045

nothing."""

944

1046

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

949

1051

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

950

1052

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

951

1053

# should be.

952

1054

953

1055

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

954

1056

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

955

1057

self.checker.join()

959

1061

# Escape attributes for the shell

960

1062

escaped_attrs = {

961

1063

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

962

for attr in self.runtime_expansions }

1064

for attr in self.runtime_expansions}

963

1065

try:

964

1066

command = self.checker_command % escaped_attrs

965

1067

except TypeError as error:

977

1079

# The exception is when not debugging but nevertheless

978

1080

# running in the foreground; use the previously

979

1081

# created wnull.

980

popen_args = { "close_fds": True,

981

"shell": True,

982

"cwd": "/" }

1082

popen_args = {"close_fds": True,

1083

"shell": True,

1084

"cwd": "/"}

983

1085

if (not self.server_settings["debug"]

984

1086

and self.server_settings["foreground"]):

985

1087

popen_args.update({"stdout": wnull,

986

"stderr": wnull })

987

pipe = multiprocessing.Pipe(duplex = False)

1088

"stderr": wnull})

1089

pipe = multiprocessing.Pipe(duplex=False)

988

1090

self.checker = multiprocessing.Process(

989

target = call_pipe,

990

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

991

kwargs = popen_args)

1091

target=call_pipe,

1092

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

1093

kwargs=popen_args)

992

1094

self.checker.start()

993

self.checker_callback_tag = gobject.io_add_watch(

994

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

1095

self.checker_callback_tag = GLib.io_add_watch(

1096

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

995

1097

self.checker_callback, pipe[0], command)

996

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

1098

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

997

1099

return True

998

1100

999

1101

def stop_checker(self):

1000

1102

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

1001

1103

if self.checker_callback_tag:

1002

gobject.source_remove(self.checker_callback_tag)

1104

GLib.source_remove(self.checker_callback_tag)

1003

1105

self.checker_callback_tag = None

1004

1106

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

1005

1107

return

1014

1116

byte_arrays=False):

1015

1117

"""Decorators for marking methods of a DBusObjectWithProperties to

1016

1118

become properties on the D-Bus.

1017

1119

1018

1120

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

1019

1121

and with one argument by "Set".

1020

1122

1021

1123

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

1022

1124

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

1023

1125

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

1027

1129

if byte_arrays and signature != "ay":

1028

1130

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

1029

1131

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

1030

1132

1031

1133

def decorator(func):

1032

1134

func._dbus_is_property = True

1033

1135

func._dbus_interface = dbus_interface

1036

1138

func._dbus_name = func.__name__

1037

1139

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

1038

1140

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

1039

func._dbus_get_args_options = {'byte_arrays': byte_arrays }

1141

func._dbus_get_args_options = {'byte_arrays': byte_arrays}

1040

1142

return func

1041

1143

1042

1144

return decorator

1043

1145

1044

1146

1045

1147

def dbus_interface_annotations(dbus_interface):

1046

1148

"""Decorator for marking functions returning interface annotations

1047

1149

1048

1150

Usage:

1049

1151

1050

1152

@dbus_interface_annotations("org.example.Interface")

1051

1153

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

1052

1154

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

1053

1155

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

1054

1156

"false"}

1055

1157

"""

1056

1158

1057

1159

def decorator(func):

1058

1160

func._dbus_is_interface = True

1059

1161

func._dbus_interface = dbus_interface

1060

1162

func._dbus_name = dbus_interface

1061

1163

return func

1062

1164

1063

1165

return decorator

1064

1166

1065

1167

1066

1168

def dbus_annotations(annotations):

1067

1169

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

1068

1170

Usage:

1069

1171

1070

1172

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

1071

1173

"org.freedesktop.DBus.Property."

1072

1174

"EmitsChangedSignal": "false"})

1074

1176

access="r")

1075

1177

def Property_dbus_property(self):

1076

1178

return dbus.Boolean(False)

1077

1179

1078

1180

See also the DBusObjectWithAnnotations class.

1079

1181

"""

1080

1182

1081

1183

def decorator(func):

1082

1184

func._dbus_annotations = annotations

1083

1185

return func

1084

1186

1085

1187

return decorator

1086

1188

1087

1189

1105

1207

1106

1208

class DBusObjectWithAnnotations(dbus.service.Object):

1107

1209

"""A D-Bus object with annotations.

1108

1210

1109

1211

Classes inheriting from this can use the dbus_annotations

1110

1212

decorator to add annotations to methods or signals.

1111

1213

"""

1112

1214

1113

1215

@staticmethod

1114

1216

def _is_dbus_thing(thing):

1115

1217

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

1116

1218

1117

1219

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

1118

1220

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

1119

1221

"""

1120

1222

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

1121

1223

False)

1122

1224

1123

1225

def _get_all_dbus_things(self, thing):

1124

1226

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

1125

1227

"""

1128

1230

for cls in self.__class__.__mro__

1129

1231

for name, athing in

1130

1232

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

1131

1233

1132

1234

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1133

out_signature = "s",

1134

path_keyword = 'object_path',

1135

connection_keyword = 'connection')

1235

out_signature="s",

1236

path_keyword='object_path',

1237

connection_keyword='connection')

1136

1238

def Introspect(self, object_path, connection):

1137

1239

"""Overloading of standard D-Bus method.

1138

1240

1139

1241

Inserts annotation tags on methods and signals.

1140

1242

"""

1141

1243

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

1142

1244

connection)

1143

1245

try:

1144

1246

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

1145

1247

1146

1248

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

1147

1249

# Add annotation tags

1148

1250

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

1175

1277

if_tag.appendChild(ann_tag)

1176

1278

# Fix argument name for the Introspect method itself

1177

1279

if (if_tag.getAttribute("name")

1178

== dbus.INTROSPECTABLE_IFACE):

1280

== dbus.INTROSPECTABLE_IFACE):

1179

1281

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

1180

1282

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

1181

1283

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

1194

1296

1195

1297

class DBusObjectWithProperties(DBusObjectWithAnnotations):

1196

1298

"""A D-Bus object with properties.

1197

1299

1198

1300

Classes inheriting from this can use the dbus_service_property

1199

1301

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

1200

1302

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

1201

1303

"""

1202

1304

1203

1305

def _get_dbus_property(self, interface_name, property_name):

1204

1306

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

1205

1307

property with the specified name and interface.

1210

1312

if (value._dbus_name == property_name

1211

1313

and value._dbus_interface == interface_name):

1212

1314

return value.__get__(self)

1213

1315

1214

1316

# No such property

1215

1317

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

1216

1318

self.dbus_object_path, interface_name, property_name))

1217

1319

1218

1320

@classmethod

1219

1321

def _get_all_interface_names(cls):

1220

1322

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

1223

1325

for x in (inspect.getmro(cls))

1224

1326

for attr in dir(x))

1225

1327

if name is not None)

1226

1328

1227

1329

@dbus.service.method(dbus.PROPERTIES_IFACE,

1228

1330

in_signature="ss",

1229

1331

out_signature="v")

1237

1339

if not hasattr(value, "variant_level"):

1238

1340

return value

1239

1341

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

1240

1342

1241

1343

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

1242

1344

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

1243

1345

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

1255

1357

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

1256

1358

for byte in value))

1257

1359

prop(value)

1258

1360

1259

1361

@dbus.service.method(dbus.PROPERTIES_IFACE,

1260

1362

in_signature="s",

1261

1363

out_signature="a{sv}")

1262

1364

def GetAll(self, interface_name):

1263

1365

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

1264

1366

standard.

1265

1367

1266

1368

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

1267

1369

"""

1268

1370

properties = {}

1279

1381

properties[name] = value

1280

1382

continue

1281

1383

properties[name] = type(value)(

1282

value, variant_level = value.variant_level + 1)

1384

value, variant_level=value.variant_level + 1)

1283

1385

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

1284

1386

1285

1387

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

1286

1388

def PropertiesChanged(self, interface_name, changed_properties,

1287

1389

invalidated_properties):

1289

1391

standard.

1290

1392

"""

1291

1393

pass

1292

1394

1293

1395

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1294

1396

out_signature="s",

1295

1397

path_keyword='object_path',

1296

1398

connection_keyword='connection')

1297

1399

def Introspect(self, object_path, connection):

1298

1400

"""Overloading of standard D-Bus method.

1299

1401

1300

1402

Inserts property tags and interface annotation tags.

1301

1403

"""

1302

1404

xmlstring = DBusObjectWithAnnotations.Introspect(self,

1304

1406

connection)

1305

1407

try:

1306

1408

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

1307

1409

1308

1410

def make_tag(document, name, prop):

1309

1411

e = document.createElement("property")

1310

1412

e.setAttribute("name", name)

1311

1413

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

1312

1414

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

1313

1415

return e

1314

1416

1315

1417

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

1316

1418

# Add property tags

1317

1419

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

1359

1461

exc_info=error)

1360

1462

return xmlstring

1361

1463

1464

1362

1465

try:

1363

1466

dbus.OBJECT_MANAGER_IFACE

1364

1467

except AttributeError:

1365

1468

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

1366

1469

1470

1367

1471

class DBusObjectWithObjectManager(DBusObjectWithAnnotations):

1368

1472

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

1369

1473

1370

1474

Classes inheriting from this exposes the standard

1371

1475

GetManagedObjects call and the InterfacesAdded and

1372

1476

InterfacesRemoved signals on the standard

1373

1477

"org.freedesktop.DBus.ObjectManager" interface.

1374

1478

1375

1479

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

1376

1480

manually.

1377

1481

"""

1378

1482

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

1379

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

1483

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

1380

1484

def GetManagedObjects(self):

1381

1485

"""This function must be overridden"""

1382

1486

raise NotImplementedError()

1383

1487

1384

1488

@dbus.service.signal(dbus.OBJECT_MANAGER_IFACE,

1385

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

1489

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

1386

1490

def InterfacesAdded(self, object_path, interfaces_and_properties):

1387

1491

pass

1388

1389

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

1492

1493

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

1390

1494

def InterfacesRemoved(self, object_path, interfaces):

1391

1495

pass

1392

1496

1393

1497

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

1394

out_signature = "s",

1395

path_keyword = 'object_path',

1396

connection_keyword = 'connection')

1498

out_signature="s",

1499

path_keyword='object_path',

1500

connection_keyword='connection')

1397

1501

def Introspect(self, object_path, connection):

1398

1502

"""Overloading of standard D-Bus method.

1399

1503

1400

1504

Override return argument name of GetManagedObjects to be

1401

1505

"objpath_interfaces_and_properties"

1402

1506

"""

1405

1509

connection)

1406

1510

try:

1407

1511

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

1408

1512

1409

1513

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

1410

1514

# Fix argument name for the GetManagedObjects method

1411

1515

if (if_tag.getAttribute("name")

1412

== dbus.OBJECT_MANAGER_IFACE):

1516

== dbus.OBJECT_MANAGER_IFACE):

1413

1517

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

1414

1518

if (cn.getAttribute("name")

1415

1519

== "GetManagedObjects"):

1425

1529

except (AttributeError, xml.dom.DOMException,

1426

1530

xml.parsers.expat.ExpatError) as error:

1427

1531

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

1428

exc_info = error)

1532

exc_info=error)

1429

1533

return xmlstring

1430

1534

1535

1431

1536

def datetime_to_dbus(dt, variant_level=0):

1432

1537

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

1433

1538

if dt is None:

1434

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

1539

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

1435

1540

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

1436

1541

1437

1542

1440

1545

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

1441

1546

interface names according to the "alt_interface_names" mapping.

1442

1547

Usage:

1443

1548

1444

1549

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

1445

1550

"net.example.AlternateInterface"})

1446

1551

class SampleDBusObject(dbus.service.Object):

1447

1552

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

1448

1553

def SampleDBusMethod():

1449

1554

pass

1450

1555

1451

1556

The above "SampleDBusMethod" on "SampleDBusObject" will be

1452

1557

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

1453

1558

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

1454

1559

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

1455

1560

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

1456

1561

1457

1562

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

1458

1563

(from DBusObjectWithProperties) and interfaces (from the

1459

1564

dbus_interface_annotations decorator).

1460

1565

"""

1461

1566

1462

1567

def wrapper(cls):

1463

1568

for orig_interface_name, alt_interface_name in (

1464

1569

alt_interface_names.items()):

1479

1584

interface_names.add(alt_interface)

1480

1585

# Is this a D-Bus signal?

1481

1586

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

1587

# Extract the original non-method undecorated

1588

# function by black magic

1482

1589

if sys.version_info.major == 2:

1483

# Extract the original non-method undecorated

1484

# function by black magic

1485

1590

nonmethod_func = (dict(

1486

1591

zip(attribute.func_code.co_freevars,

1487

1592

attribute.__closure__))

1488

1593

["func"].cell_contents)

1489

1594

else:

1490

nonmethod_func = attribute

1595

nonmethod_func = (dict(

1596

zip(attribute.__code__.co_freevars,

1597

attribute.__closure__))

1598

["func"].cell_contents)

1491

1599

# Create a new, but exactly alike, function

1492

1600

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

1493

1601

# with the alternate D-Bus interface name

1494

if sys.version_info.major == 2:

1495

new_function = types.FunctionType(

1496

nonmethod_func.func_code,

1497

nonmethod_func.func_globals,

1498

nonmethod_func.func_name,

1499

nonmethod_func.func_defaults,

1500

nonmethod_func.func_closure)

1501

else:

1502

new_function = types.FunctionType(

1503

nonmethod_func.__code__,

1504

nonmethod_func.__globals__,

1505

nonmethod_func.__name__,

1506

nonmethod_func.__defaults__,

1507

nonmethod_func.__closure__)

1602

new_function = copy_function(nonmethod_func)

1508

1603

new_function = (dbus.service.signal(

1509

1604

alt_interface,

1510

1605

attribute._dbus_signature)(new_function))

1514

1609

attribute._dbus_annotations)

1515

1610

except AttributeError:

1516

1611

pass

1612

1517

1613

# Define a creator of a function to call both the

1518

1614

# original and alternate functions, so both the

1519

1615

# original and alternate signals gets sent when

1522

1618

"""This function is a scope container to pass

1523

1619

func1 and func2 to the "call_both" function

1524

1620

outside of its arguments"""

1525

1621

1526

1622

@functools.wraps(func2)

1527

1623

def call_both(*args, **kwargs):

1528

1624

"""This function will emit two D-Bus

1529

1625

signals by calling func1 and func2"""

1530

1626

func1(*args, **kwargs)

1531

1627

func2(*args, **kwargs)

1532

# Make wrapper function look like a D-Bus signal

1628

# Make wrapper function look like a D-Bus

1629

# signal

1533

1630

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

1534

1631

if name.startswith("_dbus_"):

1535

1632

setattr(call_both, name, attr)

1536

1633

1537

1634

return call_both

1538

1635

# Create the "call_both" function and add it to

1539

1636

# the class

1549

1646

alt_interface,

1550

1647

attribute._dbus_in_signature,

1551

1648

attribute._dbus_out_signature)

1552

(types.FunctionType(attribute.func_code,

1553

attribute.func_globals,

1554

attribute.func_name,

1555

attribute.func_defaults,

1556

attribute.func_closure)))

1649

(copy_function(attribute)))

1557

1650

# Copy annotations, if any

1558

1651

try:

1559

1652

attr[attrname]._dbus_annotations = dict(

1571

1664

attribute._dbus_access,

1572

1665

attribute._dbus_get_args_options

1573

1666

["byte_arrays"])

1574

(types.FunctionType(

1575

attribute.func_code,

1576

attribute.func_globals,

1577

attribute.func_name,

1578

attribute.func_defaults,

1579

attribute.func_closure)))

1667

(copy_function(attribute)))

1580

1668

# Copy annotations, if any

1581

1669

try:

1582

1670

attr[attrname]._dbus_annotations = dict(

1591

1679

# to the class.

1592

1680

attr[attrname] = (

1593

1681

dbus_interface_annotations(alt_interface)

1594

(types.FunctionType(attribute.func_code,

1595

attribute.func_globals,

1596

attribute.func_name,

1597

attribute.func_defaults,

1598

attribute.func_closure)))

1682

(copy_function(attribute)))

1599

1683

if deprecate:

1600

1684

# Deprecate all alternate interfaces

1601

iname="_AlternateDBusNames_interface_annotation{}"

1685

iname = "_AlternateDBusNames_interface_annotation{}"

1602

1686

for interface_name in interface_names:

1603

1687

1604

1688

@dbus_interface_annotations(interface_name)

1605

1689

def func(self):

1606

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

1607

"true" }

1690

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

1691

"true"}

1608

1692

# Find an unused name

1609

1693

for aname in (iname.format(i)

1610

1694

for i in itertools.count()):

1614

1698

if interface_names:

1615

1699

# Replace the class with a new subclass of it with

1616

1700

# methods, signals, etc. as created above.

1617

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

1618

(cls, ), attr)

1701

if sys.version_info.major == 2:

1702

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

1703

(cls, ), attr)

1704

else:

1705

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

1706

(cls, ), attr)

1619

1707

return cls

1620

1708

1621

1709

return wrapper

1622

1710

1623

1711

1625

1713

"se.bsnet.fukt.Mandos"})

1626

1714

class ClientDBus(Client, DBusObjectWithProperties):

1627

1715

"""A Client class using D-Bus

1628

1716

1629

1717

Attributes:

1630

1718

dbus_object_path: dbus.ObjectPath

1631

1719

bus: dbus.SystemBus()

1632

1720

"""

1633

1721

1634

1722

runtime_expansions = (Client.runtime_expansions

1635

1723

+ ("dbus_object_path", ))

1636

1724

1637

1725

_interface = "se.recompile.Mandos.Client"

1638

1726

1639

1727

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

1640

1641

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

1728

1729

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

1642

1730

self.bus = bus

1643

1731

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

1644

1732

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

1650

1738

"/clients/" + client_object_name)

1651

1739

DBusObjectWithProperties.__init__(self, self.bus,

1652

1740

self.dbus_object_path)

1653

1741

1654

1742

def notifychangeproperty(transform_func, dbus_name,

1655

1743

type_func=lambda x: x,

1656

1744

variant_level=1,

1658

1746

_interface=_interface):

1659

1747

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

1660

1748

its changes to DBus.

1661

1749

1662

1750

transform_fun: Function that takes a value and a variant_level

1663

1751

and transforms it to a D-Bus type.

1664

1752

dbus_name: D-Bus name of the variable

1667

1755

variant_level: D-Bus variant level. Default: 1

1668

1756

"""

1669

1757

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

1670

1758

1671

1759

def setter(self, value):

1672

1760

if hasattr(self, "dbus_object_path"):

1673

1761

if (not hasattr(self, attrname) or

1680

1768

else:

1681

1769

dbus_value = transform_func(

1682

1770

type_func(value),

1683

variant_level = variant_level)

1771

variant_level=variant_level)

1684

1772

self.PropertyChanged(dbus.String(dbus_name),

1685

1773

dbus_value)

1686

1774

self.PropertiesChanged(

1687

1775

_interface,

1688

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

1689

dbus_value }),

1776

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

1777

dbus_value}),

1690

1778

dbus.Array())

1691

1779

setattr(self, attrname, value)

1692

1780

1693

1781

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

1694

1782

1695

1783

expires = notifychangeproperty(datetime_to_dbus, "Expires")

1696

1784

approvals_pending = notifychangeproperty(dbus.Boolean,

1697

1785

"ApprovalPending",

1698

type_func = bool)

1786

type_func=bool)

1699

1787

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

1700

1788

last_enabled = notifychangeproperty(datetime_to_dbus,

1701

1789

"LastEnabled")

1702

1790

checker = notifychangeproperty(

1703

1791

dbus.Boolean, "CheckerRunning",

1704

type_func = lambda checker: checker is not None)

1792

type_func=lambda checker: checker is not None)

1705

1793

last_checked_ok = notifychangeproperty(datetime_to_dbus,

1706

1794

"LastCheckedOK")

1707

1795

last_checker_status = notifychangeproperty(dbus.Int16,

1712

1800

"ApprovedByDefault")

1713

1801

approval_delay = notifychangeproperty(

1714

1802

dbus.UInt64, "ApprovalDelay",

1715

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

1803

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

1716

1804

approval_duration = notifychangeproperty(

1717

1805

dbus.UInt64, "ApprovalDuration",

1718

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

1806

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

1719

1807

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

1720

1808

timeout = notifychangeproperty(

1721

1809

dbus.UInt64, "Timeout",

1722

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

1810

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

1723

1811

extended_timeout = notifychangeproperty(

1724

1812

dbus.UInt64, "ExtendedTimeout",

1725

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

1813

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

1726

1814

interval = notifychangeproperty(

1727

1815

dbus.UInt64, "Interval",

1728

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

1816

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

1729

1817

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

1730

1818

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

1731

1819

invalidate_only=True)

1732

1820

1733

1821

del notifychangeproperty

1734

1822

1735

1823

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

1736

1824

try:

1737

1825

self.remove_from_connection()

1740

1828

if hasattr(DBusObjectWithProperties, "__del__"):

1741

1829

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

1742

1830

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

1743

1831

1744

1832

def checker_callback(self, source, condition,

1745

1833

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

1746

1834

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

1762

1850

| self.last_checker_signal),

1763

1851

dbus.String(command))

1764

1852

return ret

1765

1853

1766

1854

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

1767

1855

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

1768

1856

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

1772

1860

# Emit D-Bus signal

1773

1861

self.CheckerStarted(self.current_checker_command)

1774

1862

return r

1775

1863

1776

1864

def _reset_approved(self):

1777

1865

self.approved = None

1778

1866

return False

1779

1867

1780

1868

def approve(self, value=True):

1781

1869

self.approved = value

1782

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

1783

* 1000), self._reset_approved)

1870

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

1871

* 1000), self._reset_approved)

1784

1872

self.send_changedstate()

1785

1786

## D-Bus methods, signals & properties

1787

1788

## Interfaces

1789

1790

## Signals

1791

1873

1874

# D-Bus methods, signals & properties

1875

1876

# Interfaces

1877

1878

# Signals

1879

1792

1880

# CheckerCompleted - signal

1793

1881

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

1794

1882

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

1795

1883

"D-Bus signal"

1796

1884

pass

1797

1885

1798

1886

# CheckerStarted - signal

1799

1887

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

1800

1888

def CheckerStarted(self, command):

1801

1889

"D-Bus signal"

1802

1890

pass

1803

1891

1804

1892

# PropertyChanged - signal

1805

1893

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

1806

1894

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

1807

1895

def PropertyChanged(self, property, value):

1808

1896

"D-Bus signal"

1809

1897

pass

1810

1898

1811

1899

# GotSecret - signal

1812

1900

@dbus.service.signal(_interface)

1813

1901

def GotSecret(self):

1816

1904

server to mandos-client

1817

1905

"""

1818

1906

pass

1819

1907

1820

1908

# Rejected - signal

1821

1909

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

1822

1910

def Rejected(self, reason):

1823

1911

"D-Bus signal"

1824

1912

pass

1825

1913

1826

1914

# NeedApproval - signal

1827

1915

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

1828

1916

def NeedApproval(self, timeout, default):

1829

1917

"D-Bus signal"

1830

1918

return self.need_approval()

1831

1832

## Methods

1833

1919

1920

# Methods

1921

1834

1922

# Approve - method

1835

1923

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

1836

1924

def Approve(self, value):

1837

1925

self.approve(value)

1838

1926

1839

1927

# CheckedOK - method

1840

1928

@dbus.service.method(_interface)

1841

1929

def CheckedOK(self):

1842

1930

self.checked_ok()

1843

1931

1844

1932

# Enable - method

1845

1933

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

1846

1934

@dbus.service.method(_interface)

1847

1935

def Enable(self):

1848

1936

"D-Bus method"

1849

1937

self.enable()

1850

1938

1851

1939

# StartChecker - method

1852

1940

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

1853

1941

@dbus.service.method(_interface)

1854

1942

def StartChecker(self):

1855

1943

"D-Bus method"

1856

1944

self.start_checker()

1857

1945

1858

1946

# Disable - method

1859

1947

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

1860

1948

@dbus.service.method(_interface)

1861

1949

def Disable(self):

1862

1950

"D-Bus method"

1863

1951

self.disable()

1864

1952

1865

1953

# StopChecker - method

1866

1954

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

1867

1955

@dbus.service.method(_interface)

1868

1956

def StopChecker(self):

1869

1957

self.stop_checker()

1870

1871

## Properties

1872

1958

1959

# Properties

1960

1873

1961

# ApprovalPending - property

1874

1962

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

1875

1963

def ApprovalPending_dbus_property(self):

1876

1964

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

1877

1965

1878

1966

# ApprovedByDefault - property

1879

1967

@dbus_service_property(_interface,

1880

1968

signature="b",

1883

1971

if value is None: # get

1884

1972

return dbus.Boolean(self.approved_by_default)

1885

1973

self.approved_by_default = bool(value)

1886

1974

1887

1975

# ApprovalDelay - property

1888

1976

@dbus_service_property(_interface,

1889

1977

signature="t",

1893

1981

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

1894

1982

* 1000)

1895

1983

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

1896

1984

1897

1985

# ApprovalDuration - property

1898

1986

@dbus_service_property(_interface,

1899

1987

signature="t",

1903

1991

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

1904

1992

* 1000)

1905

1993

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

1906

1994

1907

1995

# Name - property

1908

1996

@dbus_annotations(

1909

1997

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

1910

1998

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

1911

1999

def Name_dbus_property(self):

1912

2000

return dbus.String(self.name)

1913

2001

1914

2002

# Fingerprint - property

1915

2003

@dbus_annotations(

1916

2004

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

1917

2005

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

1918

2006

def Fingerprint_dbus_property(self):

1919

2007

return dbus.String(self.fingerprint)

1920

2008

1921

2009

# Host - property

1922

2010

@dbus_service_property(_interface,

1923

2011

signature="s",

1926

2014

if value is None: # get

1927

2015

return dbus.String(self.host)

1928

2016

self.host = str(value)

1929

2017

1930

2018

# Created - property

1931

2019

@dbus_annotations(

1932

2020

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

1933

2021

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

1934

2022

def Created_dbus_property(self):

1935

2023

return datetime_to_dbus(self.created)

1936

2024

1937

2025

# LastEnabled - property

1938

2026

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

1939

2027

def LastEnabled_dbus_property(self):

1940

2028

return datetime_to_dbus(self.last_enabled)

1941

2029

1942

2030

# Enabled - property

1943

2031

@dbus_service_property(_interface,

1944

2032

signature="b",

1950

2038

self.enable()

1951

2039

else:

1952

2040

self.disable()

1953

2041

1954

2042

# LastCheckedOK - property

1955

2043

@dbus_service_property(_interface,

1956

2044

signature="s",

1960

2048

self.checked_ok()

1961

2049

return

1962

2050

return datetime_to_dbus(self.last_checked_ok)

1963

2051

1964

2052

# LastCheckerStatus - property

1965

2053

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

1966

2054

def LastCheckerStatus_dbus_property(self):

1967

2055

return dbus.Int16(self.last_checker_status)

1968

2056

1969

2057

# Expires - property

1970

2058

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

1971

2059

def Expires_dbus_property(self):

1972

2060

return datetime_to_dbus(self.expires)

1973

2061

1974

2062

# LastApprovalRequest - property

1975

2063

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

1976

2064

def LastApprovalRequest_dbus_property(self):

1977

2065

return datetime_to_dbus(self.last_approval_request)

1978

2066

1979

2067

# Timeout - property

1980

2068

@dbus_service_property(_interface,

1981

2069

signature="t",

1996

2084

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

1997

2085

is None):

1998

2086

return

1999

gobject.source_remove(self.disable_initiator_tag)

2000

self.disable_initiator_tag = gobject.timeout_add(

2087

GLib.source_remove(self.disable_initiator_tag)

2088

self.disable_initiator_tag = GLib.timeout_add(

2001

2089

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

2002

2090

self.disable)

2003

2091

2004

2092

# ExtendedTimeout - property

2005

2093

@dbus_service_property(_interface,

2006

2094

signature="t",

2010

2098

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

2011

2099

* 1000)

2012

2100

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

2013

2101

2014

2102

# Interval - property

2015

2103

@dbus_service_property(_interface,

2016

2104

signature="t",

2023

2111

return

2024

2112

if self.enabled:

2025

2113

# Reschedule checker run

2026

gobject.source_remove(self.checker_initiator_tag)

2027

self.checker_initiator_tag = gobject.timeout_add(

2114

GLib.source_remove(self.checker_initiator_tag)

2115

self.checker_initiator_tag = GLib.timeout_add(

2028

2116

value, self.start_checker)

2029

self.start_checker() # Start one now, too

2030

2117

self.start_checker() # Start one now, too

2118

2031

2119

# Checker - property

2032

2120

@dbus_service_property(_interface,

2033

2121

signature="s",

2036

2124

if value is None: # get

2037

2125

return dbus.String(self.checker_command)

2038

2126

self.checker_command = str(value)

2039

2127

2040

2128

# CheckerRunning - property

2041

2129

@dbus_service_property(_interface,

2042

2130

signature="b",

2048

2136

self.start_checker()

2049

2137

else:

2050

2138

self.stop_checker()

2051

2139

2052

2140

# ObjectPath - property

2053

2141

@dbus_annotations(

2054

2142

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

2055

2143

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

2056

2144

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

2057

2145

def ObjectPath_dbus_property(self):

2058

return self.dbus_object_path # is already a dbus.ObjectPath

2059

2146

return self.dbus_object_path # is already a dbus.ObjectPath

2147

2060

2148

# Secret = property

2061

2149

@dbus_annotations(

2062

2150

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

2067

2155

byte_arrays=True)

2068

2156

def Secret_dbus_property(self, value):

2069

2157

self.secret = bytes(value)

2070

2158

2071

2159

del _interface

2072

2160

2073

2161

2077

2165

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

2078

2166

if not self._pipe.recv():

2079

2167

raise KeyError(fpr)

2080

2168

2081

2169

def __getattribute__(self, name):

2082

2170

if name == '_pipe':

2083

2171

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

2086

2174

if data[0] == 'data':

2087

2175

return data[1]

2088

2176

if data[0] == 'function':

2089

2177

2090

2178

def func(*args, **kwargs):

2091

2179

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

2092

2180

return self._pipe.recv()[1]

2093

2181

2094

2182

return func

2095

2183

2096

2184

def __setattr__(self, name, value):

2097

2185

if name == '_pipe':

2098

2186

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

2101

2189

2102

2190

class ClientHandler(socketserver.BaseRequestHandler, object):

2103

2191

"""A class to handle client connections.

2104

2192

2105

2193

Instantiated once for each connection to handle it.

2106

2194

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

2107

2195

2108

2196

def handle(self):

2109

2197

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

2110

2198

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

2111

2199

str(self.client_address))

2112

2200

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

2113

2201

self.server.child_pipe.fileno())

2114

2202

2115

2203

session = gnutls.ClientSession(self.request)

2116

2117

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

2118

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

2119

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

2120

# "+DHE-DSS"))

2204

2205

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

2206

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

2207

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

2208

# "+DHE-DSS"))

2121

2209

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

2122

2210

priority = self.server.gnutls_priority

2123

2211

if priority is None:

2124

2212

priority = "NORMAL"

2125

gnutls.priority_set_direct(session._c_object, priority,

2213

gnutls.priority_set_direct(session._c_object,

2214

priority.encode("utf-8"),

2126

2215

None)

2127

2216

2128

2217

# Start communication using the Mandos protocol

2129

2218

# Get protocol number

2130

2219

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

2135

2224

except (ValueError, IndexError, RuntimeError) as error:

2136

2225

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

2137

2226

return

2138

2227

2139

2228

# Start GnuTLS connection

2140

2229

try:

2141

2230

session.handshake()

2145

2234

# established. Just abandon the request.

2146

2235

return

2147

2236

logger.debug("Handshake succeeded")

2148

2237

2149

2238

approval_required = False

2150

2239

try:

2151

2240

try:

2155

2244

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

2156

2245

return

2157

2246

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

2158

2247

2159

2248

try:

2160

2249

client = ProxyClient(child_pipe, fpr,

2161

2250

self.client_address)

2162

2251

except KeyError:

2163

2252

return

2164

2253

2165

2254

if client.approval_delay:

2166

2255

delay = client.approval_delay

2167

2256

client.approvals_pending += 1

2168

2257

approval_required = True

2169

2258

2170

2259

while True:

2171

2260

if not client.enabled:

2172

2261

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

2175

2264

# Emit D-Bus signal

2176

2265

client.Rejected("Disabled")

2177

2266

return

2178

2267

2179

2268

if client.approved or not client.approval_delay:

2180

#We are approved or approval is disabled

2269

# We are approved or approval is disabled

2181

2270

break

2182

2271

elif client.approved is None:

2183

2272

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

2194

2283

# Emit D-Bus signal

2195

2284

client.Rejected("Denied")

2196

2285

return

2197

2198

#wait until timeout or approved

2286

2287

# wait until timeout or approved

2199

2288

time = datetime.datetime.now()

2200

2289

client.changedstate.acquire()

2201

2290

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

2214

2303

break

2215

2304

else:

2216

2305

delay -= time2 - time

2217

2218

sent_size = 0

2219

while sent_size < len(client.secret):

2220

try:

2221

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

2222

except gnutls.Error as error:

2223

logger.warning("gnutls send failed",

2224

exc_info=error)

2225

return

2226

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

2227

len(client.secret) - (sent_size

2228

+ sent))

2229

sent_size += sent

2230

2306

2307

try:

2308

session.send(client.secret)

2309

except gnutls.Error as error:

2310

logger.warning("gnutls send failed",

2311

exc_info=error)

2312

return

2313

2231

2314

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

2232

2315

# bump the timeout using extended_timeout

2233

2316

client.bump_timeout(client.extended_timeout)

2234

2317

if self.server.use_dbus:

2235

2318

# Emit D-Bus signal

2236

2319

client.GotSecret()

2237

2320

2238

2321

finally:

2239

2322

if approval_required:

2240

2323

client.approvals_pending -= 1

2243

2326

except gnutls.Error as error:

2244

2327

logger.warning("GnuTLS bye failed",

2245

2328

exc_info=error)

2246

2329

2247

2330

@staticmethod

2248

2331

def peer_certificate(session):

2249

2332

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

2261

2344

return None

2262

2345

cert = cert_list[0]

2263

2346

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

2264

2347

2265

2348

@staticmethod

2266

2349

def fingerprint(openpgp):

2267

2350

"Convert an OpenPGP bytestring to a hexdigit fingerprint"

2300

2383

2301

2384

class MultiprocessingMixIn(object):

2302

2385

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

2303

2386

2304

2387

def sub_process_main(self, request, address):

2305

2388

try:

2306

2389

self.finish_request(request, address)

2307

2390

except Exception:

2308

2391

self.handle_error(request, address)

2309

2392

self.close_request(request)

2310

2393

2311

2394

def process_request(self, request, address):

2312

2395

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

2313

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

2314

args = (request, address))

2396

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

2397

args=(request, address))

2315

2398

proc.start()

2316

2399

return proc

2317

2400

2318

2401

2319

2402

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

2320

2403

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

2321

2404

2322

2405

def process_request(self, request, client_address):

2323

2406

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

2324

2407

2325

2408

This function creates a new pipe in self.pipe

2326

2409

"""

2327

2410

parent_pipe, self.child_pipe = multiprocessing.Pipe()

2328

2411

2329

2412

proc = MultiprocessingMixIn.process_request(self, request,

2330

2413

client_address)

2331

2414

self.child_pipe.close()

2332

2415

self.add_pipe(parent_pipe, proc)

2333

2416

2334

2417

def add_pipe(self, parent_pipe, proc):

2335

2418

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

2336

2419

raise NotImplementedError()

2339

2422

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

2340

2423

socketserver.TCPServer, object):

2341

2424

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

2342

2425

2343

2426

Attributes:

2344

2427

enabled: Boolean; whether this server is activated yet

2345

2428

interface: None or a network interface name (string)

2346

2429

use_ipv6: Boolean; to use IPv6 or not

2347

2430

"""

2348

2431

2349

2432

def __init__(self, server_address, RequestHandlerClass,

2350

2433

interface=None,

2351

2434

use_ipv6=True,

2361

2444

self.socketfd = socketfd

2362

2445

# Save the original socket.socket() function

2363

2446

self.socket_socket = socket.socket

2447

2364

2448

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

2365

#

2449

#

2366

2450

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

2367

2451

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

2368

2452

# patching socket.socket.)

2369

#

2453

#

2370

2454

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

2371

2455

@functools.wraps(socket.socket)

2372

2456

def socket_wrapper(*args, **kwargs):

2384

2468

# socket_wrapper(), if socketfd was set.

2385

2469

socketserver.TCPServer.__init__(self, server_address,

2386

2470

RequestHandlerClass)

2387

2471

2388

2472

def server_bind(self):

2389

2473

"""This overrides the normal server_bind() function

2390

2474

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

2391

2475

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

2476

global SO_BINDTODEVICE

2392

2477

if self.interface is not None:

2393

2478

if SO_BINDTODEVICE is None:

2394

logger.error("SO_BINDTODEVICE does not exist;"

2395

" cannot bind to interface %s",

2396

self.interface)

2397

else:

2398

try:

2399

self.socket.setsockopt(

2400

socket.SOL_SOCKET, SO_BINDTODEVICE,

2401

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

2402

except socket.error as error:

2403

if error.errno == errno.EPERM:

2404

logger.error("No permission to bind to"

2405

" interface %s", self.interface)

2406

elif error.errno == errno.ENOPROTOOPT:

2407

logger.error("SO_BINDTODEVICE not available;"

2408

" cannot bind to interface %s",

2409

self.interface)

2410

elif error.errno == errno.ENODEV:

2411

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

2412

" cannot bind", self.interface)

2413

else:

2414

raise

2479

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

2480

# common enough.

2481

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

2482

SO_BINDTODEVICE = 25

2483

try:

2484

self.socket.setsockopt(

2485

socket.SOL_SOCKET, SO_BINDTODEVICE,

2486

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

2487

except socket.error as error:

2488

if error.errno == errno.EPERM:

2489

logger.error("No permission to bind to"

2490

" interface %s", self.interface)

2491

elif error.errno == errno.ENOPROTOOPT:

2492

logger.error("SO_BINDTODEVICE not available;"

2493

" cannot bind to interface %s",

2494

self.interface)

2495

elif error.errno == errno.ENODEV:

2496

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

2497

" cannot bind", self.interface)

2498

else:

2499

raise

2415

2500

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

2416

2501

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

2417

2502

if not self.server_address[0]:

2418

2503

if self.address_family == socket.AF_INET6:

2419

any_address = "::" # in6addr_any

2504

any_address = "::" # in6addr_any

2420

2505

else:

2421

any_address = "0.0.0.0" # INADDR_ANY

2506

any_address = "0.0.0.0" # INADDR_ANY

2422

2507

self.server_address = (any_address,

2423

2508

self.server_address[1])

2424

2509

elif not self.server_address[1]:

2434

2519

2435

2520

class MandosServer(IPv6_TCPServer):

2436

2521

"""Mandos server.

2437

2522

2438

2523

Attributes:

2439

2524

clients: set of Client objects

2440

2525

gnutls_priority GnuTLS priority string

2441

2526

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

2442

2443

Assumes a gobject.MainLoop event loop.

2527

2528

Assumes a GLib.MainLoop event loop.

2444

2529

"""

2445

2530

2446

2531

def __init__(self, server_address, RequestHandlerClass,

2447

2532

interface=None,

2448

2533

use_ipv6=True,

2458

2543

self.gnutls_priority = gnutls_priority

2459

2544

IPv6_TCPServer.__init__(self, server_address,

2460

2545

RequestHandlerClass,

2461

interface = interface,

2462

use_ipv6 = use_ipv6,

2463

socketfd = socketfd)

2464

2546

interface=interface,

2547

use_ipv6=use_ipv6,

2548

socketfd=socketfd)

2549

2465

2550

def server_activate(self):

2466

2551

if self.enabled:

2467

2552

return socketserver.TCPServer.server_activate(self)

2468

2553

2469

2554

def enable(self):

2470

2555

self.enabled = True

2471

2556

2472

2557

def add_pipe(self, parent_pipe, proc):

2473

2558

# Call "handle_ipc" for both data and EOF events

2474

gobject.io_add_watch(

2559

GLib.io_add_watch(

2475

2560

parent_pipe.fileno(),

2476

gobject.IO_IN | gobject.IO_HUP,

2561

GLib.IO_IN | GLib.IO_HUP,

2477

2562

functools.partial(self.handle_ipc,

2478

parent_pipe = parent_pipe,

2479

proc = proc))

2480

2563

parent_pipe=parent_pipe,

2564

proc=proc))

2565

2481

2566

def handle_ipc(self, source, condition,

2482

2567

parent_pipe=None,

2483

proc = None,

2568

proc=None,

2484

2569

client_object=None):

2485

2570

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

2486

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

2571

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

2487

2572

# Wait for other process to exit

2488

2573

proc.join()

2489

2574

return False

2490

2575

2491

2576

# Read a request from the child

2492

2577

request = parent_pipe.recv()

2493

2578

command = request[0]

2494

2579

2495

2580

if command == 'init':

2496

2581

fpr = request[1]

2497

2582

address = request[2]

2498

2499

for c in self.clients.itervalues():

2583

2584

for c in self.clients.values():

2500

2585

if c.fingerprint == fpr:

2501

2586

client = c

2502

2587

break

2509

2594

address[0])

2510

2595

parent_pipe.send(False)

2511

2596

return False

2512

2513

gobject.io_add_watch(

2597

2598

GLib.io_add_watch(

2514

2599

parent_pipe.fileno(),

2515

gobject.IO_IN | gobject.IO_HUP,

2600

GLib.IO_IN | GLib.IO_HUP,

2516

2601

functools.partial(self.handle_ipc,

2517

parent_pipe = parent_pipe,

2518

proc = proc,

2519

client_object = client))

2602

parent_pipe=parent_pipe,

2603

proc=proc,

2604

client_object=client))

2520

2605

parent_pipe.send(True)

2521

2606

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

2522

2607

# same fileno

2525

2610

funcname = request[1]

2526

2611

args = request[2]

2527

2612

kwargs = request[3]

2528

2613

2529

2614

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

2530

2615

funcname)(*args,

2531

2616

**kwargs)))

2532

2617

2533

2618

if command == 'getattr':

2534

2619

attrname = request[1]

2535

2620

if isinstance(client_object.__getattribute__(attrname),

2538

2623

else:

2539

2624

parent_pipe.send((

2540

2625

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

2541

2626

2542

2627

if command == 'setattr':

2543

2628

attrname = request[1]

2544

2629

value = request[2]

2545

2630

setattr(client_object, attrname, value)

2546

2631

2547

2632

return True

2548

2633

2549

2634

2550

2635

def rfc3339_duration_to_delta(duration):

2551

2636

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

2552

2637

2553

2638

>>> rfc3339_duration_to_delta("P7D")

2554

2639

datetime.timedelta(7)

2555

2640

>>> rfc3339_duration_to_delta("PT60S")

2565

2650

>>> rfc3339_duration_to_delta("P1DT3M20S")

2566

2651

datetime.timedelta(1, 200)

2567

2652

"""

2568

2653

2569

2654

# Parsing an RFC 3339 duration with regular expressions is not

2570

2655

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

2571

2656

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

2572

2657

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

2573

2658

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

2574

2659

# avoid excessive use of external libraries.

2575

2660

2576

2661

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

2577

2662

Token = collections.namedtuple("Token", (

2578

2663

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

2611

2696

frozenset((token_year, token_month,

2612

2697

token_day, token_time,

2613

2698

token_week)))

2614

# Define starting values

2615

value = datetime.timedelta() # Value so far

2699

# Define starting values:

2700

# Value so far

2701

value = datetime.timedelta()

2616

2702

found_token = None

2617

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

2618

s = duration # String left to parse

2703

# Following valid tokens

2704

followers = frozenset((token_duration, ))

2705

# String left to parse

2706

s = duration

2619

2707

# Loop until end token is found

2620

2708

while found_token is not token_end:

2621

2709

# Search for any currently valid tokens

2645

2733

2646

2734

def string_to_delta(interval):

2647

2735

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

2648

2736

2649

2737

>>> string_to_delta('7d')

2650

2738

datetime.timedelta(7)

2651

2739

>>> string_to_delta('60s')

2659

2747

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

2660

2748

datetime.timedelta(0, 330)

2661

2749

"""

2662

2750

2663

2751

try:

2664

2752

return rfc3339_duration_to_delta(interval)

2665

2753

except ValueError:

2666

2754

pass

2667

2755

2668

2756

timevalue = datetime.timedelta(0)

2669

2757

for s in interval.split():

2670

2758

try:

2688

2776

return timevalue

2689

2777

2690

2778

2691

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

2779

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

2692

2780

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

2693

2781

2694

2782

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

2695

2783

if os.fork():

2696

2784

sys.exit()

2714

2802

2715

2803

2716

2804

def main():

2717

2805

2718

2806

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

2719

2807

# Parsing of options, both command line and config file

2720

2808

2721

2809

parser = argparse.ArgumentParser()

2722

2810

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

2723

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

2811

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

2724

2812

help="show version number and exit")

2725

2813

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

2726

2814

help="Bind to interface IF")

2762

2850

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

2763

2851

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

2764

2852

default=None)

2765

2853

2766

2854

options = parser.parse_args()

2767

2855

2768

2856

if options.check:

2769

2857

import doctest

2770

2858

fail_count, test_count = doctest.testmod()

2771

2859

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

2772

2860

2773

2861

# Default values for config file for server-global settings

2774

server_defaults = { "interface": "",

2775

"address": "",

2776

"port": "",

2777

"debug": "False",

2778

"priority":

2779

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

2780

":+SIGN-DSA-SHA256",

2781

"servicename": "Mandos",

2782

"use_dbus": "True",

2783

"use_ipv6": "True",

2784

"debuglevel": "",

2785

"restore": "True",

2786

"socket": "",

2787

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

2788

"foreground": "False",

2789

"zeroconf": "True",

2790

}

2791

2862

server_defaults = {"interface": "",

2863

"address": "",

2864

"port": "",

2865

"debug": "False",

2866

"priority":

2867

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

2868

":+SIGN-DSA-SHA256",

2869

"servicename": "Mandos",

2870

"use_dbus": "True",

2871

"use_ipv6": "True",

2872

"debuglevel": "",

2873

"restore": "True",

2874

"socket": "",

2875

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

2876

"foreground": "False",

2877

"zeroconf": "True",

2878

}

2879

2792

2880

# Parse config file for server-global settings

2793

2881

server_config = configparser.SafeConfigParser(server_defaults)

2794

2882

del server_defaults

2796

2884

# Convert the SafeConfigParser object to a dict

2797

2885

server_settings = server_config.defaults()

2798

2886

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

2799

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

2887

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

2888

"foreground", "zeroconf"):

2800

2889

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

2801

2890

option)

2802

2891

if server_settings["port"]:

2812

2901

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

2813

2902

["socket"])

2814

2903

del server_config

2815

2904

2816

2905

# Override the settings from the config file with command line

2817

2906

# options, if set.

2818

2907

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

2836

2925

if server_settings["debug"]:

2837

2926

server_settings["foreground"] = True

2838

2927

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

2839

2928

2840

2929

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

2841

2930

2842

2931

if (not server_settings["zeroconf"]

2843

2932

and not (server_settings["port"]

2844

2933

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

2845

2934

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

2846

2935

2847

2936

# For convenience

2848

2937

debug = server_settings["debug"]

2849

2938

debuglevel = server_settings["debuglevel"]

2853

2942

stored_state_file)

2854

2943

foreground = server_settings["foreground"]

2855

2944

zeroconf = server_settings["zeroconf"]

2856

2945

2857

2946

if debug:

2858

2947

initlogger(debug, logging.DEBUG)

2859

2948

else:

2862

2951

else:

2863

2952

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

2864

2953

initlogger(debug, level)

2865

2954

2866

2955

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

2867

2956

syslogger.setFormatter(

2868

2957

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

2869

2958

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

2870

2959

server_settings["servicename"])))

2871

2960

2872

2961

# Parse config file with clients

2873

2962

client_config = configparser.SafeConfigParser(Client

2874

2963

.client_defaults)

2875

2964

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

2876

2965

"clients.conf"))

2877

2966

2878

2967

global mandos_dbus_service

2879

2968

mandos_dbus_service = None

2880

2969

2881

2970

socketfd = None

2882

2971

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

2883

2972

socketfd = server_settings["socket"]

2899

2988

except IOError as e:

2900

2989

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

2901

2990

exc_info=e)

2902

2903

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

2991

2992

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

2993

("mandos", "mandos"),

2994

("nobody", "nogroup")):

2904

2995

try:

2905

2996

uid = pwd.getpwnam(name).pw_uid

2906

gid = pwd.getpwnam(name).pw_gid

2997

gid = pwd.getpwnam(group).pw_gid

2907

2998

break

2908

2999

except KeyError:

2909

3000

continue

2913

3004

try:

2914

3005

os.setgid(gid)

2915

3006

os.setuid(uid)

3007

if debug:

3008

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

3009

gid))

2916

3010

except OSError as error:

3011

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

3012

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

2917

3013

if error.errno != errno.EPERM:

2918

3014

raise

2919

3015

2920

3016

if debug:

2921

3017

# Enable all possible GnuTLS debugging

2922

3018

2923

3019

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

2924

3020

# - GnuTLS manual

2925

3021

gnutls.global_set_log_level(11)

2926

3022

2927

3023

@gnutls.log_func

2928

3024

def debug_gnutls(level, string):

2929

3025

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

2930

3026

2931

3027

gnutls.global_set_log_function(debug_gnutls)

2932

3028

2933

3029

# Redirect stdin so all checkers get /dev/null

2934

3030

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

2935

3031

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

2936

3032

if null > 2:

2937

3033

os.close(null)

2938

3034

2939

3035

# Need to fork before connecting to D-Bus

2940

3036

if not foreground:

2941

3037

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

2942

3038

daemon()

2943

2944

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

2945

# need to inform gobject that threads will be used.

2946

gobject.threads_init()

2947

3039

3040

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

3041

# to inform GLib that threads will be used.

3042

GLib.threads_init()

3043

2948

3044

global main_loop

2949

3045

# From the Avahi example code

2950

3046

DBusGMainLoop(set_as_default=True)

2951

main_loop = gobject.MainLoop()

3047

main_loop = GLib.MainLoop()

2952

3048

bus = dbus.SystemBus()

2953

3049

# End of Avahi example code

2954

3050

if use_dbus:

2967

3063

if zeroconf:

2968

3064

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2969

3065

service = AvahiServiceToSyslog(

2970

name = server_settings["servicename"],

2971

servicetype = "_mandos._tcp",

2972

protocol = protocol,

2973

bus = bus)

3066

name=server_settings["servicename"],

3067

servicetype="_mandos._tcp",

3068

protocol=protocol,

3069

bus=bus)

2974

3070

if server_settings["interface"]:

2975

3071

service.interface = if_nametoindex(

2976

3072

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

2977

3073

2978

3074

global multiprocessing_manager

2979

3075

multiprocessing_manager = multiprocessing.Manager()

2980

3076

2981

3077

client_class = Client

2982

3078

if use_dbus:

2983

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

2984

3079

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

3080

2985

3081

client_settings = Client.config_parser(client_config)

2986

3082

old_client_settings = {}

2987

3083

clients_data = {}

2988

3084

2989

3085

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

2990

3086

global wnull

2991

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

3087

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

2992

3088

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

2993

3089

# mode

2994

3090

if debug or not foreground:

2995

3091

wnull.close()

2996

3092

2997

3093

# Get client data and settings from last running state.

2998

3094

if server_settings["restore"]:

2999

3095

try:

3000

3096

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

3001

clients_data, old_client_settings = pickle.load(

3002

stored_state)

3097

if sys.version_info.major == 2:

3098

clients_data, old_client_settings = pickle.load(

3099

stored_state)

3100

else:

3101

bytes_clients_data, bytes_old_client_settings = (

3102

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

3103

# Fix bytes to strings

3104

# clients_data

3105

# .keys()

3106

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

3107

if isinstance(key, bytes)

3108

else key): value

3109

for key, value in

3110

bytes_clients_data.items()}

3111

del bytes_clients_data

3112

for key in clients_data:

3113

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

3114

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

3115

for k, v in

3116

clients_data[key].items()}

3117

clients_data[key] = value

3118

# .client_structure

3119

value["client_structure"] = [

3120

(s.decode("utf-8")

3121

if isinstance(s, bytes)

3122

else s) for s in

3123

value["client_structure"]]

3124

# .name & .host

3125

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

3126

if isinstance(value[k], bytes):

3127

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

3128

# old_client_settings

3129

# .keys()

3130

old_client_settings = {

3131

(key.decode("utf-8")

3132

if isinstance(key, bytes)

3133

else key): value

3134

for key, value in

3135

bytes_old_client_settings.items()}

3136

del bytes_old_client_settings

3137

# .host

3138

for value in old_client_settings.values():

3139

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

3140

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

3141

.decode("utf-8"))

3003

3142

os.remove(stored_state_path)

3004

3143

except IOError as e:

3005

3144

if e.errno == errno.ENOENT:

3013

3152

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

3014

3153

"EOFError:",

3015

3154

exc_info=e)

3016

3155

3017

3156

with PGPEngine() as pgp:

3018

3157

for client_name, client in clients_data.items():

3019

3158

# Skip removed clients

3020

3159

if client_name not in client_settings:

3021

3160

continue

3022

3161

3023

3162

# Decide which value to use after restoring saved state.

3024

3163

# We have three different values: Old config file,

3025

3164

# new config file, and saved state.

3036

3175

client[name] = value

3037

3176

except KeyError:

3038

3177

pass

3039

3178

3040

3179

# Clients who has passed its expire date can still be

3041

3180

# enabled if its last checker was successful. A Client

3042

3181

# whose checker succeeded before we stored its state is

3075

3214

client_name))

3076

3215

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

3077

3216

["secret"])

3078

3217

3079

3218

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

3080

3219

for client_name in (set(old_client_settings)

3081

3220

- set(client_settings)):

3083

3222

for client_name in (set(client_settings)

3084

3223

- set(old_client_settings)):

3085

3224

clients_data[client_name] = client_settings[client_name]

3086

3225

3087

3226

# Create all client objects

3088

3227

for client_name, client in clients_data.items():

3089

3228

tcp_server.clients[client_name] = client_class(

3090

name = client_name,

3091

settings = client,

3092

server_settings = server_settings)

3093

3229

name=client_name,

3230

settings=client,

3231

server_settings=server_settings)

3232

3094

3233

if not tcp_server.clients:

3095

3234

logger.warning("No clients defined")

3096

3235

3097

3236

if not foreground:

3098

3237

if pidfile is not None:

3099

3238

pid = os.getpid()

3105

3244

pidfilename, pid)

3106

3245

del pidfile

3107

3246

del pidfilename

3108

3109

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

3110

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

3111

3247

3248

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

3249

GLib.unix_signal_add(GLib.PRIORITY_HIGH, termsig,

3250

lambda: main_loop.quit() and False)

3251

3112

3252

if use_dbus:

3113

3253

3114

3254

@alternate_dbus_interfaces(

3115

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

3255

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

3116

3256

class MandosDBusService(DBusObjectWithObjectManager):

3117

3257

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

3118

3258

3119

3259

def __init__(self):

3120

3260

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

3121

3261

3122

3262

_interface = "se.recompile.Mandos"

3123

3263

3124

3264

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

3125

3265

def ClientAdded(self, objpath):

3126

3266

"D-Bus signal"

3127

3267

pass

3128

3268

3129

3269

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

3130

3270

def ClientNotFound(self, fingerprint, address):

3131

3271

"D-Bus signal"

3132

3272

pass

3133

3273

3134

3274

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

3135

3275

"true"})

3136

3276

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

3137

3277

def ClientRemoved(self, objpath, name):

3138

3278

"D-Bus signal"

3139

3279

pass

3140

3280

3141

3281

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

3142

3282

"true"})

3143

3283

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

3144

3284

def GetAllClients(self):

3145

3285

"D-Bus method"

3146

3286

return dbus.Array(c.dbus_object_path for c in

3147

tcp_server.clients.itervalues())

3148

3287

tcp_server.clients.values())

3288

3149

3289

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

3150

3290

"true"})

3151

3291

@dbus.service.method(_interface,

3153

3293

def GetAllClientsWithProperties(self):

3154

3294

"D-Bus method"

3155

3295

return dbus.Dictionary(

3156

{ c.dbus_object_path: c.GetAll(

3296

{c.dbus_object_path: c.GetAll(

3157

3297

"se.recompile.Mandos.Client")

3158

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

3298

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

3159

3299

signature="oa{sv}")

3160

3300

3161

3301

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

3162

3302

def RemoveClient(self, object_path):

3163

3303

"D-Bus method"

3164

for c in tcp_server.clients.itervalues():

3304

for c in tcp_server.clients.values():

3165

3305

if c.dbus_object_path == object_path:

3166

3306

del tcp_server.clients[c.name]

3167

3307

c.remove_from_connection()

3171

3311

self.client_removed_signal(c)

3172

3312

return

3173

3313

raise KeyError(object_path)

3174

3314

3175

3315

del _interface

3176

3316

3177

3317

@dbus.service.method(dbus.OBJECT_MANAGER_IFACE,

3178

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

3318

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

3179

3319

def GetManagedObjects(self):

3180

3320

"""D-Bus method"""

3181

3321

return dbus.Dictionary(

3182

{ client.dbus_object_path:

3183

dbus.Dictionary(

3184

{ interface: client.GetAll(interface)

3185

for interface in

3186

client._get_all_interface_names()})

3187

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

3188

3322

{client.dbus_object_path:

3323

dbus.Dictionary(

3324

{interface: client.GetAll(interface)

3325

for interface in

3326

client._get_all_interface_names()})

3327

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

3328

3189

3329

def client_added_signal(self, client):

3190

3330

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

3191

3331

if use_dbus:

3193

3333

self.InterfacesAdded(

3194

3334

client.dbus_object_path,

3195

3335

dbus.Dictionary(

3196

{ interface: client.GetAll(interface)

3197

for interface in

3198

client._get_all_interface_names()}))

3336

{interface: client.GetAll(interface)

3337

for interface in

3338

client._get_all_interface_names()}))

3199

3339

# Old signal

3200

3340

self.ClientAdded(client.dbus_object_path)

3201

3341

3202

3342

def client_removed_signal(self, client):

3203

3343

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

3204

3344

if use_dbus:

3209

3349

# Old signal

3210

3350

self.ClientRemoved(client.dbus_object_path,

3211

3351

client.name)

3212

3352

3213

3353

mandos_dbus_service = MandosDBusService()

3214

3354

3355

# Save modules to variables to exempt the modules from being

3356

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

3357

mp = multiprocessing

3358

wn = wnull

3359

3215

3360

def cleanup():

3216

3361

"Cleanup function; run on exit"

3217

3362

if zeroconf:

3218

3363

service.cleanup()

3219

3220

multiprocessing.active_children()

3221

wnull.close()

3364

3365

mp.active_children()

3366

wn.close()

3222

3367

if not (tcp_server.clients or client_settings):

3223

3368

return

3224

3369

3225

3370

# Store client before exiting. Secrets are encrypted with key

3226

3371

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

3227

3372

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

3228

3373

clients = {}

3229

3374

with PGPEngine() as pgp:

3230

for client in tcp_server.clients.itervalues():

3375

for client in tcp_server.clients.values():

3231

3376

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

3232

3377

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

3233

3378

key)

3234

3379

client_dict = {}

3235

3380

3236

3381

# A list of attributes that can not be pickled

3237

3382

# + secret.

3238

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

3239

"checker", "server_settings" }

3383

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

3384

"checker", "server_settings"}

3240

3385

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

3241

3386

.Object):

3242

3387

exclude.add(name)

3243

3388

3244

3389

client_dict["encrypted_secret"] = (client

3245

3390

.encrypted_secret)

3246

3391

for attr in client.client_structure:

3247

3392

if attr not in exclude:

3248

3393

client_dict[attr] = getattr(client, attr)

3249

3394

3250

3395

clients[client.name] = client_dict

3251

3396

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

3252

3397

3253

3398

try:

3254

3399

with tempfile.NamedTemporaryFile(

3255

3400

mode='wb',

3257

3402

prefix='clients-',

3258

3403

dir=os.path.dirname(stored_state_path),

3259

3404

delete=False) as stored_state:

3260

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

3405

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

3406

protocol=2)

3261

3407

tempname = stored_state.name

3262

3408

os.rename(tempname, stored_state_path)

3263

3409

except (IOError, OSError) as e:

3273

3419

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

3274

3420

exc_info=e)

3275

3421

raise

3276

3422

3277

3423

# Delete all clients, and settings from config

3278

3424

while tcp_server.clients:

3279

3425

name, client = tcp_server.clients.popitem()

3285

3431

if use_dbus:

3286

3432

mandos_dbus_service.client_removed_signal(client)

3287

3433

client_settings.clear()

3288

3434

3289

3435

atexit.register(cleanup)

3290

3291

for client in tcp_server.clients.itervalues():

3436

3437

for client in tcp_server.clients.values():

3292

3438

if use_dbus:

3293

3439

# Emit D-Bus signal for adding

3294

3440

mandos_dbus_service.client_added_signal(client)

3295

3441

# Need to initiate checking of clients

3296

3442

if client.enabled:

3297

3443

client.init_checker()

3298

3444

3299

3445

tcp_server.enable()

3300

3446

tcp_server.server_activate()

3301

3447

3302

3448

# Find out what port we got

3303

3449

if zeroconf:

3304

3450

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

3309

3455

else: # IPv4

3310

3456

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

3311

3457

*tcp_server.socket.getsockname())

3312

3313

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

3314

3458

3459

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

3460

3315

3461

try:

3316

3462

if zeroconf:

3317

3463

# From the Avahi example code

3322

3468

cleanup()

3323

3469

sys.exit(1)

3324

3470

# End of Avahi example code

3325

3326

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

3327

lambda *args, **kwargs:

3328

(tcp_server.handle_request

3329

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

3330

3471

3472

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

3473

lambda *args, **kwargs:

3474

(tcp_server.handle_request

3475

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

3476

3331

3477

logger.debug("Starting main loop")

3332

3478

main_loop.run()

3333

3479

except AvahiError as error: